/
platform_windows.c
910 lines (739 loc) · 26.9 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
/*
* MSDN: "If you do not need the high-order 32 bits, this
* pointer must be set to NULL."
*/
pHighOrderPos = (HighOrderPos) ? &HighOrderPos : NULL;
688
/* Move pointer "pos" count from start of file */
689
rc = SetFilePointer(Handle, LOWORDER_UINT64(pos),
690
pHighOrderPos, FILE_BEGIN);
691
692
693
694
if ( (rc == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
{
695
BAIL_MACRO(errcodeFromWinApi(), 0);
696
697
} /* if */
698
return 1; /* No error occured */
699
} /* __PHYSFS_platformSeek */
700
701
702
703
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
704
HANDLE Handle = ((WinApiFile *) opaque)->handle;
705
LONG HighPos = 0;
706
DWORD LowPos;
707
708
709
PHYSFS_sint64 retval;
/* Get current position */
710
LowPos = SetFilePointer(Handle, 0, &HighPos, FILE_CURRENT);
711
712
if ( (LowPos == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
713
{
714
BAIL_MACRO(errcodeFromWinApi(), -1);
715
} /* if */
716
717
718
else
{
/* Combine the high/low order to create the 64-bit position value */
719
720
721
722
retval = (((PHYSFS_uint64) HighPos) << 32) | LowPos;
assert(retval >= 0);
} /* else */
723
return retval;
724
} /* __PHYSFS_platformTell */
725
726
727
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
728
{
729
HANDLE Handle = ((WinApiFile *) opaque)->handle;
730
731
DWORD SizeHigh;
DWORD SizeLow;
732
733
PHYSFS_sint64 retval;
734
SizeLow = GetFileSize(Handle, &SizeHigh);
735
736
if ( (SizeLow == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
737
{
738
BAIL_MACRO(errcodeFromWinApi(), -1);
739
} /* if */
740
741
742
else
{
/* Combine the high/low order to create the 64-bit position value */
743
744
retval = (((PHYSFS_uint64) SizeHigh) << 32) | SizeLow;
assert(retval >= 0);
745
} /* else */
746
747
return retval;
748
749
} /* __PHYSFS_platformFileLength */
750
751
752
int __PHYSFS_platformFlush(void *opaque)
{
753
WinApiFile *fh = ((WinApiFile *) opaque);
754
if (!fh->readonly)
755
BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
756
757
return 1;
758
} /* __PHYSFS_platformFlush */
759
760
761
void __PHYSFS_platformClose(void *opaque)
762
{
763
HANDLE Handle = ((WinApiFile *) opaque)->handle;
764
(void) CloseHandle(Handle); /* ignore errors. You should have flushed! */
765
allocator.Free(opaque);
766
} /* __PHYSFS_platformClose */
767
768
769
static int doPlatformDelete(LPWSTR wpath)
770
{
771
772
const int isdir = (GetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY);
const BOOL rc = (isdir) ? RemoveDirectoryW(wpath) : DeleteFileW(wpath);
773
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), 0);
774
return 1; /* if you made it here, it worked. */
775
776
777
778
779
780
} /* doPlatformDelete */
int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
781
LPWSTR wpath = NULL;
782
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
783
BAIL_IF_MACRO(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
784
785
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
786
return retval;
787
} /* __PHYSFS_platformDelete */
788
789
790
791
void *__PHYSFS_platformCreateMutex(void)
{
792
793
794
795
796
LPCRITICAL_SECTION lpcs;
lpcs = (LPCRITICAL_SECTION) allocator.Malloc(sizeof (CRITICAL_SECTION));
BAIL_IF_MACRO(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
InitializeCriticalSection(lpcs);
return lpcs;
797
798
} /* __PHYSFS_platformCreateMutex */
799
800
801
void __PHYSFS_platformDestroyMutex(void *mutex)
{
802
803
DeleteCriticalSection((LPCRITICAL_SECTION) mutex);
allocator.Free(mutex);
804
805
} /* __PHYSFS_platformDestroyMutex */
806
807
808
int __PHYSFS_platformGrabMutex(void *mutex)
{
809
810
EnterCriticalSection((LPCRITICAL_SECTION) mutex);
return 1;
811
} /* __PHYSFS_platformGrabMutex */
812
813
814
815
void __PHYSFS_platformReleaseMutex(void *mutex)
{
816
LeaveCriticalSection((LPCRITICAL_SECTION) mutex);
817
818
} /* __PHYSFS_platformReleaseMutex */
819
820
static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
821
822
823
{
SYSTEMTIME st_utc;
SYSTEMTIME st_localtz;
824
825
826
TIME_ZONE_INFORMATION tzi;
DWORD tzid;
PHYSFS_sint64 retval;
827
struct tm tm;
828
BOOL rc;
829
830
BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
831
tzid = GetTimeZoneInformation(&tzi);
832
BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
833
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
834
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), -1);
835
836
/* Convert to a format that mktime() can grok... */
837
838
839
840
841
842
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;
843
tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
844
845
tm.tm_yday = -1;
tm.tm_isdst = -1;
846
847
848
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
849
BAIL_IF_MACRO(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
850
return retval;
851
852
} /* FileTimeToPhysfsTime */
853
int __PHYSFS_platformStat(const char *filename, int *exists, PHYSFS_Stat *stat)
854
855
856
{
WIN32_FILE_ATTRIBUTE_DATA winstat;
WCHAR *wstr = NULL;
857
DWORD err = 0;
858
859
860
BOOL rc = 0;
UTF8_TO_UNICODE_STACK_MACRO(wstr, filename);
861
BAIL_IF_MACRO(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
862
863
864
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
err = (!rc) ? GetLastError() : 0;
*exists = ((err != ERROR_FILE_NOT_FOUND) && (err != ERROR_PATH_NOT_FOUND));
865
__PHYSFS_smallFree(wstr);
866
BAIL_IF_MACRO(!rc, errcodeFromWinApiError(err), 0);
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
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;
891
stat->filesize = (((PHYSFS_uint64) winstat.nFileSizeHigh) << 32) | winstat.nFileSizeLow;
892
893
894
895
} /* else */
stat->readonly = ((winstat.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0);
896
return 1;
897
898
899
} /* __PHYSFS_platformStat */
900
/* !!! FIXME: Don't use C runtime for allocators? */
901
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
902
{
903
return 0; /* just use malloc() and friends. */
904
} /* __PHYSFS_platformSetDefaultAllocator */
905
906
#endif /* PHYSFS_PLATFORM_WINDOWS */
907
908
/* end of windows.c ... */