/
physfs_platform_windows.c
1020 lines (841 loc) · 30.2 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_platforms.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
22
#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS 1
#endif
23
#define WIN32_LEAN_AND_MEAN 1
24
#include <windows.h>
25
26
#ifndef PHYSFS_PLATFORM_WINRT
27
#include <userenv.h>
28
#include <shlobj.h>
29
30
31
#endif
#if !defined(PHYSFS_NO_CDROM_SUPPORT)
32
#include <dbt.h>
33
34
#endif
35
#include <errno.h>
36
#include <ctype.h>
37
#include <time.h>
38
39
40
41
#ifdef allocator /* apparently Windows 10 SDK conflicts here. */
#undef allocator
#endif
42
43
#include "physfs_internal.h"
44
45
46
47
48
49
50
/*
* 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
51
52
53
/* just in case... */
#define PHYSFS_INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
54
55
/* Not defined before the Vista SDK. */
56
#define PHYSFS_FILE_ATTRIBUTE_REPARSE_POINT 0x400
57
58
59
#define PHYSFS_IO_REPARSE_TAG_SYMLINK 0xA000000C
60
#define UTF8_TO_UNICODE_STACK(w_assignto, str) { \
61
62
63
if (str == NULL) \
w_assignto = NULL; \
else { \
64
const size_t len = (PHYSFS_uint64) ((strlen(str) + 1) * 2); \
65
66
w_assignto = (WCHAR *) __PHYSFS_smallAlloc(len); \
if (w_assignto != NULL) \
67
PHYSFS_utf8ToUtf16(str, (PHYSFS_uint16 *) w_assignto, len); \
68
69
} \
} \
70
71
/* Note this counts WCHARs, not codepoints! */
72
73
74
75
76
static PHYSFS_uint64 wStrLen(const WCHAR *wstr)
{
PHYSFS_uint64 len = 0;
while (*(wstr++))
len++;
77
return len;
78
79
80
81
82
83
84
85
86
87
} /* 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);
88
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
89
PHYSFS_utf8FromUtf16((const PHYSFS_uint16 *) w_str, retval, len);
90
91
92
93
ptr = allocator.Realloc(retval, strlen(retval) + 1); /* shrink. */
if (ptr != NULL)
retval = (char *) ptr;
} /* if */
94
return retval;
95
96
} /* unicodeToUtf8Heap */
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
172
173
/* 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 */
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
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)
189
{
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
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;
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;
205
206
207
208
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;
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
case ERROR_HANDLE_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
case ERROR_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
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 */
229
230
231
232
233
234
235
#if defined(PHYSFS_NO_CDROM_SUPPORT)
#define detectAvailableCDs(cb, data)
#define deinitCDThread()
#else
static HANDLE detectCDThreadHandle = NULL;
236
static HWND detectCDHwnd = NULL;
237
238
static volatile DWORD drivesWithMediaBitmap = 0;
239
typedef BOOL (WINAPI *fnSTEM)(DWORD, LPDWORD b);
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
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);
258
259
260
261
262
263
264
265
/* 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;
266
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
/* 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 */
310
static DWORD WINAPI detectCDThread(LPVOID arg)
311
{
312
HANDLE initialDiscDetectionComplete = *((HANDLE *) arg);
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
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)
{
328
SetEvent(initialDiscDetectionComplete); /* let main thread go on. */
329
330
331
332
333
334
335
336
337
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)
{
338
SetEvent(initialDiscDetectionComplete); /* let main thread go on. */
339
340
341
342
343
344
345
346
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();
347
348
SetEvent(initialDiscDetectionComplete); /* let main thread go on. */
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
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 */
364
365
static void detectAvailableCDs(PHYSFS_StringCallback cb, void *data)
366
{
367
368
369
370
371
372
373
374
375
376
377
378
379
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)
{
380
381
HANDLE initialDetectDone = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!initialDetectDone)
382
383
return; /* oh well. */
384
385
386
387
388
389
390
391
detectCDThreadHandle = CreateThread(NULL, 0, detectCDThread,
&initialDetectDone, 0, NULL);
if (detectCDThreadHandle)
WaitForSingleObject(initialDetectDone, INFINITE);
CloseHandle(initialDetectDone);
if (!detectCDThreadHandle)
return; /* oh well. */
392
393
394
395
} /* if */
drives = drivesWithMediaBitmap; /* whatever the thread has seen, we take. */
for (i = 'A'; i <= 'Z'; i++)
396
{
397
398
399
if (drives & (1 << (i - 'A')))
{
drive_str[0] = (char) i;
400
cb(data, drive_str);
401
} /* if */
402
} /* for */
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
} /* 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);
422
} /* __PHYSFS_platformDetectAvailableCDs */
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
#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
446
447
448
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
449
450
451
452
#ifdef PHYSFS_PLATFORM_WINRT
return calcDirAppendSep((const WCHAR *) __PHYSFS_winrtCalcBaseDir());
#else
char *retval = NULL;
453
454
DWORD buflen = 64;
LPWSTR modpath = NULL;
455
456
457
458
459
460
461
462
463
while (1)
{
DWORD rc;
void *ptr;
if ( (ptr = allocator.Realloc(modpath, buflen*sizeof(WCHAR))) == NULL )
{
allocator.Free(modpath);
464
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
465
466
467
468
469
470
471
} /* if */
modpath = (LPWSTR) ptr;
rc = GetModuleFileNameW(NULL, modpath, buflen);
if (rc == 0)
{
allocator.Free(modpath);
472
BAIL(errcodeFromWinApi(), NULL);
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
} /* 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 != '\\'))
495
PHYSFS_setErrorCode(PHYSFS_ERR_OTHER_ERROR); /* oh well. */
496
497
else
{
498
*(ptr+1) = '\0'; /* chop off filename. */
499
500
501
502
503
504
retval = unicodeToUtf8Heap(modpath);
} /* else */
} /* else */
allocator.Free(modpath);
return retval; /* w00t. */
505
#endif
506
507
508
} /* __PHYSFS_platformCalcBaseDir */
509
510
char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
{
511
512
513
#ifdef PHYSFS_PLATFORM_WINRT
return calcDirAppendSep((const WCHAR *) __PHYSFS_winrtCalcPrefDir());
#else
514
515
516
517
518
519
520
/*
* 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);
*/
521
522
WCHAR path[MAX_PATH];
523
524
525
526
char *utf8 = NULL;
size_t len = 0;
char *retval = NULL;
527
528
if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
NULL, 0, path)))
529
BAIL(PHYSFS_ERR_OS_ERROR, NULL);
530
531
utf8 = unicodeToUtf8Heap(path);
532
BAIL_IF_ERRPASS(!utf8, NULL);
533
len = strlen(utf8) + strlen(org) + strlen(app) + 4;
534
535
536
537
retval = allocator.Malloc(len);
if (!retval)
{
allocator.Free(utf8);
538
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
539
540
} /* if */
541
snprintf(retval, len, "%s\\%s\\%s\\", utf8, org, app);
542
allocator.Free(utf8);
543
return retval;
544
#endif
545
546
547
} /* __PHYSFS_platformCalcPrefDir */
548
char *__PHYSFS_platformCalcUserDir(void)
549
{
550
551
552
#ifdef PHYSFS_PLATFORM_WINRT
return calcDirAppendSep((const WCHAR *) __PHYSFS_winrtCalcPrefDir());
#else
553
554
555
556
557
558
559
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");
560
BAIL_IF(!lib, errcodeFromWinApi(), NULL);
561
pGetDir=(fnGetUserProfDirW) GetProcAddress(lib,"GetUserProfileDirectoryW");
562
GOTO_IF(!pGetDir, errcodeFromWinApi(), done);
563
564
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &accessToken))
565
GOTO(errcodeFromWinApi(), done);
566
567
568
569
570
571
572
573
574
575
576
577
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.
*/
578
rc = pGetDir(accessToken, &dummy, &psize);
579
GOTO_IF(rc, PHYSFS_ERR_OS_ERROR, done); /* should have failed! */
580
581
/* Allocate memory for the profile directory */
582
wstr = (LPWSTR) __PHYSFS_smallAlloc((psize + 1) * sizeof (WCHAR));
583
584
585
if (wstr != NULL)
{
if (pGetDir(accessToken, wstr, &psize))
586
587
588
589
590
591
592
{
/* Make sure it ends in a dirsep. We allocated +1 for this. */
if (wstr[psize - 2] != '\\')
{
wstr[psize - 1] = '\\';
wstr[psize - 0] = '\0';
} /* if */
593
retval = unicodeToUtf8Heap(wstr);
594
} /* if */
595
596
597
598
599
__PHYSFS_smallFree(wstr);
} /* if */
} /* if */
done:
600
601
if (accessToken)
CloseHandle(accessToken);
602
603
FreeLibrary(lib);
return retval; /* We made it: hit the showers. */
604
#endif
605
} /* __PHYSFS_platformCalcUserDir */
606
607
608
609
610
611
612
613
int __PHYSFS_platformInit(void)
{
return 1; /* It's all good */
} /* __PHYSFS_platformInit */
614
void __PHYSFS_platformDeinit(void)
615
616
617
618
619
{
deinitCDThread();
} /* __PHYSFS_platformDeinit */
620
void *__PHYSFS_platformGetThreadID(void)
621
{
622
return ( (void *) ((size_t) GetCurrentThreadId()) );
623
624
} /* __PHYSFS_platformGetThreadID */
625
626
PHYSFS_EnumerateCallbackResult __PHYSFS_platformEnumerate(const char *dirname,
627
628
PHYSFS_EnumerateCallback callback,
const char *origdir, void *callbackdata)
629
{
630
PHYSFS_EnumerateCallbackResult retval = PHYSFS_ENUM_OK;
631
632
HANDLE dir = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAW entw;
633
size_t len = strlen(dirname);
634
635
char *searchPath = NULL;
WCHAR *wSearchPath = NULL;
636
637
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
638
searchPath = (char *) __PHYSFS_smallAlloc(len + 3);
639
BAIL_IF(!searchPath, PHYSFS_ERR_OUT_OF_MEMORY, PHYSFS_ENUM_ERROR);
640
641
/* Copy current dirname */
642
strcpy(searchPath, dirname);
643
644
/* if there's no '\\' at the end of the path, stick one in there. */
645
if (searchPath[len - 1] != '\\')
646
{
647
648
searchPath[len++] = '\\';
searchPath[len] = '\0';
649
650
} /* if */
651
/* Append the "*" to the end of the string */
652
strcat(searchPath, "*");
653
654
UTF8_TO_UNICODE_STACK(wSearchPath, searchPath);
655
__PHYSFS_smallFree(searchPath);
656
BAIL_IF_ERRPASS(!wSearchPath, PHYSFS_ENUM_ERROR);
657
658
dir = winFindFirstFileW(wSearchPath, &entw);
659
__PHYSFS_smallFree(wSearchPath);
660
BAIL_IF(dir==INVALID_HANDLE_VALUE, errcodeFromWinApi(), PHYSFS_ENUM_ERROR);
661
662
do
663
{
664
665
const WCHAR *fn = entw.cFileName;
char *utf8;
666
667
668
669
670
671
if (fn[0] == '.') /* ignore "." and ".." */
{
if ((fn[1] == '\0') || ((fn[1] == '.') && (fn[2] == '\0')))
continue;
} /* if */
672
673
utf8 = unicodeToUtf8Heap(fn);
674
675
676
if (utf8 == NULL)
retval = -1;
else
677
{
678
retval = callback(callbackdata, origdir, utf8);
679
allocator.Free(utf8);
680
if (retval == PHYSFS_ENUM_ERROR)
681
PHYSFS_setErrorCode(PHYSFS_ERR_APP_CALLBACK);
682
} /* else */
683
} while ((retval == PHYSFS_ENUM_OK) && (FindNextFileW(dir, &entw) != 0));
684
685
FindClose(dir);
686
687
688
return retval;
} /* __PHYSFS_platformEnumerate */
689
690
691
692
int __PHYSFS_platformMkDir(const char *path)
{
693
694
WCHAR *wpath;
DWORD rc;
695
UTF8_TO_UNICODE_STACK(wpath, path);
696
rc = CreateDirectoryW(wpath, NULL);
697
__PHYSFS_smallFree(wpath);
698
BAIL_IF(rc == 0, errcodeFromWinApi(), 0);
699
return 1;
700
701
} /* __PHYSFS_platformMkDir */
702
703
static HANDLE doOpen(const char *fname, DWORD mode, DWORD creation)
704
{
705
HANDLE fileh;
706
WCHAR *wfname;
707
708
709
UTF8_TO_UNICODE_STACK(wfname, fname);
BAIL_IF(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
710
711
fileh = winCreateFileW(wfname, mode, creation);
712
__PHYSFS_smallFree(wfname);
713
714
715
if (fileh == INVALID_HANDLE_VALUE)
BAIL(errcodeFromWinApi(), INVALID_HANDLE_VALUE);
716
717
return fileh;
718
719
} /* doOpen */
720
721
722
void *__PHYSFS_platformOpenRead(const char *filename)
{
723
724
HANDLE h = doOpen(filename, GENERIC_READ, OPEN_EXISTING);
return (h == INVALID_HANDLE_VALUE) ? NULL : (void *) h;
725
} /* __PHYSFS_platformOpenRead */
726
727
728
729
void *__PHYSFS_platformOpenWrite(const char *filename)
{
730
731
HANDLE h = doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS);
return (h == INVALID_HANDLE_VALUE) ? NULL : (void *) h;
732
} /* __PHYSFS_platformOpenWrite */
733
734
735
736
void *__PHYSFS_platformOpenAppend(const char *filename)
{
737
738
739
740
HANDLE h = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS);
BAIL_IF_ERRPASS(h == INVALID_HANDLE_VALUE, NULL);
if (!winSetFilePointer(h, 0, NULL, FILE_END))
741
{
742
743
744
const PHYSFS_ErrorCode err = errcodeFromWinApi();
CloseHandle(h);
BAIL(err, NULL);
745
746
} /* if */
747
return (void *) h;
748
} /* __PHYSFS_platformOpenAppend */
749
750
751
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
752
{
753
HANDLE h = (HANDLE) opaque;
754
PHYSFS_sint64 totalRead = 0;
755
756
if (!__PHYSFS_ui64FitsAddressSpace(len))
757
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
758
759
760
761
762
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numRead = 0;
763
if (!ReadFile(h, buf, thislen, &numRead, NULL))
764
BAIL(errcodeFromWinApi(), -1);
765
766
767
768
769
770
771
len -= (PHYSFS_uint64) numRead;
totalRead += (PHYSFS_sint64) numRead;
if (numRead != thislen)
break;
} /* while */
return totalRead;
772
773
} /* __PHYSFS_platformRead */
774
775
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
776
PHYSFS_uint64 len)
777
{
778
HANDLE h = (HANDLE) opaque;
779
PHYSFS_sint64 totalWritten = 0;
780
781
if (!__PHYSFS_ui64FitsAddressSpace(len))
782
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
783
784
785
786
787
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numWritten = 0;
788
if (!WriteFile(h, buffer, thislen, &numWritten, NULL))
789
BAIL(errcodeFromWinApi(), -1);
790
791
792
793
794
795
796
len -= (PHYSFS_uint64) numWritten;
totalWritten += (PHYSFS_sint64) numWritten;
if (numWritten != thislen)
break;
} /* while */
return totalWritten;
797
798
} /* __PHYSFS_platformWrite */
799
800
801
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
802
HANDLE h = (HANDLE) opaque;
803
const PHYSFS_sint64 spos = (PHYSFS_sint64) pos;
804
BAIL_IF(!winSetFilePointer(h,spos,NULL,FILE_BEGIN), errcodeFromWinApi(), 0);
805
return 1; /* No error occured */
806
} /* __PHYSFS_platformSeek */
807
808
809
810
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
811
HANDLE h = (HANDLE) opaque;
812
PHYSFS_sint64 pos = 0;
813
BAIL_IF(!winSetFilePointer(h,0,&pos,FILE_CURRENT), errcodeFromWinApi(), -1);
814
return pos;
815
} /* __PHYSFS_platformTell */
816
817
818
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
819
{
820
HANDLE h = (HANDLE) opaque;
821
822
const PHYSFS_sint64 retval = winGetFileSize(h);
BAIL_IF(retval < 0, errcodeFromWinApi(), -1);
823
return retval;
824
825
} /* __PHYSFS_platformFileLength */
826
827
828
int __PHYSFS_platformFlush(void *opaque)
{
829
830
HANDLE h = (HANDLE) opaque;
BAIL_IF(!FlushFileBuffers(h), errcodeFromWinApi(), 0);
831
return 1;
832
} /* __PHYSFS_platformFlush */
833
834
835
void __PHYSFS_platformClose(void *opaque)
836
{
837
838
HANDLE h = (HANDLE) opaque;
(void) CloseHandle(h); /* ignore errors. You should have flushed! */
839
} /* __PHYSFS_platformClose */
840
841
842
static int doPlatformDelete(LPWSTR wpath)
843
{
844
845
846
847
848
849
850
851
852
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 */
853
return 1; /* if you made it here, it worked. */
854
855
856
857
858
859
} /* doPlatformDelete */
int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
860
LPWSTR wpath = NULL;
861
862
UTF8_TO_UNICODE_STACK(wpath, path);
BAIL_IF(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
863
864
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
865
return retval;
866
} /* __PHYSFS_platformDelete */
867
868
869
870
void *__PHYSFS_platformCreateMutex(void)
{
871
872
LPCRITICAL_SECTION lpcs;
lpcs = (LPCRITICAL_SECTION) allocator.Malloc(sizeof (CRITICAL_SECTION));
873
BAIL_IF(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
874
875
876
877
878
879
880
if (!winInitializeCriticalSection(lpcs))
{
allocator.Free(lpcs);
BAIL(errcodeFromWinApi(), NULL);
} /* if */
881
return lpcs;
882
883
} /* __PHYSFS_platformCreateMutex */
884
885
886
void __PHYSFS_platformDestroyMutex(void *mutex)
{
887
888
DeleteCriticalSection((LPCRITICAL_SECTION) mutex);
allocator.Free(mutex);
889
890
} /* __PHYSFS_platformDestroyMutex */
891
892
893
int __PHYSFS_platformGrabMutex(void *mutex)
{
894
895
EnterCriticalSection((LPCRITICAL_SECTION) mutex);
return 1;
896
} /* __PHYSFS_platformGrabMutex */
897
898
899
900
void __PHYSFS_platformReleaseMutex(void *mutex)
{
901
LeaveCriticalSection((LPCRITICAL_SECTION) mutex);
902
903
} /* __PHYSFS_platformReleaseMutex */
904
905
static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
906
907
908
{
SYSTEMTIME st_utc;
SYSTEMTIME st_localtz;
909
910
911
TIME_ZONE_INFORMATION tzi;
DWORD tzid;
PHYSFS_sint64 retval;
912
struct tm tm;
913
BOOL rc;
914
915
BAIL_IF(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
916
tzid = GetTimeZoneInformation(&tzi);
917
BAIL_IF(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
918
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
919
BAIL_IF(!rc, errcodeFromWinApi(), -1);
920
921
/* Convert to a format that mktime() can grok... */
922
923
924
925
926
927
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;
928
tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
929
930
tm.tm_yday = -1;
tm.tm_isdst = -1;
931
932
933
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
934
BAIL_IF(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
935
return retval;
936
937
} /* FileTimeToPhysfsTime */
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
/* 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. */
954
h = winFindFirstFileW(wpath, &w32dw);
955
956
957
958
if (h == INVALID_HANDLE_VALUE)
return 0; /* ...maybe the file just vanished...? */
FindClose(h);
959
return (w32dw.dwReserved0 == PHYSFS_IO_REPARSE_TAG_SYMLINK);
960
961
962
} /* isSymlink */
963
int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
964
965
966
{
WIN32_FILE_ATTRIBUTE_DATA winstat;
WCHAR *wstr = NULL;
967
DWORD err = 0;
968
BOOL rc = 0;
969
int issymlink = 0;
970
971
972
UTF8_TO_UNICODE_STACK(wstr, filename);
BAIL_IF(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
973
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
974
975
976
977
978
979
if (!rc)
err = GetLastError();
else /* check for symlink while wstr is still available */
issymlink = isSymlink(wstr, winstat.dwFileAttributes);
980
__PHYSFS_smallFree(wstr);
981
BAIL_IF(!rc, errcodeFromWinApiError(err), 0);
982
983
984
985
st->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
st->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);
st->createtime = FileTimeToPhysfsTime(&winstat.ftCreationTime);
986
987
if (issymlink)
988
{
989
st->filetype = PHYSFS_FILETYPE_SYMLINK;
990
st->filesize = 0;
991
992
} /* if */
993
994
995
996
997
998
999
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))
1000
{