/
macclassic.c
974 lines (791 loc) · 29 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
37
#include <alloca.h>
/*
* 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.
*/
38
39
40
41
/*
* 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,
42
43
* and you may or may not be better off using that, especially since
* mutexes are no-ops in this file. Patches welcome.
44
*/
45
#ifdef __PHYSFS_CARBONIZED__ /* this is currently not defined anywhere. */
46
47
48
49
50
#include <Carbon.h>
#else
#include <OSUtils.h>
#include <Processes.h>
#include <Files.h>
51
52
53
#include <TextUtils.h>
#include <Resources.h>
#include <MacMemory.h>
54
#include <Events.h>
55
#include <DriverGestalt.h>
56
#include <Aliases.h>
57
58
59
60
61
62
63
64
#endif
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
const char *__PHYSFS_platformDirSeparator = ":";
65
66
static const char *get_macos_error_string(OSErr err)
67
68
69
70
71
72
{
if (err == noErr)
return(NULL);
switch (err)
{
73
74
75
76
77
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);
78
79
80
81
82
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);
83
84
85
86
87
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);
88
case dupFNErr: return(ERR_FILE_EXISTS);
89
90
91
92
93
94
95
96
97
98
99
100
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);
101
case memFullErr: return(ERR_OUT_OF_MEMORY);
102
103
104
105
106
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);
107
case errFSNameTooLong: return(ERR_BAD_FILENAME);
108
case errFSNotAFolder: return(ERR_NOT_A_DIR);
109
/*case errFSNotAFile: return(ERR_NOT_A_FILE);*/
110
111
112
113
114
115
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);
116
117
118
119
120
121
122
case paramErr:
case errFSBadFSRef:
case errFSBadBuffer:
case errFSMissingName:
case errFSBadPosMode:
case errFSBadAllocFlags:
123
124
125
case errFSBadItemCount:
case errFSBadSearchParams:
case afpDenyConflict:
126
return(ERR_PHYSFS_BAD_OS_CALL);
127
128
default: return(ERR_MACOS_GENERIC);
129
130
131
} /* switch */
return(NULL);
132
} /* get_macos_error_string */
133
134
135
static OSErr oserr(OSErr retval)
136
{
137
char buf[sizeof (ERR_MACOS_GENERIC) + 32];
138
const char *errstr = get_macos_error_string(retval);
139
if (strcmp(errstr, ERR_MACOS_GENERIC) == 0)
140
{
141
snprintf(buf, sizeof (buf), ERR_MACOS_GENERIC, (int) retval);
142
143
144
145
errstr = buf;
} /* if */
if (errstr != NULL)
146
__PHYSFS_setError(errstr);
147
148
return(retval);
149
150
151
} /* oserr */
152
153
static struct ProcessInfoRec procInfo;
static FSSpec procfsspec;
154
155
156
int __PHYSFS_platformInit(void)
{
157
158
OSErr err;
ProcessSerialNumber psn;
159
BAIL_IF_MACRO(oserr(GetCurrentProcess(&psn)) != noErr, NULL, 0);
160
161
162
163
164
memset(&procInfo, '\0', sizeof (ProcessInfoRec));
memset(&procfsspec, '\0', sizeof (FSSpec));
procInfo.processInfoLength = sizeof (ProcessInfoRec);
procInfo.processAppSpec = &procfsspec;
err = GetProcessInformation(&psn, &procInfo);
165
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
166
return(1); /* we're golden. */
167
168
169
170
171
172
173
174
175
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
176
177
178
179
/*
* CD detection code is borrowed from Apple Technical Q&A DV18.
* http://developer.apple.com/qa/dv/dv18.html
*/
180
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
181
{
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
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;
199
size_t size;
200
201
202
203
204
205
206
HParamBlockRec hpbr;
memset(&hpbr, '\0', sizeof (HParamBlockRec));
hpbr.volumeParam.ioNamePtr = volName;
hpbr.volumeParam.ioVRefNum = dqp->dQDrive;
hpbr.volumeParam.ioVolIndex = 0;
if (PBHGetVInfoSync(&hpbr) == noErr)
{
207
208
209
210
size = (size_t) volName[0]; /* convert to ASCIZ string... */
memmove(&volName[0], &volName[1], size);
volName[size] = '\0';
cb(data, volName);
211
212
213
214
215
} /* if */
} /* if */
dqp = (DrvQEl *) dqp->qLink;
} /* while */
216
217
218
} /* __PHYSFS_platformDetectAvailableCDs */
219
static char *convFSSpecToPath(FSSpec *spec, int includeFile)
220
221
222
223
224
225
{
char *ptr;
char *retval = NULL;
UInt32 retLength = 0;
CInfoPBRec infoPB;
Str255 str255;
226
227
228
229
str255[0] = spec->name[0];
memcpy(&str255[1], &spec->name[1], str255[0]);
230
memset(&infoPB, '\0', sizeof (CInfoPBRec));
231
infoPB.dirInfo.ioNamePtr = str255; /* put name in here. */
232
233
234
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;
235
236
237
238
239
240
/* 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;
241
if (oserr(PBGetCatInfoSync(&infoPB)) != noErr)
242
243
{
if (retval != NULL)
244
allocator.Free(retval);
245
return(NULL);
246
} /* if */
247
248
249
infoPB.dirInfo.ioFDirIndex = -1; /* look at parent dir next time. */
250
251
/* allocate more space for the retval... */
retLength += str255[0] + 1; /* + 1 for a ':' or null char... */
252
ptr = (char *) allocator.Malloc(retLength);
253
254
255
if (ptr == NULL)
{
if (retval != NULL)
256
allocator.Free(retval);
257
258
259
260
261
262
263
264
265
266
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);
267
allocator.Free(retval);
268
269
270
271
272
} /* if */
retval = ptr;
} while (infoPB.dirInfo.ioDrDirID != fsRtDirID);
return(retval);
273
274
275
276
277
278
279
280
281
282
} /* 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));
283
284
285
286
287
288
} /* __PHYSFS_platformCalcBaseDir */
char *__PHYSFS_platformGetUserName(void)
{
char *retval = NULL;
289
290
291
292
293
294
StringHandle strHandle;
short origResourceFile = CurResFile();
/* use the System resource file. */
UseResFile(0);
/* apparently, -16096 specifies the username. */
295
strHandle = GetString(-16096);
296
UseResFile(origResourceFile);
297
BAIL_IF_MACRO(strHandle == NULL, NULL, NULL);
298
299
HLock((Handle) strHandle);
300
retval = (char *) allocator.Malloc((*strHandle)[0] + 1);
301
302
303
304
305
306
307
308
309
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);
310
311
312
313
314
315
return(retval);
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
316
#if 0
317
return(NULL); /* bah...use default behaviour, I guess. */
318
319
320
321
#else
/* (Hmm. Default behaviour is broken in the base library. :) ) */
return(__PHYSFS_platformCalcBaseDir(NULL));
#endif
322
323
324
325
326
327
328
329
330
331
332
} /* __PHYSFS_platformGetUserDir */
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
{
return(1); /* single threaded. */
} /* __PHYSFS_platformGetThreadID */
int __PHYSFS_platformStricmp(const char *x, const char *y)
{
333
334
335
336
337
338
339
340
341
342
343
344
345
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);
346
347
348
} /* __PHYSFS_platformStricmp */
349
int __PHYSFS_platformStrnicmp(const char *x, const char *y, PHYSFS_uint32 len)
350
{
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
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 */
369
370
371
static OSErr fnameToFSSpecNoAlias(const char *fname, FSSpec *spec)
372
{
373
OSErr err;
374
Str255 str255;
375
int needColon = (strchr(fname, ':') == NULL);
376
int len = strlen(fname) + ((needColon) ? 1 : 0);
377
378
379
380
381
if (len > 255)
return(bdNamErr);
/* !!! FIXME: What happens with relative pathnames? */
382
383
384
385
386
387
388
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] = ':';
389
err = oserr(FSMakeFSSpec(0, 0, str255, spec));
390
return(err);
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
} /* 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, ':');
412
BAIL_IF_MACRO(!ptr, ERR_NO_SUCH_FILE, err); /* just in case */
413
ptr = strchr(ptr + 1, ':');
414
BAIL_IF_MACRO(!ptr, ERR_NO_SUCH_FILE, err); /* just in case */
415
416
*ptr = '\0';
err = fnameToFSSpecNoAlias(path, spec); /* get first dir. */
417
BAIL_IF_MACRO(oserr(err) != noErr, NULL, err);
418
419
420
start = ptr;
ptr = strchr(start + 1, ':');
421
/* Now check each element of the path for aliases... */
422
423
424
425
426
427
428
429
430
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);
431
if (err != noErr) /* not an alias, really just a bogus path. */
432
433
434
435
436
return(fnameToFSSpecNoAlias(fname, spec)); /* reset */
if ((infoPB.dirInfo.ioFlAttrib & kioFlAttribDirMask) != 0)
spec->parID = infoPB.dirInfo.ioDrDirID;
437
if (ptr != NULL) /* terminate string after next element. */
438
*ptr = '\0';
439
440
441
442
443
444
445
446
447
448
*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 */
449
450
start = ptr; /* move to the next element. */
451
452
453
454
455
456
457
if (ptr != NULL)
ptr = strchr(start + 1, ':');
} while (start != NULL);
} /* if */
else /* there's something there; make sure final file is not an alias. */
{
458
BAIL_IF_MACRO(oserr(err) != noErr, NULL, err);
459
err = ResolveAliasFileWithMountFlags(spec, 1, &folder, &alias, 0);
460
BAIL_IF_MACRO(oserr(err) != noErr, NULL, err);
461
462
463
} /* else */
return(noErr); /* w00t. */
464
465
466
} /* fnameToFSSpec */
467
468
int __PHYSFS_platformExists(const char *fname)
{
469
470
FSSpec spec;
return(fnameToFSSpec(fname, &spec) == noErr);
471
472
473
474
475
} /* __PHYSFS_platformExists */
int __PHYSFS_platformIsSymLink(const char *fname)
{
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
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';
491
BAIL_IF_MACRO(fnameToFSSpec(dir, &spec) != noErr, NULL, 0);
492
493
494
495
496
497
498
*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;
499
BAIL_IF_MACRO(oserr(PBGetCatInfoSync(&infoPB)) != noErr, NULL, 0);
500
501
502
err = FSMakeFSSpec(spec.vRefNum, infoPB.dirInfo.ioDrDirID,
(const unsigned char *) ptr, &spec);
503
504
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
BAIL_IF_MACRO(oserr(IsAliasFile(&spec, &a, &f)) != noErr, NULL, 0);
505
return(a);
506
507
508
509
510
} /* __PHYSFS_platformIsSymlink */
int __PHYSFS_platformIsDirectory(const char *fname)
{
511
512
FSSpec spec;
CInfoPBRec infoPB;
513
OSErr err;
514
515
BAIL_IF_MACRO(fnameToFSSpec(fname, &spec) != noErr, NULL, 0);
516
517
518
memset(&infoPB, '\0', sizeof (CInfoPBRec));
infoPB.dirInfo.ioNamePtr = spec.name; /* put name in here. */
infoPB.dirInfo.ioVRefNum = spec.vRefNum; /* ID of file's volume. */
519
infoPB.dirInfo.ioDrDirID = spec.parID; /* ID of bin's dir. */
520
infoPB.dirInfo.ioFDirIndex = 0; /* file (not parent) info. */
521
err = PBGetCatInfoSync(&infoPB);
522
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
523
return((infoPB.dirInfo.ioFlAttrib & kioFlAttribDirMask) != 0);
524
525
526
527
528
529
530
} /* __PHYSFS_platformIsDirectory */
char *__PHYSFS_platformCvtToDependent(const char *prepend,
const char *dirName,
const char *append)
{
531
532
533
534
535
int len = ((prepend) ? strlen(prepend) : 0) +
((append) ? strlen(append) : 0) +
strlen(dirName) + 1;
const char *src;
char *dst;
536
char *retval = (char *) allocator.Malloc(len);
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
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);
555
556
557
558
559
} /* __PHYSFS_platformCvtToDependent */
void __PHYSFS_platformTimeslice(void)
{
560
SystemTask();
561
562
563
} /* __PHYSFS_platformTimeslice */
564
565
566
567
568
/* returns int so we can use BAIL*MACRO... */
static int macClassicEnumerateFiles(const char *dirname,
int omitSymLinks,
PHYSFS_StringCallback callback,
void *callbackdata)
569
{
570
571
UInt16 i;
UInt16 max;
572
573
574
FSSpec spec;
CInfoPBRec infoPB;
Str255 str255;
575
long dirID;
576
577
BAIL_IF_MACRO(fnameToFSSpec(dirname, &spec) != noErr, NULL, 0);
578
579
580
581
582
583
584
/* 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. */
585
BAIL_IF_MACRO(oserr(PBGetCatInfoSync(&infoPB)) != noErr, NULL, NULL);
586
587
588
589
590
591
592
593
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++)
594
{
595
size_t size;
596
597
598
599
FSSpec aliasspec;
Boolean alias = 0;
Boolean folder = 0;
600
601
memset(&infoPB, '\0', sizeof (CInfoPBRec));
str255[0] = 0;
602
603
604
605
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. */
606
if (PBGetCatInfoSync(&infoPB) != noErr)
607
continue; /* skip this file. Oh well. */
608
609
610
611
612
613
614
615
616
617
618
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. */
619
620
621
622
size = (size_t) str255[0]; /* (convert to ASCIZ string...) */
memmove(&str255[0], &str255[1], size);
str255[size] = '\0';
callback(callbackdata, str255);
623
} /* for */
624
} /* macClassicEnumerateFiles */
625
626
627
628
629
630
631
632
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
PHYSFS_StringCallback callback,
void *callbackdata)
{
macClassicEnumerateFiles(dirname, omitSymLinks, callback, callbackdata);
633
634
635
636
637
} /* __PHYSFS_platformEnumerateFiles */
char *__PHYSFS_platformCurrentDir(void)
{
638
639
640
641
642
643
644
/*
* 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));
645
646
647
648
649
} /* __PHYSFS_platformCurrentDir */
char *__PHYSFS_platformRealPath(const char *path)
{
650
651
652
653
654
655
656
657
/*
* 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;
658
BAIL_IF_MACRO(fnameToFSSpec(path, &spec) != noErr, NULL, NULL);
659
return(convFSSpecToPath(&spec, 1));
660
661
662
663
664
} /* __PHYSFS_platformRealPath */
int __PHYSFS_platformMkDir(const char *path)
{
665
666
667
668
669
SInt32 val = 0;
FSSpec spec;
OSErr err = fnameToFSSpec(path, &spec);
BAIL_IF_MACRO(err == noErr, ERR_FILE_EXISTS, 0);
670
BAIL_IF_MACRO(err != fnfErr, NULL, 0);
671
672
err = DirCreate(spec.vRefNum, spec.parID, spec.name, &val);
673
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
674
return(1);
675
676
677
} /* __PHYSFS_platformMkDir */
678
679
680
681
682
683
static SInt16 *macDoOpen(const char *fname, SInt8 perm, int createIfMissing)
{
int created = 0;
SInt16 *retval = NULL;
FSSpec spec;
OSErr err = fnameToFSSpec(fname, &spec);
684
BAIL_IF_MACRO((err != noErr) && (err != fnfErr), NULL, NULL);
685
686
if (err == fnfErr)
{
687
BAIL_IF_MACRO(!createIfMissing, ERR_NO_SUCH_FILE, NULL);
688
689
err = HCreate(spec.vRefNum, spec.parID, spec.name,
procInfo.processSignature, 'BINA');
690
BAIL_IF_MACRO(oserr(err) != noErr, NULL, NULL);
691
692
693
created = 1;
} /* if */
694
retval = (SInt16 *) allocator.Malloc(sizeof (SInt16));
695
696
697
698
699
700
701
if (retval == NULL)
{
if (created)
HDelete(spec.vRefNum, spec.parID, spec.name);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
702
err = HOpenDF(spec.vRefNum, spec.parID, spec.name, perm, retval);
703
if (oserr(err) != noErr)
704
{
705
allocator.Free(retval);
706
707
if (created)
HDelete(spec.vRefNum, spec.parID, spec.name);
708
return(NULL);
709
710
711
712
713
714
} /* if */
return(retval);
} /* macDoOpen */
715
716
void *__PHYSFS_platformOpenRead(const char *filename)
{
717
718
719
SInt16 *retval = macDoOpen(filename, fsRdPerm, 0);
if (retval != NULL) /* got a file; seek to start. */
{
720
if (oserr(SetFPos(*retval, fsFromStart, 0)) != noErr)
721
722
{
FSClose(*retval);
723
return(NULL);
724
725
726
727
} /* if */
} /* if */
return((void *) retval);
728
729
730
731
732
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
733
734
735
SInt16 *retval = macDoOpen(filename, fsRdWrPerm, 1);
if (retval != NULL) /* got a file; truncate it. */
{
736
737
if ((oserr(SetEOF(*retval, 0)) != noErr) ||
(oserr(SetFPos(*retval, fsFromStart, 0)) != noErr))
738
739
{
FSClose(*retval);
740
return(NULL);
741
742
743
744
} /* if */
} /* if */
return((void *) retval);
745
746
747
748
749
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
750
751
752
SInt16 *retval = macDoOpen(filename, fsRdWrPerm, 1);
if (retval != NULL) /* got a file; seek to end. */
{
753
if (oserr(SetFPos(*retval, fsFromLEOF, 0)) != noErr)
754
755
{
FSClose(*retval);
756
return(NULL);
757
758
759
760
} /* if */
} /* if */
return(retval);
761
762
763
764
765
766
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
767
768
769
770
771
772
773
SInt16 ref = *((SInt16 *) opaque);
SInt32 br;
PHYSFS_uint32 i;
for (i = 0; i < count; i++)
{
br = size;
774
775
BAIL_IF_MACRO(oserr(FSRead(ref, &br, buffer)) != noErr, NULL, i);
BAIL_IF_MACRO(br != size, NULL, i); /* !!! FIXME: seek back if only read part of an object! */
776
777
778
779
buffer = ((PHYSFS_uint8 *) buffer) + size;
} /* for */
return(count);
780
781
782
783
784
785
} /* __PHYSFS_platformRead */
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
786
787
788
789
790
791
792
SInt16 ref = *((SInt16 *) opaque);
SInt32 bw;
PHYSFS_uint32 i;
for (i = 0; i < count; i++)
{
bw = size;
793
794
BAIL_IF_MACRO(oserr(FSWrite(ref, &bw, buffer)) != noErr, NULL, i);
BAIL_IF_MACRO(bw != size, NULL, i); /* !!! FIXME: seek back if only wrote part of an object! */
795
796
797
798
buffer = ((PHYSFS_uint8 *) buffer) + size;
} /* for */
return(count);
799
800
801
802
803
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
804
805
SInt16 ref = *((SInt16 *) opaque);
OSErr err = SetFPos(ref, fsFromStart, (SInt32) pos);
806
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
807
return(1);
808
809
810
811
812
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
813
814
SInt16 ref = *((SInt16 *) opaque);
SInt32 curPos;
815
BAIL_IF_MACRO(oserr(GetFPos(ref, &curPos)) != noErr, NULL, -1);
816
return((PHYSFS_sint64) curPos);
817
818
819
820
821
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
822
823
SInt16 ref = *((SInt16 *) opaque);
SInt32 eofPos;
824
BAIL_IF_MACRO(oserr(GetEOF(ref, &eofPos)) != noErr, NULL, -1);
825
return((PHYSFS_sint64) eofPos);
826
827
828
829
830
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformEOF(void *opaque)
{
831
832
SInt16 ref = *((SInt16 *) opaque);
SInt32 eofPos, curPos;
833
834
BAIL_IF_MACRO(oserr(GetEOF(ref, &eofPos)) != noErr, NULL, 1);
BAIL_IF_MACRO(oserr(GetFPos(ref, &curPos)) != noErr, NULL, 1);
835
return(curPos >= eofPos);
836
837
838
839
840
} /* __PHYSFS_platformEOF */
int __PHYSFS_platformFlush(void *opaque)
{
841
842
843
844
SInt16 ref = *((SInt16 *) opaque);
ParamBlockRec pb;
memset(&pb, '\0', sizeof (ParamBlockRec));
pb.ioParam.ioRefNum = ref;
845
BAIL_IF_MACRO(oserr(PBFlushFileSync(&pb)) != noErr, NULL, 0);
846
return(1);
847
848
849
850
851
} /* __PHYSFS_platformFlush */
int __PHYSFS_platformClose(void *opaque)
{
852
853
854
SInt16 ref = *((SInt16 *) opaque);
SInt16 vRefNum;
Str63 volName;
855
int flushVol = 0;
856
857
858
859
860
861
862
863
864
865
866
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 */
867
868
BAIL_IF_MACRO(oserr(FSClose(ref)) != noErr, NULL, 0);
869
allocator.Free(opaque);
870
871
872
873
if (flushVol)
FlushVol(volName, vRefNum); /* update catalog info, etc. */
874
return(1);
875
876
877
878
879
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
880
881
FSSpec spec;
OSErr err;
882
BAIL_IF_MACRO(fnameToFSSpec(path, &spec) != noErr, NULL, 0);
883
err = HDelete(spec.vRefNum, spec.parID, spec.name);
884
BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);
885
return(1);
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
} /* __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 */
912
913
914
PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname)
{
915
916
917
918
FSSpec spec;
CInfoPBRec infoPB;
UInt32 modDate;
919
920
if (fnameToFSSpec(fname, &spec) != noErr)
return(-1); /* fnameToFSSpec() sets physfs error message. */
921
922
923
924
925
926
memset(&infoPB, '\0', sizeof (CInfoPBRec));
infoPB.dirInfo.ioNamePtr = spec.name;
infoPB.dirInfo.ioVRefNum = spec.vRefNum;
infoPB.dirInfo.ioDrDirID = spec.parID;
infoPB.dirInfo.ioFDirIndex = 0;
927
BAIL_IF_MACRO(oserr(PBGetCatInfoSync(&infoPB)) != noErr, NULL, -1);
928
929
930
931
932
933
934
935
936
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);
937
938
} /* __PHYSFS_platformGetLastModTime */
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
/* !!! 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 */
973
/* end of macclassic.c ... */