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