/
pocketpc.c
612 lines (474 loc) · 15.7 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
if ((LowPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
{
470
BAIL_MACRO(win32strerror(), -1);
471
472
473
474
475
476
477
478
479
480
481
482
483
484
} /* 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
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)
{
508
const PHYSFS_sint64 FileLength = __PHYSFS_platformFileLength(opaque);
509
510
511
PHYSFS_sint64 FilePosition;
int retval = 0;
512
513
514
if (FileLength == 0)
return 1; /* we're definitely at EOF. */
515
/* Get the current position in the file */
516
if ((FilePosition = __PHYSFS_platformTell(opaque)) != -1)
517
518
{
/* Non-zero if EOF is equal to the file length */
519
retval = (FilePosition == FileLength);
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
} /* 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)
{
538
539
HANDLE Handle = ((winCEfile *) opaque)->handle;
BAIL_IF_MACRO(!CloseHandle(Handle), win32strerror(), 0);
540
allocator.Free(opaque);
541
542
543
544
545
546
return(1);
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
547
548
wchar_t *w_path = NULL;
UTF8_TO_UNICODE_STACK_MACRO(w_path, path);
549
550
551
552
/* If filename is a folder */
if (GetFileAttributes(w_path) == FILE_ATTRIBUTE_DIRECTORY)
{
553
int retval = !RemoveDirectory(w_path);
554
__PHYSFS_smallFree(w_path);
555
556
557
558
BAIL_IF_MACRO(retval, win32strerror(), 0);
} /* if */
else
{
559
int retval = !DeleteFile(w_path);
560
__PHYSFS_smallFree(w_path);
561
562
563
564
565
566
567
BAIL_IF_MACRO(retval, win32strerror(), 0);
} /* else */
return(1); /* if you got here, it worked. */
} /* __PHYSFS_platformDelete */
568
569
570
571
572
/*
* !!! 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.
*/
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
598
599
600
601
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 */
602
603
/* !!! FIXME: Don't use C runtime for allocators? */
604
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
605
{
606
607
return(0); /* just use malloc() and friends. */
} /* __PHYSFS_platformSetDefaultAllocator */
608
609
610
#endif /* PHYSFS_PLATFORM_POCKETPC */
611
/* end of pocketpc.c ... */