/
pocketpc.c
608 lines (471 loc) · 15.6 KB
1
/*
2
* PocketPC support routines for PhysicsFS.
3
*
4
* Please see the file LICENSE.txt in the source's root directory.
5
6
7
8
*
* This file written by Ryan C. Gordon.
*/
9
10
11
12
13
#define __PHYSICSFS_INTERNAL__
#include "physfs_platforms.h"
#ifdef PHYSFS_PLATFORM_POCKETPC
14
15
16
17
18
#include <stdio.h>
#include <windows.h>
#include "physfs_internal.h"
19
20
#define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
#define INVALID_SET_FILE_POINTER 0xFFFFFFFF
21
22
23
24
25
26
27
28
typedef struct
{
HANDLE handle;
int readonly;
} winCEfile;
const char *__PHYSFS_platformDirSeparator = "\\";
29
static char *userDir = NULL;
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
* Figure out what the last failing Win32 API call was, and
* generate a human-readable string for the error message.
*
* The return value is a static buffer that is overwritten with
* each call to this function.
*/
static const char *win32strerror(void)
{
static TCHAR msgbuf[255];
TCHAR *ptr = msgbuf;
FormatMessage(
44
45
46
47
48
49
50
51
52
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
msgbuf,
sizeof (msgbuf) / sizeof (TCHAR),
NULL
);
53
54
/* chop off newlines. */
55
56
57
58
59
60
61
62
63
64
65
66
for (ptr = msgbuf; *ptr; ptr++)
{
if ((*ptr == '\n') || (*ptr == '\r'))
{
*ptr = ' ';
break;
} /* if */
} /* for */
return((const char *) msgbuf);
} /* win32strerror */
67
68
/* !!! FIXME: need to check all of these for NULLs. */
69
70
71
72
73
#define UTF8_TO_UNICODE_STACK_MACRO(w_assignto, str) { \
if (str == NULL) \
w_assignto = NULL; \
else { \
const PHYSFS_uint64 len = (PHYSFS_uint64) ((strlen(str) * 4) + 1); \
74
w_assignto = (char *) __PHYSFS_smallAlloc(len); \
75
76
77
PHYSFS_uc2fromutf8(str, (PHYSFS_uint16 *) w_assignto, len); \
} \
} \
78
79
80
81
82
83
84
static char *getExePath()
{
DWORD buflen;
int success = 0;
TCHAR *ptr = NULL;
85
TCHAR *retval = (TCHAR*) allocator.Malloc(sizeof (TCHAR) * (MAX_PATH + 1));
86
87
88
89
char *charretval;
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
retval[0] = _T('\0');
90
/* !!! FIXME: don't preallocate here? */
91
/* !!! FIXME: use smallAlloc? */
92
buflen = GetModuleFileName(NULL, retval, MAX_PATH + 1);
93
if (buflen <= 0)
94
__PHYSFS_setError(win32strerror());
95
else
96
{
97
98
99
100
101
102
103
104
105
106
retval[buflen] = '\0'; /* does API always null-terminate this? */
ptr = retval+buflen;
while( ptr != retval )
{
if( *ptr != _T('\\') )
*ptr-- = _T('\0');
else
break;
} /* while */
success = 1;
107
108
109
110
} /* else */
if (!success)
{
111
allocator.Free(retval);
112
113
114
return(NULL); /* physfs error message will be set, above. */
} /* if */
115
116
117
118
buflen = (buflen * 4) + 1;
charretval = (char *) allocator.Malloc(buflen);
if (charretval != NULL)
PHYSFS_utf8fromucs2((const PHYSFS_uint16 *) retval, charretval, buflen);
119
allocator.Free(retval);
120
121
122
return(charretval); /* w00t. */
} /* getExePath */
123
124
125
int __PHYSFS_platformInit(void)
{
126
127
userDir = getExePath();
BAIL_IF_MACRO(userDir == NULL, NULL, 0); /* failed? */
128
129
130
131
132
133
return(1); /* always succeed. */
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
134
allocator.Free(userDir);
135
136
137
138
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
139
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
140
{
141
/* no-op on this platform. */
142
143
144
145
146
} /* __PHYSFS_platformDetectAvailableCDs */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
147
return(getExePath());
148
149
150
151
152
153
154
155
156
157
158
} /* __PHYSFS_platformCalcBaseDir */
char *__PHYSFS_platformGetUserName(void)
{
BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
159
return userDir;
160
161
162
163
164
165
166
167
168
169
170
171
BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformGetUserDir */
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
{
return(1); /* single threaded. */
} /* __PHYSFS_platformGetThreadID */
int __PHYSFS_platformExists(const char *fname)
{
172
173
int retval = 0;
wchar_t *w_fname = NULL;
174
175
176
177
UTF8_TO_UNICODE_STACK_MACRO(w_fname, fname);
if (w_fname != NULL)
retval = (GetFileAttributes(w_fname) != INVALID_FILE_ATTRIBUTES);
178
__PHYSFS_smallFree(w_fname);
179
180
return(retval);
181
182
183
184
185
186
187
188
189
190
191
} /* __PHYSFS_platformExists */
int __PHYSFS_platformIsSymLink(const char *fname)
{
BAIL_MACRO(ERR_NOT_IMPLEMENTED, 0);
} /* __PHYSFS_platformIsSymlink */
int __PHYSFS_platformIsDirectory(const char *fname)
{
192
193
int retval = 0;
wchar_t *w_fname = NULL;
194
195
196
197
UTF8_TO_UNICODE_STACK_MACRO(w_fname, fname);
if (w_fname != NULL)
retval = ((GetFileAttributes(w_fname) & FILE_ATTRIBUTE_DIRECTORY) != 0);
198
__PHYSFS_smallFree(w_fname);
199
200
return(retval);
201
202
203
204
205
206
207
208
} /* __PHYSFS_platformIsDirectory */
char *__PHYSFS_platformCvtToDependent(const char *prepend,
const char *dirName,
const char *append)
{
int len = ((prepend) ? strlen(prepend) : 0) +
209
210
((append) ? strlen(append) : 0) +
strlen(dirName) + 1;
211
char *retval = (char *) allocator.Malloc(len);
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
char *p;
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
if (prepend)
strcpy(retval, prepend);
else
retval[0] = '\0';
strcat(retval, dirName);
if (append)
strcat(retval, append);
for (p = strchr(retval, '/'); p != NULL; p = strchr(p + 1, '/'))
*p = '\\';
return(retval);
} /* __PHYSFS_platformCvtToDependent */
233
234
235
static int doEnumCallback(const wchar_t *w_fname)
{
const PHYSFS_uint64 len = (PHYSFS_uint64) ((wcslen(w_fname) * 4) + 1);
236
char *str = (char *) __PHYSFS_smallAlloc(len);
237
238
PHYSFS_utf8fromucs2((const PHYSFS_uint16 *) w_fname, str, len);
callback(callbackdata, origdir, str);
239
__PHYSFS_smallFree(str);
240
241
242
243
return 1;
} /* doEnumCallback */
244
245
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
246
247
PHYSFS_EnumFilesCallback callback,
const char *origdir,
248
void *callbackdata)
249
250
251
252
{
HANDLE dir;
WIN32_FIND_DATA ent;
char *SearchPath;
253
wchar_t *w_SearchPath;
254
255
256
size_t len = strlen(dirname);
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
257
SearchPath = (char *) __PHYSFS_smallAlloc(len + 3);
258
BAIL_IF_MACRO(SearchPath == NULL, ERR_OUT_OF_MEMORY, NULL);
259
260
261
262
263
264
265
266
267
268
269
270
271
272
/* Copy current dirname */
strcpy(SearchPath, dirname);
/* if there's no '\\' at the end of the path, stick one in there. */
if (SearchPath[len - 1] != '\\')
{
SearchPath[len++] = '\\';
SearchPath[len] = '\0';
} /* if */
/* Append the "*" to the end of the string */
strcat(SearchPath, "*");
273
UTF8_TO_UNICODE_STACK_MACRO(w_SearchPath, SearchPath);
274
__PHYSFS_smallFree(SearchPath);
275
dir = FindFirstFile(w_SearchPath, &ent);
276
__PHYSFS_smallFree(w_SearchPath);
277
278
279
if (dir == INVALID_HANDLE_VALUE)
return;
280
281
282
do
{
283
const char *str = NULL;
284
285
286
287
288
289
290
if (wcscmp(ent.cFileName, L".") == 0)
continue;
if (wcscmp(ent.cFileName, L"..") == 0)
continue;
291
if (!doEnumCallback(ent.cFileName))
292
293
294
295
296
297
298
299
300
break;
} while (FindNextFile(dir, &ent) != 0);
FindClose(dir);
} /* __PHYSFS_platformEnumerateFiles */
char *__PHYSFS_platformCurrentDir(void)
{
301
return("\\");
302
303
304
305
306
} /* __PHYSFS_platformCurrentDir */
char *__PHYSFS_platformRealPath(const char *path)
{
307
char *retval = (char *) allocator.Malloc(strlen(path) + 1);
308
309
strcpy(retval,path);
return(retval);
310
311
312
313
314
} /* __PHYSFS_platformRealPath */
int __PHYSFS_platformMkDir(const char *path)
{
315
int retval = 0;
316
317
wchar_t *w_path = NULL;
UTF8_TO_UNICODE_STACK_MACRO(w_path, path);
318
319
320
321
322
323
if (w_path != NULL)
{
retval = CreateDirectory(w_path, NULL);
__PHYSFS_smallFree(w_fname);
} /* if */
return(retval);
324
325
326
327
328
329
330
} /* __PHYSFS_platformMkDir */
static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
{
HANDLE fileHandle;
winCEfile *retval;
331
332
333
wchar_t *w_fname = NULL;
UTF8_TO_UNICODE_STACK_MACRO(w_fname, fname);
334
335
fileHandle = CreateFile(w_fname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL);
336
__PHYSFS_smallFree(w_fname);
337
338
339
BAIL_IF_MACRO(fileHandle == INVALID_HANDLE_VALUE, win32strerror(), NULL);
340
retval = (winCEfile *) allocator.Malloc(sizeof (winCEfile));
341
342
if (retval == NULL)
{
343
344
CloseHandle(fileHandle);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
345
} /* if */
346
347
348
349
retval->readonly = rdonly;
retval->handle = fileHandle;
return(retval);
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
} /* doOpen */
void *__PHYSFS_platformOpenRead(const char *filename)
{
return(doOpen(filename, GENERIC_READ, OPEN_EXISTING, 1));
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
return(doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS, 0));
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
void *retval = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS, 0);
if (retval != NULL)
{
HANDLE h = ((winCEfile *) retval)->handle;
if (SetFilePointer(h, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)
{
const char *err = win32strerror();
CloseHandle(h);
375
allocator.Free(retval);
376
377
378
379
380
381
382
383
384
385
386
387
BAIL_MACRO(err, NULL);
} /* if */
} /* if */
return(retval);
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
388
HANDLE Handle = ((winCEfile *) opaque)->handle;
389
390
391
392
393
DWORD CountOfBytesRead;
PHYSFS_sint64 retval;
/* Read data from the file */
/*!!! - uint32 might be a greater # than DWORD */
394
if (!ReadFile(Handle, buffer, count * size, &CountOfBytesRead, NULL))
395
{
396
retval = -1;
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
} /* if */
else
{
/* Return the number of "objects" read. */
/* !!! - What if not the right amount of bytes was read to make an object? */
retval = CountOfBytesRead / size;
} /* else */
return(retval);
} /* __PHYSFS_platformRead */
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
413
HANDLE Handle = ((winCEfile *) opaque)->handle;
414
415
416
417
418
DWORD CountOfBytesWritten;
PHYSFS_sint64 retval;
/* Read data from the file */
/*!!! - uint32 might be a greater # than DWORD */
419
if (!WriteFile(Handle, buffer, count * size, &CountOfBytesWritten, NULL))
420
{
421
retval = -1;
422
423
424
425
426
427
428
429
} /* if */
else
{
/* Return the number of "objects" read. */
/*!!! - What if not the right number of bytes was written? */
retval = CountOfBytesWritten / size;
} /* else */
430
return(retval);
431
432
433
434
435
436
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
437
HANDLE Handle = ((winCEfile *) opaque)->handle;
438
439
440
441
442
DWORD HighOrderPos;
DWORD rc;
/* Get the high order 32-bits of the position */
//HighOrderPos = HIGHORDER_UINT64(pos);
443
HighOrderPos = (unsigned long)(pos>>32);
444
445
446
/*!!! SetFilePointer needs a signed 64-bit value. */
/* Move pointer "pos" count from start of file */
447
rc = SetFilePointer(Handle, (unsigned long)(pos&0x00000000ffffffff),
448
449
450
&HighOrderPos, FILE_BEGIN);
if ((rc == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
451
{
452
BAIL_MACRO(win32strerror(), 0);
453
}
454
455
456
457
458
459
460
return(1); /* No error occured */
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
461
HANDLE Handle = ((winCEfile *) opaque)->handle;
462
463
464
465
466
DWORD HighPos = 0;
DWORD LowPos;
PHYSFS_sint64 retval;
/* Get current position */
467
LowPos = SetFilePointer(Handle, 0, &HighPos, FILE_CURRENT);
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
if ((LowPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
{
BAIL_MACRO(win32strerror(), 0);
} /* if */
else
{
/* Combine the high/low order to create the 64-bit position value */
retval = (((PHYSFS_uint64) HighPos) << 32) | LowPos;
//assert(retval >= 0);
} /* else */
return(retval);
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
485
HANDLE Handle = ((winCEfile *) opaque)->handle;
486
487
488
489
DWORD SizeHigh;
DWORD SizeLow;
PHYSFS_sint64 retval;
490
SizeLow = GetFileSize(Handle, &SizeHigh);
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
if ((SizeLow == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
{
BAIL_MACRO(win32strerror(), -1);
} /* if */
else
{
/* Combine the high/low order to create the 64-bit position value */
retval = (((PHYSFS_uint64) SizeHigh) << 32) | SizeLow;
//assert(retval >= 0);
} /* else */
return(retval);
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformEOF(void *opaque)
{
PHYSFS_sint64 FilePosition;
int retval = 0;
/* Get the current position in the file */
if ((FilePosition = __PHYSFS_platformTell(opaque)) != 0)
{
/* Non-zero if EOF is equal to the file length */
retval = FilePosition == __PHYSFS_platformFileLength(opaque);
} /* if */
return(retval);
} /* __PHYSFS_platformEOF */
int __PHYSFS_platformFlush(void *opaque)
{
winCEfile *fh = ((winCEfile *) opaque);
if (!fh->readonly)
BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), win32strerror(), 0);
return(1);
} /* __PHYSFS_platformFlush */
int __PHYSFS_platformClose(void *opaque)
{
534
535
HANDLE Handle = ((winCEfile *) opaque)->handle;
BAIL_IF_MACRO(!CloseHandle(Handle), win32strerror(), 0);
536
allocator.Free(opaque);
537
538
539
540
541
542
return(1);
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
543
544
wchar_t *w_path = NULL;
UTF8_TO_UNICODE_STACK_MACRO(w_path, path);
545
546
547
548
/* If filename is a folder */
if (GetFileAttributes(w_path) == FILE_ATTRIBUTE_DIRECTORY)
{
549
int retval = !RemoveDirectory(w_path);
550
__PHYSFS_smallFree(w_path);
551
552
553
554
BAIL_IF_MACRO(retval, win32strerror(), 0);
} /* if */
else
{
555
int retval = !DeleteFile(w_path);
556
__PHYSFS_smallFree(w_path);
557
558
559
560
561
562
563
BAIL_IF_MACRO(retval, win32strerror(), 0);
} /* else */
return(1); /* if you got here, it worked. */
} /* __PHYSFS_platformDelete */
564
565
566
567
568
/*
* !!! 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.
*/
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
void *__PHYSFS_platformCreateMutex(void)
{
return((void *) CreateMutex(NULL, FALSE, NULL));
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
CloseHandle((HANDLE) mutex);
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
return(WaitForSingleObject((HANDLE) mutex, INFINITE) != WAIT_FAILED);
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
ReleaseMutex((HANDLE) mutex);
} /* __PHYSFS_platformReleaseMutex */
PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname)
{
BAIL_MACRO(ERR_NOT_IMPLEMENTED, -1);
} /* __PHYSFS_platformGetLastModTime */
598
599
/* !!! FIXME: Don't use C runtime for allocators? */
600
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
601
{
602
603
return(0); /* just use malloc() and friends. */
} /* __PHYSFS_platformSetDefaultAllocator */
604
605
606
#endif /* PHYSFS_PLATFORM_POCKETPC */
607
/* end of pocketpc.c ... */