/
platform_windows.c
917 lines (745 loc) · 27.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
10
11
12
#define __PHYSICSFS_INTERNAL__
#include "physfs_platforms.h"
#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
#define WIN32_LEAN_AND_MEAN 1
20
#include <windows.h>
21
#include <userenv.h>
22
#include <shlobj.h>
23
#include <dbt.h>
24
#include <errno.h>
25
#include <ctype.h>
26
#include <time.h>
27
28
29
#include "physfs_internal.h"
30
31
#define LOWORDER_UINT64(pos) ((PHYSFS_uint32) (pos & 0xFFFFFFFF))
#define HIGHORDER_UINT64(pos) ((PHYSFS_uint32) ((pos >> 32) & 0xFFFFFFFF))
32
33
34
35
36
37
38
/*
* 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
39
40
41
/* just in case... */
#define PHYSFS_INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
42
43
44
45
46
/* Not defined before the Vista SDK. */
#define PHYSFS_IO_REPARSE_TAG_SYMLINK 0xA000000C
47
48
49
50
#define UTF8_TO_UNICODE_STACK_MACRO(w_assignto, str) { \
if (str == NULL) \
w_assignto = NULL; \
else { \
51
const PHYSFS_uint64 len = (PHYSFS_uint64) ((strlen(str) + 1) * 2); \
52
53
w_assignto = (WCHAR *) __PHYSFS_smallAlloc(len); \
if (w_assignto != NULL) \
54
PHYSFS_utf8ToUtf16(str, (PHYSFS_uint16 *) w_assignto, len); \
55
56
} \
} \
57
58
/* Note this counts WCHARs, not codepoints! */
59
60
61
62
63
static PHYSFS_uint64 wStrLen(const WCHAR *wstr)
{
PHYSFS_uint64 len = 0;
while (*(wstr++))
len++;
64
return len;
65
66
67
68
69
70
71
72
73
74
} /* 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);
75
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
76
PHYSFS_utf8FromUtf16((const PHYSFS_uint16 *) w_str, retval, len);
77
78
79
80
ptr = allocator.Realloc(retval, strlen(retval) + 1); /* shrink. */
if (ptr != NULL)
retval = (char *) ptr;
} /* if */
81
return retval;
82
83
} /* unicodeToUtf8Heap */
84
/* !!! FIXME: do we really need readonly? If not, do we need this struct? */
85
86
87
88
typedef struct
{
HANDLE handle;
int readonly;
89
} WinApiFile;
90
91
92
93
94
static HANDLE detectCDThreadHandle = NULL;
static HWND detectCDHwnd = 0;
static volatile int initialDiscDetectionComplete = 0;
static volatile DWORD drivesWithMediaBitmap = 0;
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
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)
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
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;
case ERROR_FILE_NOT_FOUND: return PHYSFS_ERR_NO_SUCH_PATH;
case ERROR_PATH_NOT_FOUND: return PHYSFS_ERR_NO_SUCH_PATH;
case ERROR_DELETE_PENDING: return PHYSFS_ERR_NO_SUCH_PATH;
case ERROR_INVALID_DRIVE: return PHYSFS_ERR_NO_SUCH_PATH;
case ERROR_HANDLE_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
case ERROR_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
/* !!! FIXME: ?? case ENOTDIR: return PHYSFS_ERR_NO_SUCH_PATH; */
/* !!! 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 */
153
154
155
typedef BOOL (WINAPI *fnSTEM)(DWORD, LPDWORD b);
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
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);
174
175
176
177
178
179
180
181
/* 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;
182
183
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
/* 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 */
289
290
291
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
292
{
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
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++)
317
{
318
319
320
if (drives & (1 << (i - 'A')))
{
drive_str[0] = (char) i;
321
cb(data, drive_str);
322
} /* if */
323
} /* for */
324
} /* __PHYSFS_platformDetectAvailableCDs */
325
326
327
328
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
329
330
331
DWORD buflen = 64;
LPWSTR modpath = NULL;
char *retval = NULL;
332
333
334
335
336
337
338
339
340
while (1)
{
DWORD rc;
void *ptr;
if ( (ptr = allocator.Realloc(modpath, buflen*sizeof(WCHAR))) == NULL )
{
allocator.Free(modpath);
341
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
342
343
344
345
346
347
348
} /* if */
modpath = (LPWSTR) ptr;
rc = GetModuleFileNameW(NULL, modpath, buflen);
if (rc == 0)
{
allocator.Free(modpath);
349
BAIL_MACRO(errcodeFromWinApi(), NULL);
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
} /* 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 != '\\'))
372
__PHYSFS_setError(PHYSFS_ERR_OTHER_ERROR); /* oh well. */
373
374
375
376
377
378
379
380
381
else
{
*(ptr + 1) = '\0'; /* chop off filename. */
retval = unicodeToUtf8Heap(modpath);
} /* else */
} /* else */
allocator.Free(modpath);
return retval; /* w00t. */
382
383
384
} /* __PHYSFS_platformCalcBaseDir */
385
386
char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
{
387
388
389
390
391
392
393
/*
* 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);
*/
394
395
WCHAR path[MAX_PATH];
396
397
398
399
char *utf8 = NULL;
size_t len = 0;
char *retval = NULL;
400
401
402
403
if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
NULL, 0, path)))
BAIL_MACRO(PHYSFS_ERR_OS_ERROR, NULL);
404
405
utf8 = unicodeToUtf8Heap(path);
BAIL_IF_MACRO(!utf8, ERRPASS, NULL);
406
len = strlen(utf8) + strlen(org) + strlen(app) + 4;
407
408
409
410
411
412
413
retval = allocator.Malloc(len);
if (!retval)
{
allocator.Free(utf8);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
414
sprintf(retval, "%s\\%s\\%s\\", utf8, org, app);
415
return retval;
416
417
418
} /* __PHYSFS_platformCalcPrefDir */
419
char *__PHYSFS_platformCalcUserDir(void)
420
{
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
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");
BAIL_IF_MACRO(!lib, errcodeFromWinApi(), NULL);
pGetDir=(fnGetUserProfDirW) GetProcAddress(lib,"GetUserProfileDirectoryW");
GOTO_IF_MACRO(!pGetDir, errcodeFromWinApi(), done);
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &accessToken))
GOTO_MACRO(errcodeFromWinApi(), done);
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 */
wstr = (LPWSTR) __PHYSFS_smallAlloc(psize * sizeof (WCHAR));
if (wstr != NULL)
{
if (pGetDir(accessToken, wstr, &psize))
retval = unicodeToUtf8Heap(wstr);
__PHYSFS_smallFree(wstr);
} /* if */
CloseHandle(accessToken);
} /* if */
done:
FreeLibrary(lib);
return retval; /* We made it: hit the showers. */
} /* __PHYSFS_platformCalcUserDir */
466
467
468
void *__PHYSFS_platformGetThreadID(void)
469
{
470
return ( (void *) ((size_t) GetCurrentThreadId()) );
471
472
473
} /* __PHYSFS_platformGetThreadID */
474
static int isSymlinkAttrs(const DWORD attr, const DWORD tag)
475
{
476
477
return ( (attr & FILE_ATTRIBUTE_REPARSE_POINT) &&
(tag == PHYSFS_IO_REPARSE_TAG_SYMLINK) );
478
479
480
} /* isSymlinkAttrs */
481
482
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
483
484
PHYSFS_EnumFilesCallback callback,
const char *origdir,
485
void *callbackdata)
486
{
487
488
HANDLE dir = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAW entw;
489
size_t len = strlen(dirname);
490
491
char *searchPath = NULL;
WCHAR *wSearchPath = NULL;
492
493
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
494
495
searchPath = (char *) __PHYSFS_smallAlloc(len + 3);
if (searchPath == NULL)
496
return;
497
498
/* Copy current dirname */
499
strcpy(searchPath, dirname);
500
501
/* if there's no '\\' at the end of the path, stick one in there. */
502
if (searchPath[len - 1] != '\\')
503
{
504
505
searchPath[len++] = '\\';
searchPath[len] = '\0';
506
507
} /* if */
508
/* Append the "*" to the end of the string */
509
strcat(searchPath, "*");
510
511
UTF8_TO_UNICODE_STACK_MACRO(wSearchPath, searchPath);
512
if (!wSearchPath)
513
return; /* oh well. */
514
515
dir = FindFirstFileW(wSearchPath, &entw);
516
517
518
519
520
__PHYSFS_smallFree(wSearchPath);
__PHYSFS_smallFree(searchPath);
if (dir == INVALID_HANDLE_VALUE)
return;
521
522
do
523
{
524
525
526
527
const DWORD attr = entw.dwFileAttributes;
const DWORD tag = entw.dwReserved0;
const WCHAR *fn = entw.cFileName;
char *utf8;
528
529
530
531
532
533
534
535
536
537
if ((fn[0] == '.') && (fn[1] == '\0'))
continue;
if ((fn[0] == '.') && (fn[1] == '.') && (fn[2] == '\0'))
continue;
if ((omitSymLinks) && (isSymlinkAttrs(attr, tag)))
continue;
utf8 = unicodeToUtf8Heap(fn);
if (utf8 != NULL)
538
{
539
540
541
542
callback(callbackdata, origdir, utf8);
allocator.Free(utf8);
} /* if */
} while (FindNextFileW(dir, &entw) != 0);
543
544
545
546
547
548
549
FindClose(dir);
} /* __PHYSFS_platformEnumerateFiles */
int __PHYSFS_platformMkDir(const char *path)
{
550
551
552
WCHAR *wpath;
DWORD rc;
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
553
rc = CreateDirectoryW(wpath, NULL);
554
__PHYSFS_smallFree(wpath);
555
BAIL_IF_MACRO(rc == 0, errcodeFromWinApi(), 0);
556
return 1;
557
558
} /* __PHYSFS_platformMkDir */
559
560
561
int __PHYSFS_platformInit(void)
{
562
return 1; /* It's all good */
563
} /* __PHYSFS_platformInit */
564
565
566
567
int __PHYSFS_platformDeinit(void)
{
568
if (detectCDThreadHandle)
569
570
571
572
573
574
575
576
577
{
if (detectCDHwnd)
PostMessageW(detectCDHwnd, WM_QUIT, 0, 0);
CloseHandle(detectCDThreadHandle);
detectCDThreadHandle = NULL;
initialDiscDetectionComplete = 0;
drivesWithMediaBitmap = 0;
} /* if */
578
return 1; /* It's all good */
579
580
581
582
583
} /* __PHYSFS_platformDeinit */
static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
{
584
HANDLE fileh;
585
586
WinApiFile *retval;
WCHAR *wfname;
587
588
UTF8_TO_UNICODE_STACK_MACRO(wfname, fname);
589
BAIL_IF_MACRO(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
590
591
fileh = CreateFileW(wfname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL);
592
__PHYSFS_smallFree(wfname);
593
594
BAIL_IF_MACRO(fileh == INVALID_HANDLE_VALUE,errcodeFromWinApi(), NULL);
595
596
retval = (WinApiFile *) allocator.Malloc(sizeof (WinApiFile));
597
if (!retval)
598
{
599
CloseHandle(fileh);
600
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
601
} /* if */
602
603
retval->readonly = rdonly;
604
retval->handle = fileh;
605
return retval;
606
607
} /* doOpen */
608
609
610
void *__PHYSFS_platformOpenRead(const char *filename)
{
611
return doOpen(filename, GENERIC_READ, OPEN_EXISTING, 1);
612
} /* __PHYSFS_platformOpenRead */
613
614
615
616
void *__PHYSFS_platformOpenWrite(const char *filename)
{
617
return doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS, 0);
618
} /* __PHYSFS_platformOpenWrite */
619
620
621
622
void *__PHYSFS_platformOpenAppend(const char *filename)
{
623
624
625
void *retval = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS, 0);
if (retval != NULL)
{
626
HANDLE h = ((WinApiFile *) retval)->handle;
627
628
DWORD rc = SetFilePointer(h, 0, NULL, FILE_END);
if (rc == PHYSFS_INVALID_SET_FILE_POINTER)
629
{
630
const PHYSFS_ErrorCode err = errcodeFromWinApi();
631
CloseHandle(h);
632
allocator.Free(retval);
633
634
635
636
BAIL_MACRO(err, NULL);
} /* if */
} /* if */
637
return retval;
638
} /* __PHYSFS_platformOpenAppend */
639
640
641
/* !!! FIXME: this function fails if len > 0xFFFFFFFF. */
642
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
643
{
644
HANDLE Handle = ((WinApiFile *) opaque)->handle;
645
DWORD CountOfBytesRead = 0;
646
647
648
649
650
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
else if(!ReadFile(Handle, buf, (DWORD) len, &CountOfBytesRead, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
651
652
return (PHYSFS_sint64) CountOfBytesRead;
653
654
} /* __PHYSFS_platformRead */
655
656
/* !!! FIXME: this function fails if len > 0xFFFFFFFF. */
657
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
658
PHYSFS_uint64 len)
659
{
660
HANDLE Handle = ((WinApiFile *) opaque)->handle;
661
DWORD CountOfBytesWritten = 0;
662
663
664
665
666
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
else if(!WriteFile(Handle, buffer, (DWORD) len, &CountOfBytesWritten, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
667
668
return (PHYSFS_sint64) CountOfBytesWritten;
669
670
} /* __PHYSFS_platformWrite */
671
672
673
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
674
HANDLE Handle = ((WinApiFile *) opaque)->handle;
675
676
LONG HighOrderPos;
PLONG pHighOrderPos;
677
DWORD rc;
678
679
680
681
/* Get the high order 32-bits of the position */
HighOrderPos = HIGHORDER_UINT64(pos);
682
683
684
685
686
687
688
689
690
691
692
693
694
695
/*
* MSDN: "If you do not need the high-order 32 bits, this
* pointer must be set to NULL."
*/
pHighOrderPos = (HighOrderPos) ? &HighOrderPos : NULL;
/*
* !!! FIXME: MSDN: "Windows Me/98/95: If the pointer
* !!! FIXME: lpDistanceToMoveHigh is not NULL, then it must
* !!! FIXME: point to either 0, INVALID_SET_FILE_POINTER, or
* !!! FIXME: the sign extension of the value of lDistanceToMove.
* !!! FIXME: Any other value will be rejected."
*/
696
/* Move pointer "pos" count from start of file */
697
rc = SetFilePointer(Handle, LOWORDER_UINT64(pos),
698
pHighOrderPos, FILE_BEGIN);
699
700
701
702
if ( (rc == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
{
703
BAIL_MACRO(errcodeFromWinApi(), 0);
704
705
} /* if */
706
return 1; /* No error occured */
707
} /* __PHYSFS_platformSeek */
708
709
710
711
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
712
HANDLE Handle = ((WinApiFile *) opaque)->handle;
713
LONG HighPos = 0;
714
DWORD LowPos;
715
716
717
PHYSFS_sint64 retval;
/* Get current position */
718
LowPos = SetFilePointer(Handle, 0, &HighPos, FILE_CURRENT);
719
720
if ( (LowPos == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
721
{
722
BAIL_MACRO(errcodeFromWinApi(), -1);
723
} /* if */
724
725
726
else
{
/* Combine the high/low order to create the 64-bit position value */
727
728
729
730
retval = (((PHYSFS_uint64) HighPos) << 32) | LowPos;
assert(retval >= 0);
} /* else */
731
return retval;
732
} /* __PHYSFS_platformTell */
733
734
735
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
736
{
737
HANDLE Handle = ((WinApiFile *) opaque)->handle;
738
739
DWORD SizeHigh;
DWORD SizeLow;
740
741
PHYSFS_sint64 retval;
742
SizeLow = GetFileSize(Handle, &SizeHigh);
743
744
if ( (SizeLow == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
745
{
746
BAIL_MACRO(errcodeFromWinApi(), -1);
747
} /* if */
748
749
750
else
{
/* Combine the high/low order to create the 64-bit position value */
751
752
retval = (((PHYSFS_uint64) SizeHigh) << 32) | SizeLow;
assert(retval >= 0);
753
} /* else */
754
755
return retval;
756
757
} /* __PHYSFS_platformFileLength */
758
759
760
int __PHYSFS_platformFlush(void *opaque)
{
761
WinApiFile *fh = ((WinApiFile *) opaque);
762
if (!fh->readonly)
763
BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
764
765
return 1;
766
} /* __PHYSFS_platformFlush */
767
768
769
void __PHYSFS_platformClose(void *opaque)
770
{
771
HANDLE Handle = ((WinApiFile *) opaque)->handle;
772
(void) CloseHandle(Handle); /* ignore errors. You should have flushed! */
773
allocator.Free(opaque);
774
} /* __PHYSFS_platformClose */
775
776
777
static int doPlatformDelete(LPWSTR wpath)
778
{
779
780
const int isdir = (GetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY);
const BOOL rc = (isdir) ? RemoveDirectoryW(wpath) : DeleteFileW(wpath);
781
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), 0);
782
return 1; /* if you made it here, it worked. */
783
784
785
786
787
788
} /* doPlatformDelete */
int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
789
LPWSTR wpath = NULL;
790
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
791
BAIL_IF_MACRO(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
792
793
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
794
return retval;
795
} /* __PHYSFS_platformDelete */
796
797
798
799
800
801
802
/*
* !!! FIXME: why aren't we using Critical Sections instead of Mutexes?
* !!! FIXME: mutexes on Windows are for cross-process sync. CritSects are
* !!! FIXME: mutexes for threads in a single process and are faster.
*/
803
804
void *__PHYSFS_platformCreateMutex(void)
{
805
return ((void *) CreateMutex(NULL, FALSE, NULL));
806
807
} /* __PHYSFS_platformCreateMutex */
808
809
810
void __PHYSFS_platformDestroyMutex(void *mutex)
{
811
812
813
CloseHandle((HANDLE) mutex);
} /* __PHYSFS_platformDestroyMutex */
814
815
816
int __PHYSFS_platformGrabMutex(void *mutex)
{
817
return (WaitForSingleObject((HANDLE) mutex, INFINITE) != WAIT_FAILED);
818
} /* __PHYSFS_platformGrabMutex */
819
820
821
822
void __PHYSFS_platformReleaseMutex(void *mutex)
{
823
824
825
ReleaseMutex((HANDLE) mutex);
} /* __PHYSFS_platformReleaseMutex */
826
827
static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
828
829
830
{
SYSTEMTIME st_utc;
SYSTEMTIME st_localtz;
831
832
833
TIME_ZONE_INFORMATION tzi;
DWORD tzid;
PHYSFS_sint64 retval;
834
struct tm tm;
835
BOOL rc;
836
837
BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
838
tzid = GetTimeZoneInformation(&tzi);
839
BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
840
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
841
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), -1);
842
843
/* Convert to a format that mktime() can grok... */
844
845
846
847
848
849
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;
850
tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
851
852
tm.tm_yday = -1;
tm.tm_isdst = -1;
853
854
855
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
856
BAIL_IF_MACRO(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
857
return retval;
858
859
} /* FileTimeToPhysfsTime */
860
int __PHYSFS_platformStat(const char *filename, int *exists, PHYSFS_Stat *stat)
861
862
863
{
WIN32_FILE_ATTRIBUTE_DATA winstat;
WCHAR *wstr = NULL;
864
DWORD err = 0;
865
866
867
BOOL rc = 0;
UTF8_TO_UNICODE_STACK_MACRO(wstr, filename);
868
BAIL_IF_MACRO(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
869
870
871
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
err = (!rc) ? GetLastError() : 0;
*exists = ((err != ERROR_FILE_NOT_FOUND) && (err != ERROR_PATH_NOT_FOUND));
872
__PHYSFS_smallFree(wstr);
873
BAIL_IF_MACRO(!rc, errcodeFromWinApiError(err), 0);
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
stat->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
stat->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);
stat->createtime = FileTimeToPhysfsTime(&winstat.ftCreationTime);
if(winstat.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
stat->filetype = PHYSFS_FILETYPE_DIRECTORY;
stat->filesize = 0;
} /* if */
else if(winstat.dwFileAttributes & (FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_DEVICE))
{
/* !!! FIXME: what are reparse points? */
stat->filetype = PHYSFS_FILETYPE_OTHER;
/* !!! FIXME: don't rely on this */
stat->filesize = 0;
} /* else if */
/* !!! FIXME: check for symlinks on Vista. */
else
{
stat->filetype = PHYSFS_FILETYPE_REGULAR;
898
stat->filesize = (((PHYSFS_uint64) winstat.nFileSizeHigh) << 32) | winstat.nFileSizeLow;
899
900
901
902
} /* else */
stat->readonly = ((winstat.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0);
903
return 1;
904
905
906
} /* __PHYSFS_platformStat */
907
/* !!! FIXME: Don't use C runtime for allocators? */
908
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
909
{
910
return 0; /* just use malloc() and friends. */
911
} /* __PHYSFS_platformSetDefaultAllocator */
912
913
#endif /* PHYSFS_PLATFORM_WINDOWS */
914
915
/* end of windows.c ... */