/
platform_windows.c
933 lines (759 loc) · 27.3 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
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;
127
128
129
130
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;
131
132
case ERROR_HANDLE_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
case ERROR_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
133
/* !!! FIXME: ?? case ENOTDIR: return PHYSFS_ERR_NOT_FOUND; */
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
/* !!! 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
else
{
375
*(ptr+1) = '\0'; /* chop off filename. */
376
377
378
379
380
381
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
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 */
451
wstr = (LPWSTR) __PHYSFS_smallAlloc((psize + 1) * sizeof (WCHAR));
452
453
454
if (wstr != NULL)
{
if (pGetDir(accessToken, wstr, &psize))
455
456
457
458
459
460
461
{
/* Make sure it ends in a dirsep. We allocated +1 for this. */
if (wstr[psize - 2] != '\\')
{
wstr[psize - 1] = '\\';
wstr[psize - 0] = '\0';
} /* if */
462
retval = unicodeToUtf8Heap(wstr);
463
} /* if */
464
465
466
467
468
469
470
471
472
473
__PHYSFS_smallFree(wstr);
} /* if */
CloseHandle(accessToken);
} /* if */
done:
FreeLibrary(lib);
return retval; /* We made it: hit the showers. */
} /* __PHYSFS_platformCalcUserDir */
474
475
476
void *__PHYSFS_platformGetThreadID(void)
477
{
478
return ( (void *) ((size_t) GetCurrentThreadId()) );
479
480
481
} /* __PHYSFS_platformGetThreadID */
482
static int isSymlinkAttrs(const DWORD attr, const DWORD tag)
483
{
484
485
return ( (attr & FILE_ATTRIBUTE_REPARSE_POINT) &&
(tag == PHYSFS_IO_REPARSE_TAG_SYMLINK) );
486
487
488
} /* isSymlinkAttrs */
489
void __PHYSFS_platformEnumerateFiles(const char *dirname,
490
491
PHYSFS_EnumFilesCallback callback,
const char *origdir,
492
void *callbackdata)
493
{
494
495
HANDLE dir = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAW entw;
496
size_t len = strlen(dirname);
497
498
char *searchPath = NULL;
WCHAR *wSearchPath = NULL;
499
500
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
501
502
searchPath = (char *) __PHYSFS_smallAlloc(len + 3);
if (searchPath == NULL)
503
return;
504
505
/* Copy current dirname */
506
strcpy(searchPath, dirname);
507
508
/* if there's no '\\' at the end of the path, stick one in there. */
509
if (searchPath[len - 1] != '\\')
510
{
511
512
searchPath[len++] = '\\';
searchPath[len] = '\0';
513
514
} /* if */
515
/* Append the "*" to the end of the string */
516
strcat(searchPath, "*");
517
518
UTF8_TO_UNICODE_STACK_MACRO(wSearchPath, searchPath);
519
if (!wSearchPath)
520
return; /* oh well. */
521
522
dir = FindFirstFileW(wSearchPath, &entw);
523
524
525
526
527
__PHYSFS_smallFree(wSearchPath);
__PHYSFS_smallFree(searchPath);
if (dir == INVALID_HANDLE_VALUE)
return;
528
529
do
530
{
531
532
533
534
const DWORD attr = entw.dwFileAttributes;
const DWORD tag = entw.dwReserved0;
const WCHAR *fn = entw.cFileName;
char *utf8;
535
536
537
538
539
540
541
542
if ((fn[0] == '.') && (fn[1] == '\0'))
continue;
if ((fn[0] == '.') && (fn[1] == '.') && (fn[2] == '\0'))
continue;
utf8 = unicodeToUtf8Heap(fn);
if (utf8 != NULL)
543
{
544
545
546
547
callback(callbackdata, origdir, utf8);
allocator.Free(utf8);
} /* if */
} while (FindNextFileW(dir, &entw) != 0);
548
549
550
551
552
553
554
FindClose(dir);
} /* __PHYSFS_platformEnumerateFiles */
int __PHYSFS_platformMkDir(const char *path)
{
555
556
557
WCHAR *wpath;
DWORD rc;
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
558
rc = CreateDirectoryW(wpath, NULL);
559
__PHYSFS_smallFree(wpath);
560
BAIL_IF_MACRO(rc == 0, errcodeFromWinApi(), 0);
561
return 1;
562
563
} /* __PHYSFS_platformMkDir */
564
565
566
int __PHYSFS_platformInit(void)
{
567
return 1; /* It's all good */
568
} /* __PHYSFS_platformInit */
569
570
571
572
int __PHYSFS_platformDeinit(void)
{
573
if (detectCDThreadHandle)
574
575
576
577
578
579
580
581
582
{
if (detectCDHwnd)
PostMessageW(detectCDHwnd, WM_QUIT, 0, 0);
CloseHandle(detectCDThreadHandle);
detectCDThreadHandle = NULL;
initialDiscDetectionComplete = 0;
drivesWithMediaBitmap = 0;
} /* if */
583
return 1; /* It's all good */
584
585
586
587
588
} /* __PHYSFS_platformDeinit */
static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
{
589
HANDLE fileh;
590
591
WinApiFile *retval;
WCHAR *wfname;
592
593
UTF8_TO_UNICODE_STACK_MACRO(wfname, fname);
594
BAIL_IF_MACRO(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
595
596
fileh = CreateFileW(wfname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL);
597
__PHYSFS_smallFree(wfname);
598
599
BAIL_IF_MACRO(fileh == INVALID_HANDLE_VALUE,errcodeFromWinApi(), NULL);
600
601
retval = (WinApiFile *) allocator.Malloc(sizeof (WinApiFile));
602
if (!retval)
603
{
604
CloseHandle(fileh);
605
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
606
} /* if */
607
608
retval->readonly = rdonly;
609
retval->handle = fileh;
610
return retval;
611
612
} /* doOpen */
613
614
615
void *__PHYSFS_platformOpenRead(const char *filename)
{
616
return doOpen(filename, GENERIC_READ, OPEN_EXISTING, 1);
617
} /* __PHYSFS_platformOpenRead */
618
619
620
621
void *__PHYSFS_platformOpenWrite(const char *filename)
{
622
return doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS, 0);
623
} /* __PHYSFS_platformOpenWrite */
624
625
626
627
void *__PHYSFS_platformOpenAppend(const char *filename)
{
628
629
630
void *retval = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS, 0);
if (retval != NULL)
{
631
HANDLE h = ((WinApiFile *) retval)->handle;
632
633
DWORD rc = SetFilePointer(h, 0, NULL, FILE_END);
if (rc == PHYSFS_INVALID_SET_FILE_POINTER)
634
{
635
const PHYSFS_ErrorCode err = errcodeFromWinApi();
636
CloseHandle(h);
637
allocator.Free(retval);
638
639
640
641
BAIL_MACRO(err, NULL);
} /* if */
} /* if */
642
return retval;
643
} /* __PHYSFS_platformOpenAppend */
644
645
646
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
647
{
648
HANDLE Handle = ((WinApiFile *) opaque)->handle;
649
PHYSFS_sint64 totalRead = 0;
650
651
652
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
653
654
655
656
657
658
659
660
661
662
663
664
665
666
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numRead = 0;
if (!ReadFile(Handle, buf, thislen, &numRead, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
len -= (PHYSFS_uint64) numRead;
totalRead += (PHYSFS_sint64) numRead;
if (numRead != thislen)
break;
} /* while */
return totalRead;
667
668
} /* __PHYSFS_platformRead */
669
670
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
671
PHYSFS_uint64 len)
672
{
673
HANDLE Handle = ((WinApiFile *) opaque)->handle;
674
PHYSFS_sint64 totalWritten = 0;
675
676
677
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
678
679
680
681
682
683
684
685
686
687
688
689
690
691
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numWritten = 0;
if (!WriteFile(Handle, buffer, thislen, &numWritten, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
len -= (PHYSFS_uint64) numWritten;
totalWritten += (PHYSFS_sint64) numWritten;
if (numWritten != thislen)
break;
} /* while */
return totalWritten;
692
693
} /* __PHYSFS_platformWrite */
694
695
696
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
697
HANDLE Handle = ((WinApiFile *) opaque)->handle;
698
699
LONG HighOrderPos;
PLONG pHighOrderPos;
700
DWORD rc;
701
702
703
704
/* Get the high order 32-bits of the position */
HighOrderPos = HIGHORDER_UINT64(pos);
705
706
707
708
709
710
/*
* MSDN: "If you do not need the high-order 32 bits, this
* pointer must be set to NULL."
*/
pHighOrderPos = (HighOrderPos) ? &HighOrderPos : NULL;
711
/* Move pointer "pos" count from start of file */
712
rc = SetFilePointer(Handle, LOWORDER_UINT64(pos),
713
pHighOrderPos, FILE_BEGIN);
714
715
716
717
if ( (rc == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
{
718
BAIL_MACRO(errcodeFromWinApi(), 0);
719
720
} /* if */
721
return 1; /* No error occured */
722
} /* __PHYSFS_platformSeek */
723
724
725
726
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
727
HANDLE Handle = ((WinApiFile *) opaque)->handle;
728
LONG HighPos = 0;
729
DWORD LowPos;
730
731
732
PHYSFS_sint64 retval;
/* Get current position */
733
LowPos = SetFilePointer(Handle, 0, &HighPos, FILE_CURRENT);
734
735
if ( (LowPos == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
736
{
737
BAIL_MACRO(errcodeFromWinApi(), -1);
738
} /* if */
739
740
741
else
{
/* Combine the high/low order to create the 64-bit position value */
742
743
744
745
retval = (((PHYSFS_uint64) HighPos) << 32) | LowPos;
assert(retval >= 0);
} /* else */
746
return retval;
747
} /* __PHYSFS_platformTell */
748
749
750
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
751
{
752
HANDLE Handle = ((WinApiFile *) opaque)->handle;
753
754
DWORD SizeHigh;
DWORD SizeLow;
755
756
PHYSFS_sint64 retval;
757
SizeLow = GetFileSize(Handle, &SizeHigh);
758
759
if ( (SizeLow == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
760
{
761
BAIL_MACRO(errcodeFromWinApi(), -1);
762
} /* if */
763
764
765
else
{
/* Combine the high/low order to create the 64-bit position value */
766
767
retval = (((PHYSFS_uint64) SizeHigh) << 32) | SizeLow;
assert(retval >= 0);
768
} /* else */
769
770
return retval;
771
772
} /* __PHYSFS_platformFileLength */
773
774
775
int __PHYSFS_platformFlush(void *opaque)
{
776
WinApiFile *fh = ((WinApiFile *) opaque);
777
if (!fh->readonly)
778
BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
779
780
return 1;
781
} /* __PHYSFS_platformFlush */
782
783
784
void __PHYSFS_platformClose(void *opaque)
785
{
786
HANDLE Handle = ((WinApiFile *) opaque)->handle;
787
(void) CloseHandle(Handle); /* ignore errors. You should have flushed! */
788
allocator.Free(opaque);
789
} /* __PHYSFS_platformClose */
790
791
792
static int doPlatformDelete(LPWSTR wpath)
793
{
794
795
const int isdir = (GetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY);
const BOOL rc = (isdir) ? RemoveDirectoryW(wpath) : DeleteFileW(wpath);
796
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), 0);
797
return 1; /* if you made it here, it worked. */
798
799
800
801
802
803
} /* doPlatformDelete */
int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
804
LPWSTR wpath = NULL;
805
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
806
BAIL_IF_MACRO(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
807
808
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
809
return retval;
810
} /* __PHYSFS_platformDelete */
811
812
813
814
void *__PHYSFS_platformCreateMutex(void)
{
815
816
817
818
819
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;
820
821
} /* __PHYSFS_platformCreateMutex */
822
823
824
void __PHYSFS_platformDestroyMutex(void *mutex)
{
825
826
DeleteCriticalSection((LPCRITICAL_SECTION) mutex);
allocator.Free(mutex);
827
828
} /* __PHYSFS_platformDestroyMutex */
829
830
831
int __PHYSFS_platformGrabMutex(void *mutex)
{
832
833
EnterCriticalSection((LPCRITICAL_SECTION) mutex);
return 1;
834
} /* __PHYSFS_platformGrabMutex */
835
836
837
838
void __PHYSFS_platformReleaseMutex(void *mutex)
{
839
LeaveCriticalSection((LPCRITICAL_SECTION) mutex);
840
841
} /* __PHYSFS_platformReleaseMutex */
842
843
static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
844
845
846
{
SYSTEMTIME st_utc;
SYSTEMTIME st_localtz;
847
848
849
TIME_ZONE_INFORMATION tzi;
DWORD tzid;
PHYSFS_sint64 retval;
850
struct tm tm;
851
BOOL rc;
852
853
BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
854
tzid = GetTimeZoneInformation(&tzi);
855
BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
856
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
857
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), -1);
858
859
/* Convert to a format that mktime() can grok... */
860
861
862
863
864
865
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;
866
tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
867
868
tm.tm_yday = -1;
tm.tm_isdst = -1;
869
870
871
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
872
BAIL_IF_MACRO(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
873
return retval;
874
875
} /* FileTimeToPhysfsTime */
876
877
int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
878
879
880
{
WIN32_FILE_ATTRIBUTE_DATA winstat;
WCHAR *wstr = NULL;
881
DWORD err = 0;
882
883
884
BOOL rc = 0;
UTF8_TO_UNICODE_STACK_MACRO(wstr, filename);
885
BAIL_IF_MACRO(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
886
887
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
err = (!rc) ? GetLastError() : 0;
888
__PHYSFS_smallFree(wstr);
889
BAIL_IF_MACRO(!rc, errcodeFromWinApiError(err), 0);
890
891
892
893
st->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
st->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);
st->createtime = FileTimeToPhysfsTime(&winstat.ftCreationTime);
894
895
896
if(winstat.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
897
898
st->filetype = PHYSFS_FILETYPE_DIRECTORY;
st->filesize = 0;
899
900
901
902
903
} /* if */
else if(winstat.dwFileAttributes & (FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_DEVICE))
{
/* !!! FIXME: what are reparse points? */
904
st->filetype = PHYSFS_FILETYPE_OTHER;
905
/* !!! FIXME: don't rely on this */
906
st->filesize = 0;
907
908
909
910
911
912
} /* else if */
/* !!! FIXME: check for symlinks on Vista. */
else
{
913
914
st->filetype = PHYSFS_FILETYPE_REGULAR;
st->filesize = (((PHYSFS_uint64) winstat.nFileSizeHigh) << 32) | winstat.nFileSizeLow;
915
916
} /* else */
917
st->readonly = ((winstat.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0);
918
919
return 1;
920
921
922
} /* __PHYSFS_platformStat */
923
/* !!! FIXME: Don't use C runtime for allocators? */
924
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
925
{
926
return 0; /* just use malloc() and friends. */
927
} /* __PHYSFS_platformSetDefaultAllocator */
928
929
#endif /* PHYSFS_PLATFORM_WINDOWS */
930
931
/* end of windows.c ... */