/
physfs_platform_windows.c
1018 lines (840 loc) · 30.1 KB
1
/*
2
* Windows support routines for PhysicsFS.
3
*
4
* Please see the file LICENSE.txt in the source's root directory.
5
*
6
* This file written by Ryan C. Gordon, and made sane by Gregory S. Read.
7
8
*/
9
#define __PHYSICSFS_INTERNAL__
10
#include "physfs_internal.h"
11
12
#ifdef PHYSFS_PLATFORM_WINDOWS
13
14
/* Forcibly disable UNICODE macro, since we manage this ourselves. */
15
16
17
18
#ifdef UNICODE
#undef UNICODE
#endif
19
20
21
/* !!! FIXME: maybe clean out the "allocator" macro, eventually. */
#undef allocator /* apparently Windows 10 SDK conflicts here. */
22
#define WIN32_LEAN_AND_MEAN 1
23
#include <windows.h>
24
25
#ifndef PHYSFS_PLATFORM_WINRT
26
#include <userenv.h>
27
#include <shlobj.h>
28
29
30
#endif
#if !defined(PHYSFS_NO_CDROM_SUPPORT)
31
#include <dbt.h>
32
33
#endif
34
#include <errno.h>
35
#include <ctype.h>
36
#include <time.h>
37
38
39
40
41
42
#ifdef allocator /* apparently Windows 10 SDK conflicts here. */
#undef allocator
#endif
#define allocator __PHYSFS_AllocatorHooks
43
44
45
46
47
48
/*
* Users without the platform SDK don't have this defined. The original docs
* for SetFilePointer() just said to compare with 0xFFFFFFFF, so this should
* work as desired.
*/
#define PHYSFS_INVALID_SET_FILE_POINTER 0xFFFFFFFF
49
50
51
/* just in case... */
#define PHYSFS_INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
52
53
/* Not defined before the Vista SDK. */
54
#define PHYSFS_FILE_ATTRIBUTE_REPARSE_POINT 0x400
55
56
57
#define PHYSFS_IO_REPARSE_TAG_SYMLINK 0xA000000C
58
#define UTF8_TO_UNICODE_STACK(w_assignto, str) { \
59
60
61
if (str == NULL) \
w_assignto = NULL; \
else { \
62
const PHYSFS_uint64 len = (PHYSFS_uint64) ((strlen(str) + 1) * 2); \
63
64
w_assignto = (WCHAR *) __PHYSFS_smallAlloc(len); \
if (w_assignto != NULL) \
65
PHYSFS_utf8ToUtf16(str, (PHYSFS_uint16 *) w_assignto, len); \
66
67
} \
} \
68
69
/* Note this counts WCHARs, not codepoints! */
70
71
72
73
74
static PHYSFS_uint64 wStrLen(const WCHAR *wstr)
{
PHYSFS_uint64 len = 0;
while (*(wstr++))
len++;
75
return len;
76
77
78
79
80
81
82
83
84
85
} /* wStrLen */
static char *unicodeToUtf8Heap(const WCHAR *w_str)
{
char *retval = NULL;
if (w_str != NULL)
{
void *ptr = NULL;
const PHYSFS_uint64 len = (wStrLen(w_str) * 4) + 1;
retval = allocator.Malloc(len);
86
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
87
PHYSFS_utf8FromUtf16((const PHYSFS_uint16 *) w_str, retval, len);
88
89
90
91
ptr = allocator.Realloc(retval, strlen(retval) + 1); /* shrink. */
if (ptr != NULL)
retval = (char *) ptr;
} /* if */
92
return retval;
93
94
} /* unicodeToUtf8Heap */
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
/* Some older APIs aren't in WinRT (only the "Ex" version, etc).
Since non-WinRT might not have the "Ex" version, we tapdance to use
the perfectly-fine-and-available-even-on-Win95 API on non-WinRT targets. */
static inline HANDLE winFindFirstFileW(const WCHAR *path, LPWIN32_FIND_DATAW d)
{
#ifdef PHYSFS_PLATFORM_WINRT
return FindFirstFileExW(path, FindExInfoStandard, d,
FindExSearchNameMatch, NULL, 0);
#else
return FindFirstFileW(path, d);
#endif
} /* winFindFirstFileW */
static inline BOOL winInitializeCriticalSection(LPCRITICAL_SECTION lpcs)
{
#ifdef PHYSFS_PLATFORM_WINRT
return InitializeCriticalSectionEx(lpcs, 2000, 0);
#else
InitializeCriticalSection(lpcs);
return TRUE;
#endif
} /* winInitializeCriticalSection */
static inline HANDLE winCreateFileW(const WCHAR *wfname, const DWORD mode,
const DWORD creation)
{
const DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE;
#ifdef PHYSFS_PLATFORM_WINRT
return CreateFile2(wfname, mode, share, creation, NULL);
#else
return CreateFileW(wfname, mode, share, NULL, creation,
FILE_ATTRIBUTE_NORMAL, NULL);
#endif
} /* winCreateFileW */
static BOOL winSetFilePointer(HANDLE h, const PHYSFS_sint64 pos,
PHYSFS_sint64 *_newpos, const DWORD whence)
{
#ifdef PHYSFS_PLATFORM_WINRT
LARGE_INTEGER lipos;
LARGE_INTEGER linewpos;
BOOL rc;
lipos.QuadPart = (LONGLONG) pos;
rc = SetFilePointerEx(h, lipos, &linewpos, whence);
if (_newpos)
*_newpos = (PHYSFS_sint64) linewpos.QuadPart;
return rc;
#else
const LONG low = (LONG) (pos & 0xFFFFFFFF);
LONG high = (LONG) ((pos >> 32) & 0xFFFFFFFF);
const DWORD rc = SetFilePointer(h, low, &high, whence);
/* 0xFFFFFFFF could be valid, so you have to check GetLastError too! */
if (_newpos)
*_newpos = ((PHYSFS_sint64) rc) | (((PHYSFS_sint64) high) << 32);
if ((rc == PHYSFS_INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
return FALSE;
return TRUE;
#endif
} /* winSetFilePointer */
static PHYSFS_sint64 winGetFileSize(HANDLE h)
{
#ifdef PHYSFS_PLATFORM_WINRT
FILE_STANDARD_INFO info;
const BOOL rc = GetFileInformationByHandleEx(h, FileStandardInfo,
&info, sizeof (info));
return rc ? (PHYSFS_sint64) info.EndOfFile.QuadPart : -1;
#else
DWORD high = 0;
const DWORD rc = GetFileSize(h, &high);
if ((rc == PHYSFS_INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
return -1;
return (PHYSFS_sint64) ((((PHYSFS_uint64) high) << 32) | rc);
#endif
} /* winGetFileSize */
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
static PHYSFS_ErrorCode errcodeFromWinApiError(const DWORD err)
{
/*
* win32 error codes are sort of a tricky thing; Microsoft intentionally
* doesn't list which ones a given API might trigger, there are several
* with overlapping and unclear meanings...and there's 16 thousand of
* them in Windows 7. It looks like the ones we care about are in the
* first 500, but I can't say this list is perfect; we might miss
* important values or misinterpret others.
*
* Don't treat this list as anything other than a work in progress.
*/
switch (err)
187
{
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
case ERROR_SUCCESS: return PHYSFS_ERR_OK;
case ERROR_ACCESS_DENIED: return PHYSFS_ERR_PERMISSION;
case ERROR_NETWORK_ACCESS_DENIED: return PHYSFS_ERR_PERMISSION;
case ERROR_NOT_READY: return PHYSFS_ERR_IO;
case ERROR_CRC: return PHYSFS_ERR_IO;
case ERROR_SEEK: return PHYSFS_ERR_IO;
case ERROR_SECTOR_NOT_FOUND: return PHYSFS_ERR_IO;
case ERROR_NOT_DOS_DISK: return PHYSFS_ERR_IO;
case ERROR_WRITE_FAULT: return PHYSFS_ERR_IO;
case ERROR_READ_FAULT: return PHYSFS_ERR_IO;
case ERROR_DEV_NOT_EXIST: return PHYSFS_ERR_IO;
/* !!! FIXME: ?? case ELOOP: return PHYSFS_ERR_SYMLINK_LOOP; */
case ERROR_BUFFER_OVERFLOW: return PHYSFS_ERR_BAD_FILENAME;
case ERROR_INVALID_NAME: return PHYSFS_ERR_BAD_FILENAME;
case ERROR_BAD_PATHNAME: return PHYSFS_ERR_BAD_FILENAME;
case ERROR_DIRECTORY: return PHYSFS_ERR_BAD_FILENAME;
204
205
206
207
case ERROR_FILE_NOT_FOUND: return PHYSFS_ERR_NOT_FOUND;
case ERROR_PATH_NOT_FOUND: return PHYSFS_ERR_NOT_FOUND;
case ERROR_DELETE_PENDING: return PHYSFS_ERR_NOT_FOUND;
case ERROR_INVALID_DRIVE: return PHYSFS_ERR_NOT_FOUND;
208
209
case ERROR_HANDLE_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
case ERROR_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
210
/* !!! FIXME: ?? case ENOTDIR: return PHYSFS_ERR_NOT_FOUND; */
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
/* !!! FIXME: ?? case EISDIR: return PHYSFS_ERR_NOT_A_FILE; */
case ERROR_WRITE_PROTECT: return PHYSFS_ERR_READ_ONLY;
case ERROR_LOCK_VIOLATION: return PHYSFS_ERR_BUSY;
case ERROR_SHARING_VIOLATION: return PHYSFS_ERR_BUSY;
case ERROR_CURRENT_DIRECTORY: return PHYSFS_ERR_BUSY;
case ERROR_DRIVE_LOCKED: return PHYSFS_ERR_BUSY;
case ERROR_PATH_BUSY: return PHYSFS_ERR_BUSY;
case ERROR_BUSY: return PHYSFS_ERR_BUSY;
case ERROR_NOT_ENOUGH_MEMORY: return PHYSFS_ERR_OUT_OF_MEMORY;
case ERROR_OUTOFMEMORY: return PHYSFS_ERR_OUT_OF_MEMORY;
case ERROR_DIR_NOT_EMPTY: return PHYSFS_ERR_DIR_NOT_EMPTY;
default: return PHYSFS_ERR_OS_ERROR;
} /* switch */
} /* errcodeFromWinApiError */
static inline PHYSFS_ErrorCode errcodeFromWinApi(void)
{
return errcodeFromWinApiError(GetLastError());
} /* errcodeFromWinApi */
230
231
232
233
234
235
236
#if defined(PHYSFS_NO_CDROM_SUPPORT)
#define detectAvailableCDs(cb, data)
#define deinitCDThread()
#else
static HANDLE detectCDThreadHandle = NULL;
237
static HWND detectCDHwnd = NULL;
238
239
static volatile DWORD drivesWithMediaBitmap = 0;
240
typedef BOOL (WINAPI *fnSTEM)(DWORD, LPDWORD b);
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
static DWORD pollDiscDrives(void)
{
/* Try to use SetThreadErrorMode(), which showed up in Windows 7. */
HANDLE lib = LoadLibraryA("kernel32.dll");
fnSTEM stem = NULL;
char drive[4] = { 'x', ':', '\\', '\0' };
DWORD oldErrorMode = 0;
DWORD drives = 0;
DWORD i;
if (lib)
stem = (fnSTEM) GetProcAddress(lib, "SetThreadErrorMode");
if (stem)
stem(SEM_FAILCRITICALERRORS, &oldErrorMode);
else
oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
259
260
261
262
263
264
265
266
/* Do detection. This may block if a disc is spinning up. */
for (i = 'A'; i <= 'Z'; i++)
{
DWORD tmp = 0;
drive[0] = (char) i;
if (GetDriveTypeA(drive) != DRIVE_CDROM)
continue;
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
/* If this function succeeds, there's media in the drive */
if (GetVolumeInformationA(drive, NULL, 0, NULL, NULL, &tmp, NULL, 0))
drives |= (1 << (i - 'A'));
} /* for */
if (stem)
stem(oldErrorMode, NULL);
else
SetErrorMode(oldErrorMode);
if (lib)
FreeLibrary(lib);
return drives;
} /* pollDiscDrives */
static LRESULT CALLBACK detectCDWndProc(HWND hwnd, UINT msg,
WPARAM wp, LPARAM lparam)
{
PDEV_BROADCAST_HDR lpdb = (PDEV_BROADCAST_HDR) lparam;
PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME) lparam;
const int removed = (wp == DBT_DEVICEREMOVECOMPLETE);
if (msg == WM_DESTROY)
return 0;
else if ((msg != WM_DEVICECHANGE) ||
((wp != DBT_DEVICEARRIVAL) && (wp != DBT_DEVICEREMOVECOMPLETE)) ||
(lpdb->dbch_devicetype != DBT_DEVTYP_VOLUME) ||
((lpdbv->dbcv_flags & DBTF_MEDIA) == 0))
{
return DefWindowProcW(hwnd, msg, wp, lparam);
} /* else if */
if (removed)
drivesWithMediaBitmap &= ~lpdbv->dbcv_unitmask;
else
drivesWithMediaBitmap |= lpdbv->dbcv_unitmask;
return TRUE;
} /* detectCDWndProc */
311
static DWORD WINAPI detectCDThread(LPVOID arg)
312
{
313
HANDLE initialDiscDetectionComplete = *((HANDLE *) arg);
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
const char *classname = "PhysicsFSDetectCDCatcher";
const char *winname = "PhysicsFSDetectCDMsgWindow";
HINSTANCE hInstance = GetModuleHandleW(NULL);
ATOM class_atom = 0;
WNDCLASSEXA wce;
MSG msg;
memset(&wce, '\0', sizeof (wce));
wce.cbSize = sizeof (wce);
wce.lpfnWndProc = detectCDWndProc;
wce.lpszClassName = classname;
wce.hInstance = hInstance;
class_atom = RegisterClassExA(&wce);
if (class_atom == 0)
{
329
SetEvent(initialDiscDetectionComplete); /* let main thread go on. */
330
331
332
333
334
335
336
337
338
return 0;
} /* if */
detectCDHwnd = CreateWindowExA(0, classname, winname, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, HWND_DESKTOP, NULL, hInstance, NULL);
if (detectCDHwnd == NULL)
{
339
SetEvent(initialDiscDetectionComplete); /* let main thread go on. */
340
341
342
343
344
345
346
347
UnregisterClassA(classname, hInstance);
return 0;
} /* if */
/* We'll get events when discs come and go from now on. */
/* Do initial detection, possibly blocking awhile... */
drivesWithMediaBitmap = pollDiscDrives();
348
349
SetEvent(initialDiscDetectionComplete); /* let main thread go on. */
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
do
{
const BOOL rc = GetMessageW(&msg, detectCDHwnd, 0, 0);
if ((rc == 0) || (rc == -1))
break; /* don't care if WM_QUIT or error break this loop. */
TranslateMessage(&msg);
DispatchMessageW(&msg);
} while (1);
/* we've been asked to quit. */
DestroyWindow(detectCDHwnd);
UnregisterClassA(classname, hInstance);
return 0;
} /* detectCDThread */
365
366
static void detectAvailableCDs(PHYSFS_StringCallback cb, void *data)
367
{
368
369
370
371
372
373
374
375
376
377
378
379
380
char drive_str[4] = { 'x', ':', '\\', '\0' };
DWORD drives = 0;
DWORD i;
/*
* If you poll a drive while a user is inserting a disc, the OS will
* block this thread until the drive has spun up. So we swallow the risk
* once for initial detection, and spin a thread that will get device
* events thereafter, for apps that use this interface to poll for
* disc insertion.
*/
if (!detectCDThreadHandle)
{
381
382
HANDLE initialDetectDone = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!initialDetectDone)
383
384
return; /* oh well. */
385
386
387
388
389
390
391
392
detectCDThreadHandle = CreateThread(NULL, 0, detectCDThread,
&initialDetectDone, 0, NULL);
if (detectCDThreadHandle)
WaitForSingleObject(initialDetectDone, INFINITE);
CloseHandle(initialDetectDone);
if (!detectCDThreadHandle)
return; /* oh well. */
393
394
395
396
} /* if */
drives = drivesWithMediaBitmap; /* whatever the thread has seen, we take. */
for (i = 'A'; i <= 'Z'; i++)
397
{
398
399
400
if (drives & (1 << (i - 'A')))
{
drive_str[0] = (char) i;
401
cb(data, drive_str);
402
} /* if */
403
} /* for */
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
} /* detectAvailableCDs */
static void deinitCDThread(void)
{
if (detectCDThreadHandle)
{
if (detectCDHwnd)
PostMessageW(detectCDHwnd, WM_QUIT, 0, 0);
CloseHandle(detectCDThreadHandle);
detectCDThreadHandle = NULL;
drivesWithMediaBitmap = 0;
} /* if */
} /* deinitCDThread */
#endif
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
{
detectAvailableCDs(cb, data);
423
} /* __PHYSFS_platformDetectAvailableCDs */
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
#ifdef PHYSFS_PLATFORM_WINRT
static char *calcDirAppendSep(const WCHAR *wdir)
{
size_t len;
void *ptr;
char *retval;
BAIL_IF(!wdir, errcodeFromWinApi(), NULL);
retval = unicodeToUtf8Heap(wdir);
BAIL_IF_ERRPASS(!retval, NULL);
len = strlen(retval);
ptr = allocator.Realloc(retval, len + 2);
if (!ptr)
{
allocator.Free(retval);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
retval = (char *) ptr;
retval[len] = '\\';
retval[len+1] = '\0';
return retval;
} /* calcDirAppendSep */
#endif
447
448
449
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
450
451
452
453
#ifdef PHYSFS_PLATFORM_WINRT
return calcDirAppendSep((const WCHAR *) __PHYSFS_winrtCalcBaseDir());
#else
char *retval = NULL;
454
455
DWORD buflen = 64;
LPWSTR modpath = NULL;
456
457
458
459
460
461
462
463
464
while (1)
{
DWORD rc;
void *ptr;
if ( (ptr = allocator.Realloc(modpath, buflen*sizeof(WCHAR))) == NULL )
{
allocator.Free(modpath);
465
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
466
467
468
469
470
471
472
} /* if */
modpath = (LPWSTR) ptr;
rc = GetModuleFileNameW(NULL, modpath, buflen);
if (rc == 0)
{
allocator.Free(modpath);
473
BAIL(errcodeFromWinApi(), NULL);
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
} /* if */
if (rc < buflen)
{
buflen = rc;
break;
} /* if */
buflen *= 2;
} /* while */
if (buflen > 0) /* just in case... */
{
WCHAR *ptr = (modpath + buflen) - 1;
while (ptr != modpath)
{
if (*ptr == '\\')
break;
ptr--;
} /* while */
if ((ptr == modpath) && (*ptr != '\\'))
496
PHYSFS_setErrorCode(PHYSFS_ERR_OTHER_ERROR); /* oh well. */
497
498
else
{
499
*(ptr+1) = '\0'; /* chop off filename. */
500
501
502
503
504
505
retval = unicodeToUtf8Heap(modpath);
} /* else */
} /* else */
allocator.Free(modpath);
return retval; /* w00t. */
506
#endif
507
508
509
} /* __PHYSFS_platformCalcBaseDir */
510
511
char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
{
512
513
514
#ifdef PHYSFS_PLATFORM_WINRT
return calcDirAppendSep((const WCHAR *) __PHYSFS_winrtCalcPrefDir());
#else
515
516
517
518
519
520
521
/*
* Vista and later has a new API for this, but SHGetFolderPath works there,
* and apparently just wraps the new API. This is the new way to do it:
*
* SHGetKnownFolderPath(FOLDERID_RoamingAppData, KF_FLAG_CREATE,
* NULL, &wszPath);
*/
522
523
WCHAR path[MAX_PATH];
524
525
526
527
char *utf8 = NULL;
size_t len = 0;
char *retval = NULL;
528
529
if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
NULL, 0, path)))
530
BAIL(PHYSFS_ERR_OS_ERROR, NULL);
531
532
utf8 = unicodeToUtf8Heap(path);
533
BAIL_IF_ERRPASS(!utf8, NULL);
534
len = strlen(utf8) + strlen(org) + strlen(app) + 4;
535
536
537
538
retval = allocator.Malloc(len);
if (!retval)
{
allocator.Free(utf8);
539
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
540
541
} /* if */
542
snprintf(retval, len, "%s\\%s\\%s\\", utf8, org, app);
543
allocator.Free(utf8);
544
return retval;
545
#endif
546
547
548
} /* __PHYSFS_platformCalcPrefDir */
549
char *__PHYSFS_platformCalcUserDir(void)
550
{
551
552
553
#ifdef PHYSFS_PLATFORM_WINRT
return calcDirAppendSep((const WCHAR *) __PHYSFS_winrtCalcPrefDir());
#else
554
555
556
557
558
559
560
typedef BOOL (WINAPI *fnGetUserProfDirW)(HANDLE, LPWSTR, LPDWORD);
fnGetUserProfDirW pGetDir = NULL;
HANDLE lib = NULL;
HANDLE accessToken = NULL; /* Security handle to process */
char *retval = NULL;
lib = LoadLibraryA("userenv.dll");
561
BAIL_IF(!lib, errcodeFromWinApi(), NULL);
562
pGetDir=(fnGetUserProfDirW) GetProcAddress(lib,"GetUserProfileDirectoryW");
563
GOTO_IF(!pGetDir, errcodeFromWinApi(), done);
564
565
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &accessToken))
566
GOTO(errcodeFromWinApi(), done);
567
568
569
570
571
572
573
574
575
576
577
578
else
{
DWORD psize = 0;
WCHAR dummy = 0;
LPWSTR wstr = NULL;
BOOL rc = 0;
/*
* Should fail. Will write the size of the profile path in
* psize. Also note that the second parameter can't be
* NULL or the function fails.
*/
579
rc = pGetDir(accessToken, &dummy, &psize);
580
GOTO_IF(rc, PHYSFS_ERR_OS_ERROR, done); /* should have failed! */
581
582
/* Allocate memory for the profile directory */
583
wstr = (LPWSTR) __PHYSFS_smallAlloc((psize + 1) * sizeof (WCHAR));
584
585
586
if (wstr != NULL)
{
if (pGetDir(accessToken, wstr, &psize))
587
588
589
590
591
592
593
{
/* Make sure it ends in a dirsep. We allocated +1 for this. */
if (wstr[psize - 2] != '\\')
{
wstr[psize - 1] = '\\';
wstr[psize - 0] = '\0';
} /* if */
594
retval = unicodeToUtf8Heap(wstr);
595
} /* if */
596
597
598
599
600
__PHYSFS_smallFree(wstr);
} /* if */
} /* if */
done:
601
602
if (accessToken)
CloseHandle(accessToken);
603
604
FreeLibrary(lib);
return retval; /* We made it: hit the showers. */
605
#endif
606
} /* __PHYSFS_platformCalcUserDir */
607
608
609
610
611
612
613
614
int __PHYSFS_platformInit(void)
{
return 1; /* It's all good */
} /* __PHYSFS_platformInit */
615
void __PHYSFS_platformDeinit(void)
616
617
618
619
620
{
deinitCDThread();
} /* __PHYSFS_platformDeinit */
621
void *__PHYSFS_platformGetThreadID(void)
622
{
623
return ( (void *) ((size_t) GetCurrentThreadId()) );
624
625
} /* __PHYSFS_platformGetThreadID */
626
627
void __PHYSFS_platformEnumerateFiles(const char *dirname,
628
629
PHYSFS_EnumFilesCallback callback,
const char *origdir,
630
void *callbackdata)
631
{
632
633
HANDLE dir = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAW entw;
634
size_t len = strlen(dirname);
635
636
char *searchPath = NULL;
WCHAR *wSearchPath = NULL;
637
638
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
639
640
searchPath = (char *) __PHYSFS_smallAlloc(len + 3);
if (searchPath == NULL)
641
return;
642
643
/* Copy current dirname */
644
strcpy(searchPath, dirname);
645
646
/* if there's no '\\' at the end of the path, stick one in there. */
647
if (searchPath[len - 1] != '\\')
648
{
649
650
searchPath[len++] = '\\';
searchPath[len] = '\0';
651
652
} /* if */
653
/* Append the "*" to the end of the string */
654
strcat(searchPath, "*");
655
656
UTF8_TO_UNICODE_STACK(wSearchPath, searchPath);
657
if (!wSearchPath)
658
return; /* oh well. */
659
660
dir = winFindFirstFileW(wSearchPath, &entw);
661
662
663
664
665
__PHYSFS_smallFree(wSearchPath);
__PHYSFS_smallFree(searchPath);
if (dir == INVALID_HANDLE_VALUE)
return;
666
667
do
668
{
669
670
const WCHAR *fn = entw.cFileName;
char *utf8;
671
672
673
674
675
676
677
678
if ((fn[0] == '.') && (fn[1] == '\0'))
continue;
if ((fn[0] == '.') && (fn[1] == '.') && (fn[2] == '\0'))
continue;
utf8 = unicodeToUtf8Heap(fn);
if (utf8 != NULL)
679
{
680
681
682
683
callback(callbackdata, origdir, utf8);
allocator.Free(utf8);
} /* if */
} while (FindNextFileW(dir, &entw) != 0);
684
685
686
687
688
689
690
FindClose(dir);
} /* __PHYSFS_platformEnumerateFiles */
int __PHYSFS_platformMkDir(const char *path)
{
691
692
WCHAR *wpath;
DWORD rc;
693
UTF8_TO_UNICODE_STACK(wpath, path);
694
rc = CreateDirectoryW(wpath, NULL);
695
__PHYSFS_smallFree(wpath);
696
BAIL_IF(rc == 0, errcodeFromWinApi(), 0);
697
return 1;
698
699
} /* __PHYSFS_platformMkDir */
700
701
static HANDLE doOpen(const char *fname, DWORD mode, DWORD creation)
702
{
703
HANDLE fileh;
704
WCHAR *wfname;
705
706
707
UTF8_TO_UNICODE_STACK(wfname, fname);
BAIL_IF(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
708
709
fileh = winCreateFileW(wfname, mode, creation);
710
__PHYSFS_smallFree(wfname);
711
712
713
if (fileh == INVALID_HANDLE_VALUE)
BAIL(errcodeFromWinApi(), INVALID_HANDLE_VALUE);
714
715
return fileh;
716
717
} /* doOpen */
718
719
720
void *__PHYSFS_platformOpenRead(const char *filename)
{
721
722
HANDLE h = doOpen(filename, GENERIC_READ, OPEN_EXISTING);
return (h == INVALID_HANDLE_VALUE) ? NULL : (void *) h;
723
} /* __PHYSFS_platformOpenRead */
724
725
726
727
void *__PHYSFS_platformOpenWrite(const char *filename)
{
728
729
HANDLE h = doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS);
return (h == INVALID_HANDLE_VALUE) ? NULL : (void *) h;
730
} /* __PHYSFS_platformOpenWrite */
731
732
733
734
void *__PHYSFS_platformOpenAppend(const char *filename)
{
735
736
737
738
HANDLE h = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS);
BAIL_IF_ERRPASS(h == INVALID_HANDLE_VALUE, NULL);
if (!winSetFilePointer(h, 0, NULL, FILE_END))
739
{
740
741
742
const PHYSFS_ErrorCode err = errcodeFromWinApi();
CloseHandle(h);
BAIL(err, NULL);
743
744
} /* if */
745
return (void *) h;
746
} /* __PHYSFS_platformOpenAppend */
747
748
749
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
750
{
751
HANDLE h = (HANDLE) opaque;
752
PHYSFS_sint64 totalRead = 0;
753
754
if (!__PHYSFS_ui64FitsAddressSpace(len))
755
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
756
757
758
759
760
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numRead = 0;
761
if (!ReadFile(h, buf, thislen, &numRead, NULL))
762
BAIL(errcodeFromWinApi(), -1);
763
764
765
766
767
768
769
len -= (PHYSFS_uint64) numRead;
totalRead += (PHYSFS_sint64) numRead;
if (numRead != thislen)
break;
} /* while */
return totalRead;
770
771
} /* __PHYSFS_platformRead */
772
773
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
774
PHYSFS_uint64 len)
775
{
776
HANDLE h = (HANDLE) opaque;
777
PHYSFS_sint64 totalWritten = 0;
778
779
if (!__PHYSFS_ui64FitsAddressSpace(len))
780
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
781
782
783
784
785
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numWritten = 0;
786
if (!WriteFile(h, buffer, thislen, &numWritten, NULL))
787
BAIL(errcodeFromWinApi(), -1);
788
789
790
791
792
793
794
len -= (PHYSFS_uint64) numWritten;
totalWritten += (PHYSFS_sint64) numWritten;
if (numWritten != thislen)
break;
} /* while */
return totalWritten;
795
796
} /* __PHYSFS_platformWrite */
797
798
799
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
800
HANDLE h = (HANDLE) opaque;
801
const PHYSFS_sint64 spos = (PHYSFS_sint64) pos;
802
BAIL_IF(!winSetFilePointer(h,spos,NULL,FILE_BEGIN), errcodeFromWinApi(), 0);
803
return 1; /* No error occured */
804
} /* __PHYSFS_platformSeek */
805
806
807
808
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
809
HANDLE h = (HANDLE) opaque;
810
PHYSFS_sint64 pos = 0;
811
BAIL_IF(!winSetFilePointer(h,0,&pos,FILE_CURRENT), errcodeFromWinApi(), -1);
812
return pos;
813
} /* __PHYSFS_platformTell */
814
815
816
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
817
{
818
HANDLE h = (HANDLE) opaque;
819
820
const PHYSFS_sint64 retval = winGetFileSize(h);
BAIL_IF(retval < 0, errcodeFromWinApi(), -1);
821
return retval;
822
823
} /* __PHYSFS_platformFileLength */
824
825
826
int __PHYSFS_platformFlush(void *opaque)
{
827
828
HANDLE h = (HANDLE) opaque;
BAIL_IF(!FlushFileBuffers(h), errcodeFromWinApi(), 0);
829
return 1;
830
} /* __PHYSFS_platformFlush */
831
832
833
void __PHYSFS_platformClose(void *opaque)
834
{
835
836
HANDLE h = (HANDLE) opaque;
(void) CloseHandle(h); /* ignore errors. You should have flushed! */
837
} /* __PHYSFS_platformClose */
838
839
840
static int doPlatformDelete(LPWSTR wpath)
841
{
842
843
844
845
846
847
848
849
850
WIN32_FILE_ATTRIBUTE_DATA info;
if (!GetFileAttributesExW(wpath, GetFileExInfoStandard, &info))
BAIL(errcodeFromWinApi(), 0);
else
{
const int isdir = (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
const BOOL rc = isdir ? RemoveDirectoryW(wpath) : DeleteFileW(wpath);
BAIL_IF(!rc, errcodeFromWinApi(), 0);
} /* else */
851
return 1; /* if you made it here, it worked. */
852
853
854
855
856
857
} /* doPlatformDelete */
int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
858
LPWSTR wpath = NULL;
859
860
UTF8_TO_UNICODE_STACK(wpath, path);
BAIL_IF(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
861
862
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
863
return retval;
864
} /* __PHYSFS_platformDelete */
865
866
867
868
void *__PHYSFS_platformCreateMutex(void)
{
869
870
LPCRITICAL_SECTION lpcs;
lpcs = (LPCRITICAL_SECTION) allocator.Malloc(sizeof (CRITICAL_SECTION));
871
BAIL_IF(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
872
873
874
875
876
877
878
if (!winInitializeCriticalSection(lpcs))
{
allocator.Free(lpcs);
BAIL(errcodeFromWinApi(), NULL);
} /* if */
879
return lpcs;
880
881
} /* __PHYSFS_platformCreateMutex */
882
883
884
void __PHYSFS_platformDestroyMutex(void *mutex)
{
885
886
DeleteCriticalSection((LPCRITICAL_SECTION) mutex);
allocator.Free(mutex);
887
888
} /* __PHYSFS_platformDestroyMutex */
889
890
891
int __PHYSFS_platformGrabMutex(void *mutex)
{
892
893
EnterCriticalSection((LPCRITICAL_SECTION) mutex);
return 1;
894
} /* __PHYSFS_platformGrabMutex */
895
896
897
898
void __PHYSFS_platformReleaseMutex(void *mutex)
{
899
LeaveCriticalSection((LPCRITICAL_SECTION) mutex);
900
901
} /* __PHYSFS_platformReleaseMutex */
902
903
static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
904
905
906
{
SYSTEMTIME st_utc;
SYSTEMTIME st_localtz;
907
908
909
TIME_ZONE_INFORMATION tzi;
DWORD tzid;
PHYSFS_sint64 retval;
910
struct tm tm;
911
BOOL rc;
912
913
BAIL_IF(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
914
tzid = GetTimeZoneInformation(&tzi);
915
BAIL_IF(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
916
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
917
BAIL_IF(!rc, errcodeFromWinApi(), -1);
918
919
/* Convert to a format that mktime() can grok... */
920
921
922
923
924
925
tm.tm_sec = st_localtz.wSecond;
tm.tm_min = st_localtz.wMinute;
tm.tm_hour = st_localtz.wHour;
tm.tm_mday = st_localtz.wDay;
tm.tm_mon = st_localtz.wMonth - 1;
tm.tm_year = st_localtz.wYear - 1900;
926
tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
927
928
tm.tm_yday = -1;
tm.tm_isdst = -1;
929
930
931
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
932
BAIL_IF(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
933
return retval;
934
935
} /* FileTimeToPhysfsTime */
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
/* check for symlinks. These exist in NTFS 3.1 (WinXP), even though
they aren't really available to userspace before Vista. I wonder
what would happen if you put an NTFS disk with a symlink on it
into an XP machine, though; would this flag get set?
NTFS symlinks are a form of "reparse point" (junction, volume mount,
etc), so if the REPARSE_POINT attribute is set, check for the symlink
tag thereafter. This assumes you already read in the file attributes. */
static int isSymlink(const WCHAR *wpath, const DWORD attr)
{
WIN32_FIND_DATAW w32dw;
HANDLE h;
if ((attr & PHYSFS_FILE_ATTRIBUTE_REPARSE_POINT) == 0)
return 0; /* not a reparse point? Definitely not a symlink. */
952
h = winFindFirstFileW(wpath, &w32dw);
953
954
955
956
if (h == INVALID_HANDLE_VALUE)
return 0; /* ...maybe the file just vanished...? */
FindClose(h);
957
return (w32dw.dwReserved0 == PHYSFS_IO_REPARSE_TAG_SYMLINK);
958
959
960
} /* isSymlink */
961
int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
962
963
964
{
WIN32_FILE_ATTRIBUTE_DATA winstat;
WCHAR *wstr = NULL;
965
DWORD err = 0;
966
BOOL rc = 0;
967
int issymlink = 0;
968
969
970
UTF8_TO_UNICODE_STACK(wstr, filename);
BAIL_IF(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
971
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
972
973
974
975
976
977
if (!rc)
err = GetLastError();
else /* check for symlink while wstr is still available */
issymlink = isSymlink(wstr, winstat.dwFileAttributes);
978
__PHYSFS_smallFree(wstr);
979
BAIL_IF(!rc, errcodeFromWinApiError(err), 0);
980
981
982
983
st->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
st->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);
st->createtime = FileTimeToPhysfsTime(&winstat.ftCreationTime);
984
985
if (issymlink)
986
{
987
st->filetype = PHYSFS_FILETYPE_SYMLINK;
988
st->filesize = 0;
989
990
} /* if */
991
992
993
994
995
996
997
else if (winstat.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
st->filetype = PHYSFS_FILETYPE_DIRECTORY;
st->filesize = 0;
} /* else if */
else if (winstat.dwFileAttributes & (FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_DEVICE))
998
{
999
st->filetype = PHYSFS_FILETYPE_OTHER;
1000
st->filesize = (((PHYSFS_uint64) winstat.nFileSizeHigh) << 32) | winstat.nFileSizeLow;