/
macclassic.c
969 lines (785 loc) · 29.1 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
/* !!! 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 */
942
void *__PHYSFS_platformAllocatorMalloc(PHYSFS_uint64 s)
943
{
944
945
946
/* make sure s isn't larger than the address space of the platform... */
if ( s > (0xFFFFFFFFFFFFFFFF >> (64-(sizeof (size_t) * 8))) )
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
947
#undef malloc
948
return(malloc((size_t) s));
949
950
951
} /* __PHYSFS_platformMalloc */
952
void *__PHYSFS_platformAllocatorRealloc(void *ptr, PHYSFS_uint64 s)
953
{
954
955
956
/* make sure s isn't larger than the address space of the platform... */
if ( s > (0xFFFFFFFFFFFFFFFF >> (64-(sizeof (size_t) * 8))) )
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
957
#undef realloc
958
return(realloc(ptr, (size_t) s));
959
960
961
962
963
964
965
966
967
} /* __PHYSFS_platformRealloc */
void __PHYSFS_platformAllocatorFree(void *ptr)
{
#undef free
free(ptr);
} /* __PHYSFS_platformAllocatorFree */
968
/* end of macclassic.c ... */