/
physfs_platform_windows.c
1019 lines (840 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
else
{
DWORD psize = 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.
*/
577
rc = pGetDir(accessToken, NULL, &psize);
578
GOTO_IF(rc, PHYSFS_ERR_OS_ERROR, done); /* should have failed! */
579
580
/* Allocate memory for the profile directory */
581
wstr = (LPWSTR) __PHYSFS_smallAlloc((psize + 1) * sizeof (WCHAR));
582
583
584
if (wstr != NULL)
{
if (pGetDir(accessToken, wstr, &psize))
585
586
587
588
589
590
591
{
/* Make sure it ends in a dirsep. We allocated +1 for this. */
if (wstr[psize - 2] != '\\')
{
wstr[psize - 1] = '\\';
wstr[psize - 0] = '\0';
} /* if */
592
retval = unicodeToUtf8Heap(wstr);
593
} /* if */
594
595
596
597
598
__PHYSFS_smallFree(wstr);
} /* if */
} /* if */
done:
599
600
if (accessToken)
CloseHandle(accessToken);
601
602
FreeLibrary(lib);
return retval; /* We made it: hit the showers. */
603
#endif
604
} /* __PHYSFS_platformCalcUserDir */
605
606
607
608
609
610
611
612
int __PHYSFS_platformInit(void)
{
return 1; /* It's all good */
} /* __PHYSFS_platformInit */
613
void __PHYSFS_platformDeinit(void)
614
615
616
617
618
{
deinitCDThread();
} /* __PHYSFS_platformDeinit */
619
void *__PHYSFS_platformGetThreadID(void)
620
{
621
return ( (void *) ((size_t) GetCurrentThreadId()) );
622
623
} /* __PHYSFS_platformGetThreadID */
624
625
PHYSFS_EnumerateCallbackResult __PHYSFS_platformEnumerate(const char *dirname,
626
627
PHYSFS_EnumerateCallback callback,
const char *origdir, void *callbackdata)
628
{
629
PHYSFS_EnumerateCallbackResult retval = PHYSFS_ENUM_OK;
630
631
HANDLE dir = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAW entw;
632
size_t len = strlen(dirname);
633
634
char *searchPath = NULL;
WCHAR *wSearchPath = NULL;
635
636
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
637
searchPath = (char *) __PHYSFS_smallAlloc(len + 3);
638
BAIL_IF(!searchPath, PHYSFS_ERR_OUT_OF_MEMORY, PHYSFS_ENUM_ERROR);
639
640
/* Copy current dirname */
641
strcpy(searchPath, dirname);
642
643
/* if there's no '\\' at the end of the path, stick one in there. */
644
if (searchPath[len - 1] != '\\')
645
{
646
647
searchPath[len++] = '\\';
searchPath[len] = '\0';
648
649
} /* if */
650
/* Append the "*" to the end of the string */
651
strcat(searchPath, "*");
652
653
UTF8_TO_UNICODE_STACK(wSearchPath, searchPath);
654
__PHYSFS_smallFree(searchPath);
655
BAIL_IF_ERRPASS(!wSearchPath, PHYSFS_ENUM_ERROR);
656
657
dir = winFindFirstFileW(wSearchPath, &entw);
658
__PHYSFS_smallFree(wSearchPath);
659
BAIL_IF(dir==INVALID_HANDLE_VALUE, errcodeFromWinApi(), PHYSFS_ENUM_ERROR);
660
661
do
662
{
663
664
const WCHAR *fn = entw.cFileName;
char *utf8;
665
666
667
668
669
670
if (fn[0] == '.') /* ignore "." and ".." */
{
if ((fn[1] == '\0') || ((fn[1] == '.') && (fn[2] == '\0')))
continue;
} /* if */
671
672
utf8 = unicodeToUtf8Heap(fn);
673
674
675
if (utf8 == NULL)
retval = -1;
else
676
{
677
retval = callback(callbackdata, origdir, utf8);
678
allocator.Free(utf8);
679
if (retval == PHYSFS_ENUM_ERROR)
680
PHYSFS_setErrorCode(PHYSFS_ERR_APP_CALLBACK);
681
} /* else */
682
} while ((retval == PHYSFS_ENUM_OK) && (FindNextFileW(dir, &entw) != 0));
683
684
FindClose(dir);
685
686
687
return retval;
} /* __PHYSFS_platformEnumerate */
688
689
690
691
int __PHYSFS_platformMkDir(const char *path)
{
692
693
WCHAR *wpath;
DWORD rc;
694
UTF8_TO_UNICODE_STACK(wpath, path);
695
rc = CreateDirectoryW(wpath, NULL);
696
__PHYSFS_smallFree(wpath);
697
BAIL_IF(rc == 0, errcodeFromWinApi(), 0);
698
return 1;
699
700
} /* __PHYSFS_platformMkDir */
701
702
static HANDLE doOpen(const char *fname, DWORD mode, DWORD creation)
703
{
704
HANDLE fileh;
705
WCHAR *wfname;
706
707
708
UTF8_TO_UNICODE_STACK(wfname, fname);
BAIL_IF(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
709
710
fileh = winCreateFileW(wfname, mode, creation);
711
__PHYSFS_smallFree(wfname);
712
713
714
if (fileh == INVALID_HANDLE_VALUE)
BAIL(errcodeFromWinApi(), INVALID_HANDLE_VALUE);
715
716
return fileh;
717
718
} /* doOpen */
719
720
721
void *__PHYSFS_platformOpenRead(const char *filename)
{
722
723
HANDLE h = doOpen(filename, GENERIC_READ, OPEN_EXISTING);
return (h == INVALID_HANDLE_VALUE) ? NULL : (void *) h;
724
} /* __PHYSFS_platformOpenRead */
725
726
727
728
void *__PHYSFS_platformOpenWrite(const char *filename)
{
729
730
HANDLE h = doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS);
return (h == INVALID_HANDLE_VALUE) ? NULL : (void *) h;
731
} /* __PHYSFS_platformOpenWrite */
732
733
734
735
void *__PHYSFS_platformOpenAppend(const char *filename)
{
736
737
738
739
HANDLE h = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS);
BAIL_IF_ERRPASS(h == INVALID_HANDLE_VALUE, NULL);
if (!winSetFilePointer(h, 0, NULL, FILE_END))
740
{
741
742
743
const PHYSFS_ErrorCode err = errcodeFromWinApi();
CloseHandle(h);
BAIL(err, NULL);
744
745
} /* if */
746
return (void *) h;
747
} /* __PHYSFS_platformOpenAppend */
748
749
750
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
751
{
752
HANDLE h = (HANDLE) opaque;
753
PHYSFS_sint64 totalRead = 0;
754
755
if (!__PHYSFS_ui64FitsAddressSpace(len))
756
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
757
758
759
760
761
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numRead = 0;
762
if (!ReadFile(h, buf, thislen, &numRead, NULL))
763
BAIL(errcodeFromWinApi(), -1);
764
765
766
767
768
769
770
len -= (PHYSFS_uint64) numRead;
totalRead += (PHYSFS_sint64) numRead;
if (numRead != thislen)
break;
} /* while */
return totalRead;
771
772
} /* __PHYSFS_platformRead */
773
774
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
775
PHYSFS_uint64 len)
776
{
777
HANDLE h = (HANDLE) opaque;
778
PHYSFS_sint64 totalWritten = 0;
779
780
if (!__PHYSFS_ui64FitsAddressSpace(len))
781
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
782
783
784
785
786
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numWritten = 0;
787
if (!WriteFile(h, buffer, thislen, &numWritten, NULL))
788
BAIL(errcodeFromWinApi(), -1);
789
790
791
792
793
794
795
len -= (PHYSFS_uint64) numWritten;
totalWritten += (PHYSFS_sint64) numWritten;
if (numWritten != thislen)
break;
} /* while */
return totalWritten;
796
797
} /* __PHYSFS_platformWrite */
798
799
800
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
801
HANDLE h = (HANDLE) opaque;
802
const PHYSFS_sint64 spos = (PHYSFS_sint64) pos;
803
BAIL_IF(!winSetFilePointer(h,spos,NULL,FILE_BEGIN), errcodeFromWinApi(), 0);
804
return 1; /* No error occured */
805
} /* __PHYSFS_platformSeek */
806
807
808
809
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
810
HANDLE h = (HANDLE) opaque;
811
PHYSFS_sint64 pos = 0;
812
BAIL_IF(!winSetFilePointer(h,0,&pos,FILE_CURRENT), errcodeFromWinApi(), -1);
813
return pos;
814
} /* __PHYSFS_platformTell */
815
816
817
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
818
{
819
HANDLE h = (HANDLE) opaque;
820
821
const PHYSFS_sint64 retval = winGetFileSize(h);
BAIL_IF(retval < 0, errcodeFromWinApi(), -1);
822
return retval;
823
824
} /* __PHYSFS_platformFileLength */
825
826
827
int __PHYSFS_platformFlush(void *opaque)
{
828
829
HANDLE h = (HANDLE) opaque;
BAIL_IF(!FlushFileBuffers(h), errcodeFromWinApi(), 0);
830
return 1;
831
} /* __PHYSFS_platformFlush */
832
833
834
void __PHYSFS_platformClose(void *opaque)
835
{
836
837
HANDLE h = (HANDLE) opaque;
(void) CloseHandle(h); /* ignore errors. You should have flushed! */
838
} /* __PHYSFS_platformClose */
839
840
841
static int doPlatformDelete(LPWSTR wpath)
842
{
843
844
845
846
847
848
849
850
851
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 */
852
return 1; /* if you made it here, it worked. */
853
854
855
856
857
858
} /* doPlatformDelete */
int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
859
LPWSTR wpath = NULL;
860
861
UTF8_TO_UNICODE_STACK(wpath, path);
BAIL_IF(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
862
863
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
864
return retval;
865
} /* __PHYSFS_platformDelete */
866
867
868
869
void *__PHYSFS_platformCreateMutex(void)
{
870
871
LPCRITICAL_SECTION lpcs;
lpcs = (LPCRITICAL_SECTION) allocator.Malloc(sizeof (CRITICAL_SECTION));
872
BAIL_IF(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
873
874
875
876
877
878
879
if (!winInitializeCriticalSection(lpcs))
{
allocator.Free(lpcs);
BAIL(errcodeFromWinApi(), NULL);
} /* if */
880
return lpcs;
881
882
} /* __PHYSFS_platformCreateMutex */
883
884
885
void __PHYSFS_platformDestroyMutex(void *mutex)
{
886
887
DeleteCriticalSection((LPCRITICAL_SECTION) mutex);
allocator.Free(mutex);
888
889
} /* __PHYSFS_platformDestroyMutex */
890
891
892
int __PHYSFS_platformGrabMutex(void *mutex)
{
893
894
EnterCriticalSection((LPCRITICAL_SECTION) mutex);
return 1;
895
} /* __PHYSFS_platformGrabMutex */
896
897
898
899
void __PHYSFS_platformReleaseMutex(void *mutex)
{
900
LeaveCriticalSection((LPCRITICAL_SECTION) mutex);
901
902
} /* __PHYSFS_platformReleaseMutex */
903
904
static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
905
906
907
{
SYSTEMTIME st_utc;
SYSTEMTIME st_localtz;
908
909
910
TIME_ZONE_INFORMATION tzi;
DWORD tzid;
PHYSFS_sint64 retval;
911
struct tm tm;
912
BOOL rc;
913
914
BAIL_IF(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
915
tzid = GetTimeZoneInformation(&tzi);
916
BAIL_IF(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
917
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
918
BAIL_IF(!rc, errcodeFromWinApi(), -1);
919
920
/* Convert to a format that mktime() can grok... */
921
922
923
924
925
926
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;
927
tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
928
929
tm.tm_yday = -1;
tm.tm_isdst = -1;
930
931
932
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
933
BAIL_IF(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
934
return retval;
935
936
} /* FileTimeToPhysfsTime */
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
/* 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. */
953
h = winFindFirstFileW(wpath, &w32dw);
954
955
956
957
if (h == INVALID_HANDLE_VALUE)
return 0; /* ...maybe the file just vanished...? */
FindClose(h);
958
return (w32dw.dwReserved0 == PHYSFS_IO_REPARSE_TAG_SYMLINK);
959
960
961
} /* isSymlink */
962
int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st, const int follow)
963
964
965
{
WIN32_FILE_ATTRIBUTE_DATA winstat;
WCHAR *wstr = NULL;
966
DWORD err = 0;
967
BOOL rc = 0;
968
int issymlink = 0;
969
970
971
UTF8_TO_UNICODE_STACK(wstr, filename);
BAIL_IF(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
972
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
973
974
975
976
if (!rc)
err = GetLastError();
else /* check for symlink while wstr is still available */
977
issymlink = !follow && isSymlink(wstr, winstat.dwFileAttributes);
978
979
__PHYSFS_smallFree(wstr);
980
BAIL_IF(!rc, errcodeFromWinApiError(err), 0);
981
982
983
984
st->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
st->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);
st->createtime = FileTimeToPhysfsTime(&winstat.ftCreationTime);
985
986
if (issymlink)
987
{
988
st->filetype = PHYSFS_FILETYPE_SYMLINK;
989
st->filesize = 0;
990
991
} /* if */
992
993
994
995
996
997
998
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))
999
{
1000
st->filetype = PHYSFS_FILETYPE_OTHER;