/
macclassic.c
963 lines (779 loc) · 28.7 KB
1
2
3
4
5
6
7
8
/*
* MacOS Classic support routines for PhysicsFS.
*
* Please see the file LICENSE in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
9
10
11
12
#if HAVE_CONFIG_H
# include <config.h>
#endif
13
#include <stdio.h>
14
15
#include <stdlib.h>
#include <string.h>
16
#include <ctype.h>
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*
* Most of the API calls in here are, according to ADC, available since
* MacOS 8.1. I don't think I used any MacOS 9 or CarbonLib-specific
* functions. There might be one or two 8.5 calls, and perhaps when the
* ADC docs say "Available in MacOS 8.1" they really mean "this works
* with System 6, but we don't want to hear about it at this point."
*
* IsAliasFile() showed up in MacOS 8.5. You can duplicate this code with
* PBGetCatInfoSync(), which is an older API, if you hope the bits in the
* catalog info never change (which they won't for, say, MacOS 8.1).
* See Apple Technote FL-30:
* http://developer.apple.com/technotes/fl/fl_30.html
*
* If you want to use weak pointers and Gestalt, and choose the correct
* code to use during __PHYSFS_platformInit(), I'll accept a patch, but
* chances are, it wasn't worth the time it took to write this, let alone
* implement that.
*/
37
38
39
40
/*
* Please note that I haven't tried this code with CarbonLib or under
* MacOS X at all. The code in unix.c is known to work with Darwin,
41
42
* and you may or may not be better off using that, especially since
* mutexes are no-ops in this file. Patches welcome.
43
*/
44
#ifdef __PHYSFS_CARBONIZED__ /* this is currently not defined anywhere. */
45
46
47
48
49
#include <Carbon.h>
#else
#include <OSUtils.h>
#include <Processes.h>
#include <Files.h>
50
51
52
#include <TextUtils.h>
#include <Resources.h>
#include <MacMemory.h>
53
#include <Events.h>
54
#include <DriverGestalt.h>
55
#include <Aliases.h>
56
57
58
59
60
61
62
63
#endif
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
const char *__PHYSFS_platformDirSeparator = ":";
64
65
static const char *get_macos_error_string(OSErr err)
66
67
68
69
70
71
{
if (err == noErr)
return(NULL);
switch (err)
{
72
73
74
75
76
case fnfErr: return(ERR_NO_SUCH_FILE);
case notOpenErr: return(ERR_NO_SUCH_VOLUME);
case dirFulErr: return(ERR_DIRECTORY_FULL);
case dskFulErr: return(ERR_DISK_FULL);
case nsvErr: return(ERR_NO_SUCH_VOLUME);
77
78
79
80
81
case ioErr: return(ERR_IO_ERROR);
case bdNamErr: return(ERR_BAD_FILENAME);
case fnOpnErr: return(ERR_NOT_A_HANDLE);
case eofErr: return(ERR_PAST_EOF);
case posErr: return(ERR_SEEK_OUT_OF_RANGE);
82
83
84
85
86
case tmfoErr: return(ERR_TOO_MANY_HANDLES);
case wPrErr: return(ERR_VOL_LOCKED_HW);
case fLckdErr: return(ERR_FILE_LOCKED);
case vLckdErr: return(ERR_VOL_LOCKED_SW);
case fBsyErr: return(ERR_FILE_OR_DIR_BUSY);
87
case dupFNErr: return(ERR_FILE_EXISTS);
88
89
90
91
92
93
94
95
96
97
98
99
case opWrErr: return(ERR_FILE_ALREADY_OPEN_W);
case rfNumErr: return(ERR_INVALID_REFNUM);
case gfpErr: return(ERR_GETTING_FILE_POS);
case volOffLinErr: return(ERR_VOLUME_OFFLINE);
case permErr: return(ERR_PERMISSION_DENIED);
case volOnLinErr: return(ERR_VOL_ALREADY_ONLINE);
case nsDrvErr: return(ERR_NO_SUCH_DRIVE);
case noMacDskErr: return(ERR_NOT_MAC_DISK);
case extFSErr: return(ERR_VOL_EXTERNAL_FS);
case fsRnErr: return(ERR_PROBLEM_RENAME);
case badMDBErr: return(ERR_BAD_MASTER_BLOCK);
case wrPermErr: return(ERR_PERMISSION_DENIED);
100
case memFullErr: return(ERR_OUT_OF_MEMORY);
101
102
103
104
105
case dirNFErr: return(ERR_NO_SUCH_PATH);
case tmwdoErr: return(ERR_TOO_MANY_HANDLES);
case badMovErr: return(ERR_CANT_MOVE_FORBIDDEN);
case wrgVolTypErr: return(ERR_WRONG_VOL_TYPE);
case volGoneErr: return(ERR_SERVER_VOL_LOST);
106
case errFSNameTooLong: return(ERR_BAD_FILENAME);
107
case errFSNotAFolder: return(ERR_NOT_A_DIR);
108
/*case errFSNotAFile: return(ERR_NOT_A_FILE);*/
109
110
111
112
113
114
case fidNotFound: return(ERR_FILE_ID_NOT_FOUND);
case fidExists: return(ERR_FILE_ID_EXISTS);
case afpAccessDenied: return(ERR_ACCESS_DENIED);
case afpNoServer: return(ERR_SERVER_NO_RESPOND);
case afpUserNotAuth: return(ERR_USER_AUTH_FAILED);
case afpPwdExpiredErr: return(ERR_PWORD_EXPIRED);
115
116
117
118
119
120
121
case paramErr:
case errFSBadFSRef:
case errFSBadBuffer:
case errFSMissingName:
case errFSBadPosMode:
case errFSBadAllocFlags:
122
123
124
case errFSBadItemCount:
case errFSBadSearchParams:
case afpDenyConflict:
125
return(ERR_PHYSFS_BAD_OS_CALL);
126
127
default: return(ERR_MACOS_GENERIC);
128
129
130
} /* switch */
return(NULL);
131
} /* get_macos_error_string */
132
133
134
static OSErr oserr(OSErr retval)
135
{
136
char buf[sizeof (ERR_MACOS_GENERIC) + 32];
137
const char *errstr = get_macos_error_string(retval);
138
if (strcmp(errstr, ERR_MACOS_GENERIC) == 0)
139
{
140
sprintf(buf, ERR_MACOS_GENERIC, (int) retval);
141
142
143
144
errstr = buf;
} /* if */
if (errstr != NULL)
145
__PHYSFS_setError(errstr);
146
147
return(retval);
148
149
150
} /* oserr */
151
152
static struct ProcessInfoRec procInfo;
static FSSpec procfsspec;
153
154
155
int __PHYSFS_platformInit(void)
{
156
157
OSErr err;
ProcessSerialNumber psn;
158
BAIL_IF_MACRO(oserr(GetCurrentProcess(&psn)) != noErr, NULL, 0);
159
160
161
162
163
memset(&procInfo, '\0', sizeof (ProcessInfoRec));
memset(&procfsspec, '\0', sizeof (FSSpec));
procInfo.processInfoLength = sizeof (ProcessInfoRec);
procInfo.processAppSpec = &procfsspec;
err = GetProcessInformation(&psn, &procInfo);
164
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
165
return(1); /* we're golden. */
166
167
168
169
170
171
172
173
174
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
175
176
177
178
/*
* CD detection code is borrowed from Apple Technical Q&A DV18.
* http://developer.apple.com/qa/dv/dv18.html
*/
179
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
180
{
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
DriverGestaltParam pb;
DrvQEl *dqp;
OSErr status;
pb.csCode = kDriverGestaltCode;
pb.driverGestaltSelector = kdgDeviceType;
dqp = (DrvQEl *) GetDrvQHdr()->qHead;
while (dqp != NULL)
{
pb.ioCRefNum = dqp->dQRefNum;
pb.ioVRefNum = dqp->dQDrive;
status = PBStatusSync((ParmBlkPtr) &pb);
if ((status == noErr) && (pb.driverGestaltResponse == kdgCDType))
{
Str63 volName;
198
size_t size;
199
200
201
202
203
204
205
HParamBlockRec hpbr;
memset(&hpbr, '\0', sizeof (HParamBlockRec));
hpbr.volumeParam.ioNamePtr = volName;
hpbr.volumeParam.ioVRefNum = dqp->dQDrive;
hpbr.volumeParam.ioVolIndex = 0;
if (PBHGetVInfoSync(&hpbr) == noErr)
{
206
207
208
size = (size_t) volName[0]; /* convert to ASCIZ string... */
memmove(&volName[0], &volName[1], size);
volName[size] = '\0';
209
cb(data, (const char *) volName);
210
211
212
213
214
} /* if */
} /* if */
dqp = (DrvQEl *) dqp->qLink;
} /* while */
215
216
217
} /* __PHYSFS_platformDetectAvailableCDs */
218
static char *convFSSpecToPath(FSSpec *spec, int includeFile)
219
220
221
222
223
224
{
char *ptr;
char *retval = NULL;
UInt32 retLength = 0;
CInfoPBRec infoPB;
Str255 str255;
225
226
227
228
str255[0] = spec->name[0];
memcpy(&str255[1], &spec->name[1], str255[0]);
229
memset(&infoPB, '\0', sizeof (CInfoPBRec));
230
infoPB.dirInfo.ioNamePtr = str255; /* put name in here. */
231
232
233
infoPB.dirInfo.ioVRefNum = spec->vRefNum; /* ID of bin's volume. */
infoPB.dirInfo.ioDrParID = spec->parID; /* ID of bin's dir. */
infoPB.dirInfo.ioFDirIndex = (includeFile) ? 0 : -1;
234
235
236
237
238
239
/* walk the tree back to the root dir (volume), building path string... */
do
{
/* check parent dir of what we last looked at... */
infoPB.dirInfo.ioDrDirID = infoPB.dirInfo.ioDrParID;
240
if (oserr(PBGetCatInfoSync(&infoPB)) != noErr)
241
242
{
if (retval != NULL)
243
allocator.Free(retval);
244
return(NULL);
245
} /* if */
246
247
248
infoPB.dirInfo.ioFDirIndex = -1; /* look at parent dir next time. */
249
250
/* allocate more space for the retval... */
retLength += str255[0] + 1; /* + 1 for a ':' or null char... */
251
ptr = (char *) allocator.Malloc(retLength);
252
253
254
if (ptr == NULL)
{
if (retval != NULL)
255
allocator.Free(retval);
256
257
258
259
260
261
262
263
264
265
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
/* prepend new dir to retval and cleanup... */
memcpy(ptr, &str255[1], str255[0]);
ptr[str255[0]] = '\0'; /* null terminate it. */
if (retval != NULL)
{
strcat(ptr, ":");
strcat(ptr, retval);
266
allocator.Free(retval);
267
268
269
270
271
} /* if */
retval = ptr;
} while (infoPB.dirInfo.ioDrDirID != fsRtDirID);
return(retval);
272
273
274
275
276
277
278
279
280
281
} /* convFSSpecToPath */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
FSSpec spec;
/* Get the name of the binary's parent directory. */
FSMakeFSSpec(procfsspec.vRefNum, procfsspec.parID, procfsspec.name, &spec);
return(convFSSpecToPath(&spec, 0));
282
283
284
285
286
287
} /* __PHYSFS_platformCalcBaseDir */
char *__PHYSFS_platformGetUserName(void)
{
char *retval = NULL;
288
289
290
291
292
293
StringHandle strHandle;
short origResourceFile = CurResFile();
/* use the System resource file. */
UseResFile(0);
/* apparently, -16096 specifies the username. */
294
strHandle = GetString(-16096);
295
UseResFile(origResourceFile);
296
BAIL_IF_MACRO(strHandle == NULL, NULL, NULL);
297
298
HLock((Handle) strHandle);
299
retval = (char *) allocator.Malloc((*strHandle)[0] + 1);
300
301
302
303
304
305
306
307
308
if (retval == NULL)
{
HUnlock((Handle) strHandle);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
memcpy(retval, &(*strHandle)[1], (*strHandle)[0]);
retval[(*strHandle)[0]] = '\0'; /* null-terminate it. */
HUnlock((Handle) strHandle);
309
310
311
312
313
314
return(retval);
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
315
#if 0
316
return(NULL); /* bah...use default behaviour, I guess. */
317
318
319
320
#else
/* (Hmm. Default behaviour is broken in the base library. :) ) */
return(__PHYSFS_platformCalcBaseDir(NULL));
#endif
321
322
323
324
325
326
327
328
329
330
331
} /* __PHYSFS_platformGetUserDir */
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
{
return(1); /* single threaded. */
} /* __PHYSFS_platformGetThreadID */
int __PHYSFS_platformStricmp(const char *x, const char *y)
{
332
333
334
335
336
337
338
339
340
341
342
343
344
int ux, uy;
do
{
ux = toupper((int) *x);
uy = toupper((int) *y);
if (ux != uy)
return((ux > uy) ? 1 : -1);
x++;
y++;
} while ((ux) && (uy));
return(0);
345
346
347
} /* __PHYSFS_platformStricmp */
348
int __PHYSFS_platformStrnicmp(const char *x, const char *y, PHYSFS_uint32 len)
349
{
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
int ux, uy;
if (!len)
return(0);
do
{
ux = toupper((int) *x);
uy = toupper((int) *y);
if (ux != uy)
return((ux > uy) ? 1 : -1);
x++;
y++;
len--;
} while ((ux) && (uy) && (len));
return(0);
} /* __PHYSFS_platformStrnicmp */
368
369
370
static OSErr fnameToFSSpecNoAlias(const char *fname, FSSpec *spec)
371
{
372
OSErr err;
373
Str255 str255;
374
int needColon = (strchr(fname, ':') == NULL);
375
int len = strlen(fname) + ((needColon) ? 1 : 0);
376
377
378
379
380
if (len > 255)
return(bdNamErr);
/* !!! FIXME: What happens with relative pathnames? */
381
382
383
384
385
386
387
str255[0] = len;
memcpy(&str255[1], fname, len);
/* probably just a volume name, which seems to need a ':' at the end. */
if (needColon)
str255[len] = ':';
388
err = oserr(FSMakeFSSpec(0, 0, str255, spec));
389
return(err);
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
} /* fnameToFSSpecNoAlias */
static OSErr fnameToFSSpec(const char *fname, FSSpec *spec)
{
Boolean alias = 0;
Boolean folder = 0;
OSErr err = fnameToFSSpecNoAlias(fname, spec);
if (err == dirNFErr) /* might be an alias in the middle of the path. */
{
/*
* Has to be at least two ':' chars, or we wouldn't get a
* dir-not-found condition. (no ':' means it was just a volume,
* just one ':' means we would have gotten a fnfErr, if anything.
*/
char *ptr;
char *start;
char *path = alloca(strlen(fname) + 1);
strcpy(path, fname);
ptr = strchr(path, ':');
411
BAIL_IF_MACRO(!ptr, ERR_NO_SUCH_FILE, err); /* just in case */
412
ptr = strchr(ptr + 1, ':');
413
BAIL_IF_MACRO(!ptr, ERR_NO_SUCH_FILE, err); /* just in case */
414
415
*ptr = '\0';
err = fnameToFSSpecNoAlias(path, spec); /* get first dir. */
416
BAIL_IF_MACRO(oserr(err) != noErr, NULL, err);
417
418
419
start = ptr;
ptr = strchr(start + 1, ':');
420
/* Now check each element of the path for aliases... */
421
422
423
424
425
426
427
428
429
do
{
CInfoPBRec infoPB;
memset(&infoPB, '\0', sizeof (CInfoPBRec));
infoPB.dirInfo.ioNamePtr = spec->name;
infoPB.dirInfo.ioVRefNum = spec->vRefNum;
infoPB.dirInfo.ioDrDirID = spec->parID;
infoPB.dirInfo.ioFDirIndex = 0;
err = PBGetCatInfoSync(&infoPB);
430
if (err != noErr) /* not an alias, really just a bogus path. */
431
432
433
434
435
return(fnameToFSSpecNoAlias(fname, spec)); /* reset */
if ((infoPB.dirInfo.ioFlAttrib & kioFlAttribDirMask) != 0)
spec->parID = infoPB.dirInfo.ioDrDirID;
436
if (ptr != NULL) /* terminate string after next element. */
437
*ptr = '\0';
438
439
440
441
442
443
444
445
446
447
*start = strlen(start + 1); /* make it a pstring. */
err = FSMakeFSSpec(spec->vRefNum, spec->parID,
(const unsigned char *) start, spec);
if (err != noErr) /* not an alias, really a bogus path. */
return(fnameToFSSpecNoAlias(fname, spec)); /* reset */
err = ResolveAliasFileWithMountFlags(spec, 1, &folder, &alias, 0);
if (err != noErr) /* not an alias, really a bogus path. */
return(fnameToFSSpecNoAlias(fname, spec)); /* reset */
448
449
start = ptr; /* move to the next element. */
450
451
452
453
454
455
456
if (ptr != NULL)
ptr = strchr(start + 1, ':');
} while (start != NULL);
} /* if */
else /* there's something there; make sure final file is not an alias. */
{
457
BAIL_IF_MACRO(oserr(err) != noErr, NULL, err);
458
err = ResolveAliasFileWithMountFlags(spec, 1, &folder, &alias, 0);
459
BAIL_IF_MACRO(oserr(err) != noErr, NULL, err);
460
461
462
} /* else */
return(noErr); /* w00t. */
463
464
465
} /* fnameToFSSpec */
466
467
int __PHYSFS_platformExists(const char *fname)
{
468
469
FSSpec spec;
return(fnameToFSSpec(fname, &spec) == noErr);
470
471
472
473
474
} /* __PHYSFS_platformExists */
int __PHYSFS_platformIsSymLink(const char *fname)
{
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
OSErr err;
FSSpec spec;
Boolean a = 0;
Boolean f = 0;
CInfoPBRec infoPB;
char *ptr;
char *dir = alloca(strlen(fname) + 1);
BAIL_IF_MACRO(dir == NULL, ERR_OUT_OF_MEMORY, 0);
strcpy(dir, fname);
ptr = strrchr(dir, ':');
if (ptr == NULL) /* just a volume name? Can't be a symlink. */
return(0);
/* resolve aliases up to the actual file... */
*ptr = '\0';
490
BAIL_IF_MACRO(fnameToFSSpec(dir, &spec) != noErr, NULL, 0);
491
492
493
494
495
496
497
*ptr = strlen(ptr + 1); /* ptr is now a pascal string. Yikes! */
memset(&infoPB, '\0', sizeof (CInfoPBRec));
infoPB.dirInfo.ioNamePtr = spec.name;
infoPB.dirInfo.ioVRefNum = spec.vRefNum;
infoPB.dirInfo.ioDrDirID = spec.parID;
infoPB.dirInfo.ioFDirIndex = 0;
498
BAIL_IF_MACRO(oserr(PBGetCatInfoSync(&infoPB)) != noErr, NULL, 0);
499
500
501
err = FSMakeFSSpec(spec.vRefNum, infoPB.dirInfo.ioDrDirID,
(const unsigned char *) ptr, &spec);
502
503
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
BAIL_IF_MACRO(oserr(IsAliasFile(&spec, &a, &f)) != noErr, NULL, 0);
504
return(a);
505
506
507
508
509
} /* __PHYSFS_platformIsSymlink */
int __PHYSFS_platformIsDirectory(const char *fname)
{
510
511
FSSpec spec;
CInfoPBRec infoPB;
512
OSErr err;
513
514
BAIL_IF_MACRO(fnameToFSSpec(fname, &spec) != noErr, NULL, 0);
515
516
517
memset(&infoPB, '\0', sizeof (CInfoPBRec));
infoPB.dirInfo.ioNamePtr = spec.name; /* put name in here. */
infoPB.dirInfo.ioVRefNum = spec.vRefNum; /* ID of file's volume. */
518
infoPB.dirInfo.ioDrDirID = spec.parID; /* ID of bin's dir. */
519
infoPB.dirInfo.ioFDirIndex = 0; /* file (not parent) info. */
520
err = PBGetCatInfoSync(&infoPB);
521
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
522
return((infoPB.dirInfo.ioFlAttrib & kioFlAttribDirMask) != 0);
523
524
525
526
527
528
529
} /* __PHYSFS_platformIsDirectory */
char *__PHYSFS_platformCvtToDependent(const char *prepend,
const char *dirName,
const char *append)
{
530
531
532
533
534
int len = ((prepend) ? strlen(prepend) : 0) +
((append) ? strlen(append) : 0) +
strlen(dirName) + 1;
const char *src;
char *dst;
535
char *retval = (char *) allocator.Malloc(len);
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
if (prepend != NULL)
{
strcpy(retval, prepend);
dst = retval + strlen(retval);
} /* if */
else
{
*retval = '\0';
dst = retval;
} /* else */
for (src = dirName; *src; src++, dst++)
*dst = ((*src == '/') ? ':' : *src);
*dst = '\0';
return(retval);
554
555
556
557
558
} /* __PHYSFS_platformCvtToDependent */
void __PHYSFS_platformTimeslice(void)
{
559
SystemTask();
560
561
562
} /* __PHYSFS_platformTimeslice */
563
564
565
566
567
/* returns int so we can use BAIL*MACRO... */
static int macClassicEnumerateFiles(const char *dirname,
int omitSymLinks,
PHYSFS_StringCallback callback,
void *callbackdata)
568
{
569
570
UInt16 i;
UInt16 max;
571
572
573
FSSpec spec;
CInfoPBRec infoPB;
Str255 str255;
574
long dirID;
575
576
BAIL_IF_MACRO(fnameToFSSpec(dirname, &spec) != noErr, NULL, 0);
577
578
579
580
581
582
583
/* get the dir ID of what we want to enumerate... */
memset(&infoPB, '\0', sizeof (CInfoPBRec));
infoPB.dirInfo.ioNamePtr = spec.name; /* name of dir to enum. */
infoPB.dirInfo.ioVRefNum = spec.vRefNum; /* ID of file's volume. */
infoPB.dirInfo.ioDrDirID = spec.parID; /* ID of dir. */
infoPB.dirInfo.ioFDirIndex = 0; /* file (not parent) info. */
584
BAIL_IF_MACRO(oserr(PBGetCatInfoSync(&infoPB)) != noErr, NULL, NULL);
585
586
587
588
589
590
591
592
if ((infoPB.dirInfo.ioFlAttrib & kioFlAttribDirMask) == 0)
BAIL_MACRO(ERR_NOT_A_DIR, NULL);
dirID = infoPB.dirInfo.ioDrDirID;
max = infoPB.dirInfo.ioDrNmFls;
for (i = 1; i <= max; i++)
593
{
594
size_t size;
595
596
597
598
FSSpec aliasspec;
Boolean alias = 0;
Boolean folder = 0;
599
600
memset(&infoPB, '\0', sizeof (CInfoPBRec));
str255[0] = 0;
601
602
603
604
infoPB.dirInfo.ioNamePtr = str255; /* store name in here. */
infoPB.dirInfo.ioVRefNum = spec.vRefNum; /* ID of dir's volume. */
infoPB.dirInfo.ioDrDirID = dirID; /* ID of dir. */
infoPB.dirInfo.ioFDirIndex = i; /* next file's info. */
605
if (PBGetCatInfoSync(&infoPB) != noErr)
606
continue; /* skip this file. Oh well. */
607
608
609
610
611
612
613
614
615
616
617
if (FSMakeFSSpec(spec.vRefNum, dirID, str255, &aliasspec) != noErr)
continue; /* skip it. */
if (IsAliasFile(&aliasspec, &alias, &folder) != noErr)
continue; /* skip it. */
if ((alias) && (omitSymLinks))
continue;
/* still here? Add it to the list. */
618
619
620
size = (size_t) str255[0]; /* (convert to ASCIZ string...) */
memmove(&str255[0], &str255[1], size);
str255[size] = '\0';
621
callback(callbackdata, (const char *) str255);
622
} /* for */
623
624
return(1);
625
} /* macClassicEnumerateFiles */
626
627
628
629
630
631
632
633
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
PHYSFS_StringCallback callback,
void *callbackdata)
{
macClassicEnumerateFiles(dirname, omitSymLinks, callback, callbackdata);
634
635
636
637
638
} /* __PHYSFS_platformEnumerateFiles */
char *__PHYSFS_platformCurrentDir(void)
{
639
640
641
642
643
644
645
/*
* I don't think MacOS has a concept of "current directory", beyond
* what is grafted on by a given standard C library implementation,
* so just return the base dir.
* We don't use this for anything crucial at the moment anyhow.
*/
return(__PHYSFS_platformCalcBaseDir(NULL));
646
647
648
649
650
} /* __PHYSFS_platformCurrentDir */
char *__PHYSFS_platformRealPath(const char *path)
{
651
652
653
654
655
656
657
658
/*
* fnameToFSSpec() will resolve any symlinks to get to the real
* file's FSSpec, which, when converted, will contain the real
* direct path to a given file. convFSSpecToPath() mallocs a
* return value buffer.
*/
FSSpec spec;
659
BAIL_IF_MACRO(fnameToFSSpec(path, &spec) != noErr, NULL, NULL);
660
return(convFSSpecToPath(&spec, 1));
661
662
663
664
665
} /* __PHYSFS_platformRealPath */
int __PHYSFS_platformMkDir(const char *path)
{
666
667
668
669
670
SInt32 val = 0;
FSSpec spec;
OSErr err = fnameToFSSpec(path, &spec);
BAIL_IF_MACRO(err == noErr, ERR_FILE_EXISTS, 0);
671
BAIL_IF_MACRO(err != fnfErr, NULL, 0);
672
673
err = DirCreate(spec.vRefNum, spec.parID, spec.name, &val);
674
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
675
return(1);
676
677
678
} /* __PHYSFS_platformMkDir */
679
680
681
682
683
684
static SInt16 *macDoOpen(const char *fname, SInt8 perm, int createIfMissing)
{
int created = 0;
SInt16 *retval = NULL;
FSSpec spec;
OSErr err = fnameToFSSpec(fname, &spec);
685
BAIL_IF_MACRO((err != noErr) && (err != fnfErr), NULL, NULL);
686
687
if (err == fnfErr)
{
688
BAIL_IF_MACRO(!createIfMissing, ERR_NO_SUCH_FILE, NULL);
689
690
err = HCreate(spec.vRefNum, spec.parID, spec.name,
procInfo.processSignature, 'BINA');
691
BAIL_IF_MACRO(oserr(err) != noErr, NULL, NULL);
692
693
694
created = 1;
} /* if */
695
retval = (SInt16 *) allocator.Malloc(sizeof (SInt16));
696
697
698
699
700
701
702
if (retval == NULL)
{
if (created)
HDelete(spec.vRefNum, spec.parID, spec.name);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
703
err = HOpenDF(spec.vRefNum, spec.parID, spec.name, perm, retval);
704
if (oserr(err) != noErr)
705
{
706
allocator.Free(retval);
707
708
if (created)
HDelete(spec.vRefNum, spec.parID, spec.name);
709
return(NULL);
710
711
712
713
714
715
} /* if */
return(retval);
} /* macDoOpen */
716
717
void *__PHYSFS_platformOpenRead(const char *filename)
{
718
719
720
SInt16 *retval = macDoOpen(filename, fsRdPerm, 0);
if (retval != NULL) /* got a file; seek to start. */
{
721
if (oserr(SetFPos(*retval, fsFromStart, 0)) != noErr)
722
723
{
FSClose(*retval);
724
return(NULL);
725
726
727
728
} /* if */
} /* if */
return((void *) retval);
729
730
731
732
733
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
734
735
736
SInt16 *retval = macDoOpen(filename, fsRdWrPerm, 1);
if (retval != NULL) /* got a file; truncate it. */
{
737
738
if ((oserr(SetEOF(*retval, 0)) != noErr) ||
(oserr(SetFPos(*retval, fsFromStart, 0)) != noErr))
739
740
{
FSClose(*retval);
741
return(NULL);
742
743
744
745
} /* if */
} /* if */
return((void *) retval);
746
747
748
749
750
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
751
752
753
SInt16 *retval = macDoOpen(filename, fsRdWrPerm, 1);
if (retval != NULL) /* got a file; seek to end. */
{
754
if (oserr(SetFPos(*retval, fsFromLEOF, 0)) != noErr)
755
756
{
FSClose(*retval);
757
return(NULL);
758
759
760
761
} /* if */
} /* if */
return(retval);
762
763
764
765
766
767
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
768
SInt16 ref = *((SInt16 *) opaque);
769
SInt32 br = size*count;
770
771
772
BAIL_IF_MACRO(oserr(FSRead(ref, &br, buffer)) != noErr, NULL, br/size);
BAIL_IF_MACRO(br != size*count, NULL, br/size); /* !!! FIXME: seek back if only read part of an object! */
773
774
return(count);
775
776
777
778
779
780
} /* __PHYSFS_platformRead */
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
781
SInt16 ref = *((SInt16 *) opaque);
782
SInt32 bw = size*count;
783
784
785
BAIL_IF_MACRO(oserr(FSWrite(ref, &bw, buffer)) != noErr, NULL, bw/size);
BAIL_IF_MACRO(bw != size*count, NULL, bw/size); /* !!! FIXME: seek back if only wrote part of an object! */
786
787
return(count);
788
789
790
791
792
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
793
794
SInt16 ref = *((SInt16 *) opaque);
OSErr err = SetFPos(ref, fsFromStart, (SInt32) pos);
795
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
796
return(1);
797
798
799
800
801
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
802
803
SInt16 ref = *((SInt16 *) opaque);
SInt32 curPos;
804
BAIL_IF_MACRO(oserr(GetFPos(ref, &curPos)) != noErr, NULL, -1);
805
return((PHYSFS_sint64) curPos);
806
807
808
809
810
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
811
812
SInt16 ref = *((SInt16 *) opaque);
SInt32 eofPos;
813
BAIL_IF_MACRO(oserr(GetEOF(ref, &eofPos)) != noErr, NULL, -1);
814
return((PHYSFS_sint64) eofPos);
815
816
817
818
819
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformEOF(void *opaque)
{
820
821
SInt16 ref = *((SInt16 *) opaque);
SInt32 eofPos, curPos;
822
823
BAIL_IF_MACRO(oserr(GetEOF(ref, &eofPos)) != noErr, NULL, 1);
BAIL_IF_MACRO(oserr(GetFPos(ref, &curPos)) != noErr, NULL, 1);
824
return(curPos >= eofPos);
825
826
827
828
829
} /* __PHYSFS_platformEOF */
int __PHYSFS_platformFlush(void *opaque)
{
830
831
832
833
SInt16 ref = *((SInt16 *) opaque);
ParamBlockRec pb;
memset(&pb, '\0', sizeof (ParamBlockRec));
pb.ioParam.ioRefNum = ref;
834
BAIL_IF_MACRO(oserr(PBFlushFileSync(&pb)) != noErr, NULL, 0);
835
return(1);
836
837
838
839
840
} /* __PHYSFS_platformFlush */
int __PHYSFS_platformClose(void *opaque)
{
841
842
843
SInt16 ref = *((SInt16 *) opaque);
SInt16 vRefNum;
Str63 volName;
844
int flushVol = 0;
845
846
847
848
849
850
851
852
853
854
855
if (GetVRefNum(ref, &vRefNum) == noErr)
{
HParamBlockRec hpbr;
memset(&hpbr, '\0', sizeof (HParamBlockRec));
hpbr.volumeParam.ioNamePtr = volName;
hpbr.volumeParam.ioVRefNum = vRefNum;
hpbr.volumeParam.ioVolIndex = 0;
if (PBHGetVInfoSync(&hpbr) == noErr)
flushVol = 1;
} /* if */
856
857
BAIL_IF_MACRO(oserr(FSClose(ref)) != noErr, NULL, 0);
858
allocator.Free(opaque);
859
860
861
862
if (flushVol)
FlushVol(volName, vRefNum); /* update catalog info, etc. */
863
return(1);
864
865
866
867
868
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
869
870
FSSpec spec;
OSErr err;
871
BAIL_IF_MACRO(fnameToFSSpec(path, &spec) != noErr, NULL, 0);
872
err = HDelete(spec.vRefNum, spec.parID, spec.name);
873
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
874
return(1);
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
} /* __PHYSFS_platformDelete */
void *__PHYSFS_platformCreateMutex(void)
{
return((void *) 0x0001); /* no mutexes on MacOS Classic. */
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
/* no mutexes on MacOS Classic. */
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
return(1); /* no mutexes on MacOS Classic. */
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
/* no mutexes on MacOS Classic. */
} /* __PHYSFS_platformReleaseMutex */
901
902
903
PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname)
{
904
905
906
907
FSSpec spec;
CInfoPBRec infoPB;
UInt32 modDate;
908
909
if (fnameToFSSpec(fname, &spec) != noErr)
return(-1); /* fnameToFSSpec() sets physfs error message. */
910
911
912
913
914
915
memset(&infoPB, '\0', sizeof (CInfoPBRec));
infoPB.dirInfo.ioNamePtr = spec.name;
infoPB.dirInfo.ioVRefNum = spec.vRefNum;
infoPB.dirInfo.ioDrDirID = spec.parID;
infoPB.dirInfo.ioFDirIndex = 0;
916
BAIL_IF_MACRO(oserr(PBGetCatInfoSync(&infoPB)) != noErr, NULL, -1);
917
918
919
920
921
922
923
924
925
modDate = ((infoPB.dirInfo.ioFlAttrib & kioFlAttribDirMask) != 0) ?
infoPB.dirInfo.ioDrMdDat : infoPB.hFileInfo.ioFlMdDat;
/* epoch is different on MacOS. They use Jan 1, 1904, apparently. */
/* subtract seconds between those epochs, counting leap years. */
modDate -= 2082844800;
return((PHYSFS_sint64) modDate);
926
927
} /* __PHYSFS_platformGetLastModTime */
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
/* !!! FIXME: Don't use C runtime for allocators? */
int __PHYSFS_platformAllocatorInit(void)
{
return(1); /* always succeeds. */
} /* __PHYSFS_platformAllocatorInit */
void __PHYSFS_platformAllocatorDeinit(void)
{
/* no-op */
} /* __PHYSFS_platformAllocatorInit */
void *__PHYSFS_platformAllocatorMalloc(size_t s)
{
#undef malloc
return(malloc(s));
} /* __PHYSFS_platformMalloc */
void *__PHYSFS_platformAllocatorRealloc(void *ptr, size_t s)
{
#undef realloc
return(realloc(ptr, s));
} /* __PHYSFS_platformRealloc */
void __PHYSFS_platformAllocatorFree(void *ptr)
{
#undef free
free(ptr);
} /* __PHYSFS_platformAllocatorFree */
962
/* end of macclassic.c ... */