/
unix.c
744 lines (575 loc) · 17.2 KB
1
2
3
4
5
6
7
8
/*
* Unix 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
14
15
16
17
18
#if ((defined __APPLE__) && (defined __MACH__))
# if (!defined __DARWIN__)
# define __DARWIN__
# endif
#endif
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#if (defined __STRICT_ANSI__)
#define __PHYSFS_DOING_STRICT_ANSI__
#endif
/*
* We cheat a little: I want the symlink version of stat() (lstat), and
* GCC/Linux will not declare it if compiled with the -ansi flag.
* If you are really lacking symlink support on your platform,
* you should #define __PHYSFS_NO_SYMLINKS__ before compiling this
* file. That will open a security hole, though, if you really DO have
* symlinks on your platform; it renders PHYSFS_permitSymbolicLinks(0)
* useless, since every symlink will be reported as a regular file/dir.
*/
#if (defined __PHYSFS_DOING_STRICT_ANSI__)
#undef __STRICT_ANSI__
#endif
35
#include <stdio.h>
36
37
38
39
#if (defined __PHYSFS_DOING_STRICT_ANSI__)
#define __STRICT_ANSI__
#endif
40
#include <stdlib.h>
41
42
#include <string.h>
#include <ctype.h>
43
#include <pthread.h>
44
45
46
47
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <sys/stat.h>
48
#include <sys/param.h>
49
50
51
#include <dirent.h>
#include <time.h>
#include <errno.h>
52
53
54
55
#if (!defined __DARWIN__)
#include <mntent.h>
#else
56
57
#include <sys/ucred.h>
#endif
58
59
60
61
#include <sys/mount.h>
62
63
64
65
66
67
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
const char *__PHYSFS_platformDirSeparator = "/";
68
69
70
71
72
73
74
75
76
77
78
79
80
81
int __PHYSFS_platformInit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
82
83
84
85
86
87
88
89
90
91
#if (defined __DARWIN__)
char **__PHYSFS_platformDetectAvailableCDs(void)
{
char **retval = (char **) malloc(sizeof (char *));
int cd_count = 1; /* We count the NULL entry. */
struct statfs* mntbufp = NULL;
int mounts;
int ii;
92
93
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
94
95
96
97
98
99
100
mounts = getmntinfo( &mntbufp, MNT_WAIT );
for ( ii=0; ii < mounts; ++ii ) {
int add_it = 0;
if ( strcmp( mntbufp[ii].f_fstypename, "iso9660") == 0 )
add_it = 1;
101
102
else if ( strcmp( mntbufp[ii].f_fstypename, "cd9660") == 0 )
add_it = 1;
103
104
/* add other mount types here */
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
if (add_it)
{
char **tmp = realloc(retval, sizeof (char *) * cd_count + 1);
if (tmp)
{
retval = tmp;
retval[cd_count-1] = (char *)
malloc(strlen(mntbufp[ ii ].f_mntonname) + 1);
if (retval[cd_count-1])
{
strcpy(retval[cd_count-1], mntbufp[ ii ].f_mntonname);
cd_count++;
} /* if */
} /* if */
} /* if */
}
free( mntbufp );
retval[cd_count - 1] = NULL;
return(retval);
} /* __PHYSFS_platformDetectAvailableCDs */
#else /* non-Darwin implementation... */
133
134
char **__PHYSFS_platformDetectAvailableCDs(void)
{
135
136
137
138
139
char **retval = (char **) malloc(sizeof (char *));
int cd_count = 1; /* We count the NULL entry. */
FILE *mounts = NULL;
struct mntent *ent = NULL;
140
141
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
142
143
144
145
146
147
148
149
150
*retval = NULL;
mounts = setmntent("/etc/mtab", "r");
BAIL_IF_MACRO(mounts == NULL, ERR_IO_ERROR, retval);
while ( (ent = getmntent(mounts)) != NULL )
{
int add_it = 0;
if (strcmp(ent->mnt_type, "iso9660") == 0)
add_it = 1;
151
152
/* add other mount types here */
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
if (add_it)
{
char **tmp = realloc(retval, sizeof (char *) * cd_count + 1);
if (tmp)
{
retval = tmp;
retval[cd_count-1] = (char *) malloc(strlen(ent->mnt_dir) + 1);
if (retval[cd_count-1])
{
strcpy(retval[cd_count-1], ent->mnt_dir);
cd_count++;
} /* if */
} /* if */
} /* if */
} /* while */
endmntent(mounts);
171
172
retval[cd_count - 1] = NULL;
173
return(retval);
174
175
176
} /* __PHYSFS_platformDetectAvailableCDs */
#endif
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
static char *copyEnvironmentVariable(const char *varname)
{
const char *envr = getenv(varname);
char *retval = NULL;
if (envr != NULL)
{
retval = malloc(strlen(envr) + 1);
if (retval != NULL)
strcpy(retval, envr);
} /* if */
return(retval);
} /* copyEnvironmentVariable */
195
196
197
198
199
200
201
202
203
204
/*
* See where program (bin) resides in the $PATH specified by (envr).
* returns a copy of the first element in envr that contains it, or NULL
* if it doesn't exist or there were other problems. PHYSFS_SetError() is
* called if we have a problem.
*
* (envr) will be scribbled over, and you are expected to free() the
* return value when you're done with it.
*/
static char *findBinaryInPath(const char *bin, char *envr)
205
{
206
207
208
size_t alloc_size = 0;
char *exe = NULL;
char *start = envr;
209
210
char *ptr;
211
212
BAIL_IF_MACRO(bin == NULL, ERR_INVALID_ARGUMENT, NULL);
BAIL_IF_MACRO(envr == NULL, ERR_INVALID_ARGUMENT, NULL);
213
214
215
do
{
216
217
size_t size;
ptr = strchr(start, ':'); /* find next $PATH separator. */
218
219
220
if (ptr)
*ptr = '\0';
221
222
size = strlen(start) + strlen(bin) + 2;
if (size > alloc_size)
223
{
224
225
226
227
228
229
230
231
232
233
char *x = (char *) realloc(exe, size);
if (x == NULL)
{
if (exe != NULL)
free(exe);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
alloc_size = size;
exe = x;
234
} /* if */
235
236
/* build full binary path... */
237
strcpy(exe, start);
238
239
if (exe[strlen(exe) - 1] != '/')
strcat(exe, "/");
240
241
242
strcat(exe, bin);
if (access(exe, X_OK) == 0) /* Exists as executable? We're done. */
243
{
244
245
246
strcpy(exe, start); /* i'm lazy. piss off. */
return(exe);
} /* if */
247
248
start = ptr + 1; /* start points to beginning of next element. */
249
250
} while (ptr != NULL);
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
if (exe != NULL)
free(exe);
return(NULL); /* doesn't exist in path. */
} /* findBinaryInPath */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
/* If there isn't a path on argv0, then look through the $PATH for it. */
char *retval;
char *envr;
if (strchr(argv0, '/') != NULL) /* default behaviour can handle this. */
return(NULL);
envr = copyEnvironmentVariable("PATH");
BAIL_IF_MACRO(!envr, NULL, NULL);
retval = findBinaryInPath(argv0, envr);
271
272
273
274
275
free(envr);
return(retval);
} /* __PHYSFS_platformCalcBaseDir */
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
static char *getUserNameByUID(void)
{
uid_t uid = getuid();
struct passwd *pw;
char *retval = NULL;
pw = getpwuid(uid);
if ((pw != NULL) && (pw->pw_name != NULL))
{
retval = malloc(strlen(pw->pw_name) + 1);
if (retval != NULL)
strcpy(retval, pw->pw_name);
} /* if */
return(retval);
} /* getUserNameByUID */
static char *getUserDirByUID(void)
{
uid_t uid = getuid();
struct passwd *pw;
char *retval = NULL;
pw = getpwuid(uid);
if ((pw != NULL) && (pw->pw_dir != NULL))
{
retval = malloc(strlen(pw->pw_dir) + 1);
if (retval != NULL)
strcpy(retval, pw->pw_dir);
} /* if */
return(retval);
} /* getUserDirByUID */
312
313
char *__PHYSFS_platformGetUserName(void)
{
314
315
316
317
char *retval = getUserNameByUID();
if (retval == NULL)
retval = copyEnvironmentVariable("USER");
return(retval);
318
319
320
321
322
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
323
324
325
326
char *retval = copyEnvironmentVariable("HOME");
if (retval == NULL)
retval = getUserDirByUID();
return(retval);
327
328
329
} /* __PHYSFS_platformGetUserDir */
330
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
331
{
332
return((PHYSFS_uint64) ((PHYSFS_uint32) pthread_self()));
333
334
335
} /* __PHYSFS_platformGetThreadID */
336
337
/* -ansi and -pedantic flags prevent use of strcasecmp() on Linux. */
int __PHYSFS_platformStricmp(const char *x, const char *y)
338
{
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
int ux, uy;
do
{
ux = toupper((int) *x);
uy = toupper((int) *y);
if (ux > uy)
return(1);
else if (ux < uy)
return(-1);
x++;
y++;
} while ((ux) && (uy));
return(0);
354
355
356
} /* __PHYSFS_platformStricmp */
357
358
359
360
361
362
363
364
int __PHYSFS_platformExists(const char *fname)
{
struct stat statbuf;
return(stat(fname, &statbuf) == 0);
} /* __PHYSFS_platformExists */
int __PHYSFS_platformIsSymLink(const char *fname)
365
{
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
#if (defined __PHYSFS_NO_SYMLINKS__)
return(0);
#else
struct stat statbuf;
int retval = 0;
if (lstat(fname, &statbuf) == 0)
{
if (S_ISLNK(statbuf.st_mode))
retval = 1;
} /* if */
return(retval);
#endif
382
383
384
385
386
} /* __PHYSFS_platformIsSymlink */
int __PHYSFS_platformIsDirectory(const char *fname)
{
387
388
389
390
391
392
393
394
395
396
struct stat statbuf;
int retval = 0;
if (stat(fname, &statbuf) == 0)
{
if (S_ISDIR(statbuf.st_mode))
retval = 1;
} /* if */
return(retval);
397
398
399
} /* __PHYSFS_platformIsDirectory */
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
char *__PHYSFS_platformCvtToDependent(const char *prepend,
const char *dirName,
const char *append)
{
int len = ((prepend) ? strlen(prepend) : 0) +
((append) ? strlen(append) : 0) +
strlen(dirName) + 1;
char *retval = malloc(len);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
/* platform-independent notation is Unix-style already. :) */
if (prepend)
strcpy(retval, prepend);
else
retval[0] = '\0';
strcat(retval, dirName);
if (append)
strcat(retval, append);
return(retval);
} /* __PHYSFS_platformCvtToDependent */
/* Much like my college days, try to sleep for 10 milliseconds at a time... */
void __PHYSFS_platformTimeslice(void)
{
430
usleep( 10 * 1000 ); /* don't care if it fails. */
431
432
433
} /* __PHYSFS_platformTimeslice */
434
435
LinkedStringList *__PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks)
436
437
438
439
440
441
{
LinkedStringList *retval = NULL;
LinkedStringList *l = NULL;
LinkedStringList *prev = NULL;
DIR *dir;
struct dirent *ent;
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
int bufsize = 0;
char *buf = NULL;
int dlen = 0;
if (omitSymLinks)
{
dlen = strlen(dirname);
bufsize = dlen + 256;
buf = malloc(bufsize);
BAIL_IF_MACRO(buf == NULL, ERR_OUT_OF_MEMORY, NULL);
strcpy(buf, dirname);
if (buf[dlen - 1] != '/')
{
buf[dlen++] = '/';
buf[dlen] = '\0';
} /* if */
} /* if */
459
460
461
errno = 0;
dir = opendir(dirname);
462
463
464
465
466
467
if (dir == NULL)
{
if (buf != NULL)
free(buf);
BAIL_IF_MACRO(1, strerror(errno), NULL);
} /* if */
468
469
470
471
472
473
474
while (1)
{
ent = readdir(dir);
if (ent == NULL) /* we're done. */
break;
475
476
477
478
479
480
if (strcmp(ent->d_name, ".") == 0)
continue;
if (strcmp(ent->d_name, "..") == 0)
continue;
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
if (omitSymLinks)
{
char *p;
int len = strlen(ent->d_name) + dlen + 1;
if (len > bufsize)
{
p = realloc(buf, len);
if (p == NULL)
continue;
buf = p;
bufsize = len;
} /* if */
strcpy(buf + dlen, ent->d_name);
if (__PHYSFS_platformIsSymLink(buf))
continue;
} /* if */
499
l = (LinkedStringList *) malloc(sizeof (LinkedStringList));
500
if (l == NULL)
501
502
503
504
505
506
507
508
509
break;
l->str = (char *) malloc(strlen(ent->d_name) + 1);
if (l->str == NULL)
{
free(l);
break;
} /* if */
510
511
strcpy(l->str, ent->d_name);
512
513
514
515
516
517
518
519
520
if (retval == NULL)
retval = l;
else
prev->next = l;
prev = l;
l->next = NULL;
} /* while */
521
522
523
if (buf != NULL)
free(buf);
524
525
526
527
528
closedir(dir);
return(retval);
} /* __PHYSFS_platformEnumerateFiles */
529
530
531
532
533
534
535
536
537
538
539
540
541
542
char *__PHYSFS_platformCurrentDir(void)
{
int allocSize = 0;
char *retval = NULL;
char *ptr;
do
{
allocSize += 100;
ptr = (char *) realloc(retval, allocSize);
if (ptr == NULL)
{
if (retval != NULL)
free(retval);
543
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
544
} /* if */
545
546
547
retval = ptr;
ptr = getcwd(retval, allocSize);
548
} while (ptr == NULL && errno == ERANGE);
549
550
551
552
553
554
555
556
557
558
559
560
if (ptr == NULL && errno)
{
/*
* getcwd() failed for some reason, for example current
* directory not existing.
*/
if (retval != NULL)
free(retval);
BAIL_MACRO(ERR_NO_SUCH_FILE, NULL);
} /* if */
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
return(retval);
} /* __PHYSFS_platformCurrentDir */
char *__PHYSFS_platformRealPath(const char *path)
{
char resolved_path[MAXPATHLEN];
char *retval = NULL;
errno = 0;
BAIL_IF_MACRO(!realpath(path, resolved_path), strerror(errno), NULL);
retval = malloc(strlen(resolved_path) + 1);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, resolved_path);
return(retval);
} /* __PHYSFS_platformRealPath */
578
579
580
int __PHYSFS_platformMkDir(const char *path)
{
581
int rc;
582
583
584
585
586
587
errno = 0;
rc = mkdir(path, S_IRWXU);
BAIL_IF_MACRO(rc == -1, strerror(errno), 0);
return(1);
} /* __PHYSFS_platformMkDir */
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
static void *doOpen(const char *filename, const char *mode)
{
FILE *retval;
errno = 0;
retval = fopen(filename, mode);
if (retval == NULL)
__PHYSFS_setError(strerror(errno));
return((void *) retval);
} /* doOpen */
void *__PHYSFS_platformOpenRead(const char *filename)
{
return(doOpen(filename, "rb"));
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
return(doOpen(filename, "wb"));
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
616
return(doOpen(filename, "ab"));
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
FILE *io = (FILE *) opaque;
int rc = fread(buffer, size, count, io);
if (rc < count)
{
int err = errno;
BAIL_IF_MACRO(ferror(io), strerror(err), rc);
BAIL_MACRO(ERR_PAST_EOF, rc);
} /* if */
return(rc);
} /* __PHYSFS_platformRead */
636
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
637
638
639
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
FILE *io = (FILE *) opaque;
640
int rc = fwrite((void *) buffer, size, count, io);
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
if (rc < count)
__PHYSFS_setError(strerror(errno));
return(rc);
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
FILE *io = (FILE *) opaque;
/* !!! FIXME: Use llseek where available. */
errno = 0;
BAIL_IF_MACRO(fseek(io, pos, SEEK_SET) != 0, strerror(errno), 0);
return(1);
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
FILE *io = (FILE *) opaque;
PHYSFS_sint64 retval = ftell(io);
BAIL_IF_MACRO(retval == -1, strerror(errno), -1);
return(retval);
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
FILE *io = (FILE *) opaque;
struct stat statbuf;
errno = 0;
BAIL_IF_MACRO(fstat(fileno(io), &statbuf) == -1, strerror(errno), -1);
return((PHYSFS_sint64) statbuf.st_size);
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformEOF(void *opaque)
{
return(feof((FILE *) opaque));
} /* __PHYSFS_platformEOF */
int __PHYSFS_platformFlush(void *opaque)
{
687
688
errno = 0;
BAIL_IF_MACRO(fflush((FILE *) opaque) == EOF, strerror(errno), 0);
689
690
691
692
693
694
return(1);
} /* __PHYSFS_platformFlush */
int __PHYSFS_platformClose(void *opaque)
{
695
696
errno = 0;
BAIL_IF_MACRO(fclose((FILE *) opaque) == EOF, strerror(errno), 0);
697
698
699
700
return(1);
} /* __PHYSFS_platformClose */
701
702
703
704
705
706
707
int __PHYSFS_platformDelete(const char *path)
{
errno = 0;
BAIL_IF_MACRO(remove(path) == -1, strerror(errno), 0);
return(1);
} /* __PHYSFS_platformDelete */
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
void *__PHYSFS_platformCreateMutex(void)
{
int rc;
pthread_mutex_t *m = (pthread_mutex_t *) malloc(sizeof (pthread_mutex_t));
BAIL_IF_MACRO(m == NULL, ERR_OUT_OF_MEMORY, NULL);
rc = pthread_mutex_init(m, NULL);
if (rc != 0)
{
free(m);
BAIL_MACRO(strerror(rc), NULL);
} /* if */
return((void *) m);
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
pthread_mutex_destroy((pthread_mutex_t *) mutex);
free(mutex);
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
return(pthread_mutex_lock((pthread_mutex_t *) mutex) == 0);
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
pthread_mutex_unlock((pthread_mutex_t *) mutex);
} /* __PHYSFS_platformReleaseMutex */
743
/* end of unix.c ... */