*/
/*
- * Copyright (C) 2013 Eric Biggers
+ * Copyright (C) 2013-2016 Eric Biggers
*
* This file is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
#include "wimlib/assert.h"
#include "wimlib/glob.h"
#include "wimlib/error.h"
+#include "wimlib/timestamp.h"
#include "wimlib/util.h"
static int
/* Use the Win32 API to get the number of processors. */
unsigned
-win32_get_number_of_processors(void)
+get_available_cpus(void)
{
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
/* Use the Win32 API to get the amount of available memory. */
u64
-win32_get_avail_memory(void)
+get_available_memory(void)
{
MEMORYSTATUSEX status = {
.dwLength = sizeof(status),
p = tmpname;
p = wmempcpy(p, dstpath, dstlen);
p = wmempcpy(p, orig_suffix, ARRAY_LEN(orig_suffix));
- randomize_char_array_with_alnum(p, num_rand_chars);
+ get_random_alnum_chars(p, num_rand_chars);
p += num_rand_chars;
*p = L'\0';
}
return 0;
}
+#define MAX_IO_AMOUNT 1048576
+
static int
do_pread_or_pwrite(int fd, void *buf, size_t count, off_t offset,
bool is_pwrite)
{
HANDLE h;
LARGE_INTEGER orig_offset;
- DWORD bytes_read_or_written;
+ DWORD result = 0xFFFFFFFF;
LARGE_INTEGER relative_offset;
OVERLAPPED overlapped;
BOOL bret;
+ DWORD err = 0;
h = (HANDLE)_get_osfhandle(fd);
if (h == INVALID_HANDLE_VALUE)
- goto err;
+ goto error;
if (GetFileType(h) == FILE_TYPE_PIPE) {
errno = ESPIPE;
- goto err;
+ goto error;
}
/* Get original position */
relative_offset.QuadPart = 0;
- if (!SetFilePointerEx(h, relative_offset, &orig_offset, FILE_CURRENT))
- goto err_set_errno;
+ if (!SetFilePointerEx(h, relative_offset, &orig_offset, FILE_CURRENT)) {
+ err = GetLastError();
+ win32_error(err, L"Failed to get original file position");
+ goto error;
+ }
memset(&overlapped, 0, sizeof(overlapped));
overlapped.Offset = offset;
overlapped.OffsetHigh = offset >> 32;
/* Do the read or write at the specified offset */
+ count = min(count, MAX_IO_AMOUNT);
+ SetLastError(0);
if (is_pwrite)
- bret = WriteFile(h, buf, count, &bytes_read_or_written, &overlapped);
+ bret = WriteFile(h, buf, count, &result, &overlapped);
else
- bret = ReadFile(h, buf, count, &bytes_read_or_written, &overlapped);
- if (!bret)
- goto err_set_errno;
+ bret = ReadFile(h, buf, count, &result, &overlapped);
+ if (!bret) {
+ err = GetLastError();
+ win32_error(err, L"Failed to %s %zu bytes at offset %"PRIu64,
+ (is_pwrite ? "write" : "read"), count, offset);
+ goto error;
+ }
+
+ wimlib_assert(result <= count);
/* Restore the original position */
- if (!SetFilePointerEx(h, orig_offset, NULL, FILE_BEGIN))
- goto err_set_errno;
+ if (!SetFilePointerEx(h, orig_offset, NULL, FILE_BEGIN)) {
+ err = GetLastError();
+ win32_error(err, L"Failed to restore file position to %"PRIu64,
+ offset);
+ goto error;
+ }
- return bytes_read_or_written;
-err_set_errno:
- set_errno_from_GetLastError();
-err:
+ return result;
+
+error:
+ if (err)
+ set_errno_from_win32_error(err);
return -1;
}
* offset, so it is not safe to use with readers/writers on the same file
* descriptor. */
ssize_t
-pread(int fd, void *buf, size_t count, off_t offset)
+win32_pread(int fd, void *buf, size_t count, off_t offset)
{
return do_pread_or_pwrite(fd, buf, count, offset, false);
}
* offset, so it is not safe to use with readers/writers on the same file
* descriptor. */
ssize_t
-pwrite(int fd, const void *buf, size_t count, off_t offset)
+win32_pwrite(int fd, const void *buf, size_t count, off_t offset)
{
return do_pread_or_pwrite(fd, (void*)buf, count, offset, true);
}
+/* Replacement for read() which doesn't hide the Win32 error code */
+ssize_t
+win32_read(int fd, void *buf, size_t count)
+{
+ HANDLE h = (HANDLE)_get_osfhandle(fd);
+ DWORD result = 0xFFFFFFFF;
+
+ if (h == INVALID_HANDLE_VALUE)
+ return -1;
+
+ count = min(count, MAX_IO_AMOUNT);
+ SetLastError(0);
+ if (!ReadFile(h, buf, count, &result, NULL)) {
+ DWORD err = GetLastError();
+ win32_error(err,
+ L"Error reading %zu bytes from fd %d", count, fd);
+ set_errno_from_win32_error(err);
+ return -1;
+ }
+
+ wimlib_assert(result <= count);
+ return result;
+}
+
+/* Replacement for write() which doesn't hide the Win32 error code */
+ssize_t
+win32_write(int fd, const void *buf, size_t count)
+{
+ HANDLE h = (HANDLE)_get_osfhandle(fd);
+ DWORD result = 0xFFFFFFFF;
+
+ if (h == INVALID_HANDLE_VALUE)
+ return -1;
+
+ count = min(count, MAX_IO_AMOUNT);
+ SetLastError(0);
+ if (!WriteFile(h, buf, count, &result, NULL)) {
+ DWORD err = GetLastError();
+ win32_error(err,
+ L"Error writing %zu bytes to fd %d", count, fd);
+ set_errno_from_win32_error(err);
+ return -1;
+ }
+
+ wimlib_assert(result <= count);
+ return result;
+}
+
/* Replacement for glob() in Windows native builds that operates on wide
* characters. */
int
return fp;
}
+#define RtlGenRandom SystemFunction036
+BOOLEAN WINAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
+
+/*
+ * Generate @n cryptographically secure random bytes (thread-safe)
+ *
+ * This is the Windows version. It uses RtlGenRandom() (actually called
+ * SystemFunction036) from advapi32.dll.
+ */
+void
+get_random_bytes(void *p, size_t n)
+{
+ while (n != 0) {
+ u32 count = min(n, UINT32_MAX);
+
+ if (!RtlGenRandom(p, count)) {
+ win32_error(GetLastError(),
+ L"RtlGenRandom() failed (count=%u)", count);
+ wimlib_assert(0);
+ count = 0;
+ }
+ p += count;
+ n -= count;
+ }
+}
+
+/* Retrieve the current time as a WIM timestamp. */
+u64
+now_as_wim_timestamp(void)
+{
+ FILETIME ft;
+
+ GetSystemTimeAsFileTime(&ft);
+
+ return ((u64)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
+}
+
#endif /* __WIN32__ */
git://wimlib.net / wimlib / blobdiff