/
platform_posix.c
556 lines (431 loc) · 13.5 KB
1
2
3
/*
* Posix-esque support routines for PhysicsFS.
*
4
* Please see the file LICENSE.txt in the source's root directory.
5
6
7
8
*
* This file written by Ryan C. Gordon.
*/
9
10
11
12
#define __PHYSICSFS_INTERNAL__
#include "physfs_platforms.h"
#ifdef PHYSFS_PLATFORM_POSIX
13
14
#include <unistd.h>
15
#include <ctype.h>
16
17
#include <sys/types.h>
#include <sys/stat.h>
18
#include <pwd.h>
19
20
#include <dirent.h>
#include <errno.h>
21
#include <fcntl.h>
22
23
24
25
26
#if ((!defined PHYSFS_NO_THREAD_SUPPORT) && (!defined PHYSFS_PLATFORM_BEOS))
#include <pthread.h>
#endif
27
28
29
30
#ifdef PHYSFS_HAVE_LLSEEK
#include <linux/unistd.h>
#endif
31
32
33
#include "physfs_internal.h"
34
35
36
const char *__PHYSFS_platformDirSeparator = "/";
37
38
39
40
41
42
43
char *__PHYSFS_platformCopyEnvironmentVariable(const char *varname)
{
const char *envr = getenv(varname);
char *retval = NULL;
if (envr != NULL)
{
44
retval = (char *) allocator.Malloc(strlen(envr) + 1);
45
46
47
48
if (retval != NULL)
strcpy(retval, envr);
} /* if */
49
return retval;
50
51
52
53
54
55
56
57
58
59
60
61
} /* __PHYSFS_platformCopyEnvironmentVariable */
static char *getUserNameByUID(void)
{
uid_t uid = getuid();
struct passwd *pw;
char *retval = NULL;
pw = getpwuid(uid);
if ((pw != NULL) && (pw->pw_name != NULL))
{
62
retval = (char *) allocator.Malloc(strlen(pw->pw_name) + 1);
63
64
65
66
if (retval != NULL)
strcpy(retval, pw->pw_name);
} /* if */
67
return retval;
68
69
70
71
72
73
74
75
76
77
78
79
} /* 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))
{
80
retval = (char *) allocator.Malloc(strlen(pw->pw_dir) + 1);
81
82
83
84
if (retval != NULL)
strcpy(retval, pw->pw_dir);
} /* if */
85
return retval;
86
87
88
89
90
91
92
93
} /* getUserDirByUID */
char *__PHYSFS_platformGetUserName(void)
{
char *retval = getUserNameByUID();
if (retval == NULL)
retval = __PHYSFS_platformCopyEnvironmentVariable("USER");
94
return retval;
95
96
97
98
99
100
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
char *retval = __PHYSFS_platformCopyEnvironmentVariable("HOME");
101
102
103
104
105
106
107
108
109
110
111
112
/* if the environment variable was set, make sure it's really a dir. */
if (retval != NULL)
{
struct stat statbuf;
if ((stat(retval, &statbuf) == -1) || (S_ISDIR(statbuf.st_mode) == 0))
{
allocator.Free(retval);
retval = NULL;
} /* if */
} /* if */
113
114
if (retval == NULL)
retval = getUserDirByUID();
115
116
return retval;
117
118
119
120
121
122
123
124
125
126
} /* __PHYSFS_platformGetUserDir */
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;
127
char *retval = (char *) allocator.Malloc(len);
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
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);
143
return retval;
144
145
146
147
} /* __PHYSFS_platformCvtToDependent */
148
149
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
150
151
PHYSFS_EnumFilesCallback callback,
const char *origdir,
152
void *callbackdata)
153
154
155
156
157
158
159
{
DIR *dir;
struct dirent *ent;
int bufsize = 0;
char *buf = NULL;
int dlen = 0;
160
if (omitSymLinks) /* !!! FIXME: this malloc sucks. */
161
162
163
{
dlen = strlen(dirname);
bufsize = dlen + 256;
164
buf = (char *) allocator.Malloc(bufsize);
165
166
if (buf == NULL)
return;
167
168
169
170
171
172
173
174
175
176
177
178
strcpy(buf, dirname);
if (buf[dlen - 1] != '/')
{
buf[dlen++] = '/';
buf[dlen] = '\0';
} /* if */
} /* if */
errno = 0;
dir = opendir(dirname);
if (dir == NULL)
{
179
allocator.Free(buf);
180
return;
181
182
} /* if */
183
while ((ent = readdir(dir)) != NULL)
184
185
186
187
188
189
190
191
192
{
if (strcmp(ent->d_name, ".") == 0)
continue;
if (strcmp(ent->d_name, "..") == 0)
continue;
if (omitSymLinks)
{
193
194
PHYSFS_Stat statbuf;
int exists = 0;
195
196
197
198
char *p;
int len = strlen(ent->d_name) + dlen + 1;
if (len > bufsize)
{
199
p = (char *) allocator.Realloc(buf, len);
200
201
202
203
204
205
206
if (p == NULL)
continue;
buf = p;
bufsize = len;
} /* if */
strcpy(buf + dlen, ent->d_name);
207
208
209
210
211
212
213
if (!__PHYSFS_platformStat(buf, &exists, &statbuf))
continue;
else if (!exists)
continue; /* probably can't happen, but just in case. */
else if (statbuf.filetype == PHYSFS_FILETYPE_SYMLINK)
continue;
214
215
} /* if */
216
callback(callbackdata, origdir, ent->d_name);
217
218
} /* while */
219
allocator.Free(buf);
220
221
222
223
closedir(dir);
} /* __PHYSFS_platformEnumerateFiles */
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
char *__PHYSFS_platformCurrentDir(void)
{
int allocSize = 64;
char *retval = NULL;
char *ptr;
do
{
allocSize *= 2;
ptr = (char *) allocator.Realloc(retval, allocSize);
if (ptr == NULL)
{
if (retval != NULL)
allocator.Free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
retval = ptr;
ptr = getcwd(retval, allocSize);
} while (ptr == NULL && errno == ERANGE);
if (ptr == NULL && errno)
{
/* getcwd() failed , for example current directory not existing... */
if (retval != NULL)
allocator.Free(retval);
BAIL_MACRO(ERR_NO_SUCH_FILE, NULL);
} /* if */
/* try to shrink buffer... */
ptr = (char *) allocator.Realloc(retval, strlen(retval) + 1);
if (ptr != NULL)
retval = ptr; /* oh well if it failed. */
return retval;
} /* __PHYSFS_platformCurrentDir */
262
263
264
265
266
267
int __PHYSFS_platformMkDir(const char *path)
{
int rc;
errno = 0;
rc = mkdir(path, S_IRWXU);
BAIL_IF_MACRO(rc == -1, strerror(errno), 0);
268
return 1;
269
270
271
} /* __PHYSFS_platformMkDir */
272
static void *doOpen(const char *filename, int mode)
273
{
274
const int appending = (mode & O_APPEND);
275
276
int fd;
int *retval;
277
278
errno = 0;
279
280
281
/* O_APPEND doesn't actually behave as we'd like. */
mode &= ~O_APPEND;
282
fd = open(filename, mode, S_IRUSR | S_IWUSR);
283
BAIL_IF_MACRO(fd < 0, strerror(errno), NULL);
284
285
286
287
288
289
290
291
292
293
if (appending)
{
if (lseek(fd, 0, SEEK_END) < 0)
{
close(fd);
BAIL_MACRO(strerror(errno), NULL);
} /* if */
} /* if */
294
retval = (int *) allocator.Malloc(sizeof (int));
295
296
297
298
299
300
301
if (retval == NULL)
{
close(fd);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
*retval = fd;
302
return ((void *) retval);
303
304
305
306
307
} /* doOpen */
void *__PHYSFS_platformOpenRead(const char *filename)
{
308
return doOpen(filename, O_RDONLY);
309
310
311
312
313
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
314
return doOpen(filename, O_WRONLY | O_CREAT | O_TRUNC);
315
316
317
318
319
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
320
return doOpen(filename, O_WRONLY | O_CREAT | O_APPEND);
321
322
323
324
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
325
PHYSFS_uint64 len)
326
{
327
const int fd = *((int *) opaque);
328
ssize_t rc = 0;
329
330
BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),ERR_INVALID_ARGUMENT,-1);
331
332
333
334
335
336
rc = read(fd, buffer, (size_t) len);
BAIL_IF_MACRO(rc == -1, strerror(errno), (PHYSFS_sint64) rc);
assert(rc >= 0);
assert(rc <= len);
return (PHYSFS_sint64) rc;
337
338
339
340
} /* __PHYSFS_platformRead */
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
341
PHYSFS_uint64 len)
342
{
343
const int fd = *((int *) opaque);
344
ssize_t rc = 0;
345
346
BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),ERR_INVALID_ARGUMENT,-1);
347
348
349
350
351
352
rc = write(fd, (void *) buffer, (size_t) len);
BAIL_IF_MACRO(rc == -1, strerror(errno), rc);
assert(rc >= 0);
assert(rc <= len);
return (PHYSFS_sint64) rc;
353
354
355
356
357
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
358
const int fd = *((int *) opaque);
359
360
361
362
363
364
365
366
367
368
#ifdef PHYSFS_HAVE_LLSEEK
unsigned long offset_high = ((pos >> 32) & 0xFFFFFFFF);
unsigned long offset_low = (pos & 0xFFFFFFFF);
loff_t retoffset;
int rc = llseek(fd, offset_high, offset_low, &retoffset, SEEK_SET);
BAIL_IF_MACRO(rc == -1, strerror(errno), 0);
#else
BAIL_IF_MACRO(lseek(fd, (int) pos, SEEK_SET) == -1, strerror(errno), 0);
#endif
369
370
return 1;
371
372
373
374
375
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
376
const int fd = *((int *) opaque);
377
378
379
380
381
382
383
384
385
386
387
388
PHYSFS_sint64 retval;
#ifdef PHYSFS_HAVE_LLSEEK
loff_t retoffset;
int rc = llseek(fd, 0, &retoffset, SEEK_CUR);
BAIL_IF_MACRO(rc == -1, strerror(errno), -1);
retval = (PHYSFS_sint64) retoffset;
#else
retval = (PHYSFS_sint64) lseek(fd, 0, SEEK_CUR);
BAIL_IF_MACRO(retval == -1, strerror(errno), -1);
#endif
389
return retval;
390
391
392
393
394
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
395
const int fd = *((int *) opaque);
396
struct stat statbuf;
397
BAIL_IF_MACRO(fstat(fd, &statbuf) == -1, strerror(errno), -1);
398
return ((PHYSFS_sint64) statbuf.st_size);
399
400
401
402
403
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformFlush(void *opaque)
{
404
const int fd = *((int *) opaque);
405
BAIL_IF_MACRO(fsync(fd) == -1, strerror(errno), 0);
406
return 1;
407
408
409
} /* __PHYSFS_platformFlush */
410
void __PHYSFS_platformClose(void *opaque)
411
{
412
413
const int fd = *((int *) opaque);
(void) close(fd); /* we don't check this. You should have used flush! */
414
allocator.Free(opaque);
415
416
417
418
419
420
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
BAIL_IF_MACRO(remove(path) == -1, strerror(errno), 0);
421
return 1;
422
423
} /* __PHYSFS_platformDelete */
424
425
426
427
428
int __PHYSFS_platformStat(const char *filename, int *exists, PHYSFS_Stat *st)
{
struct stat statbuf;
429
if (lstat(filename, &statbuf) == -1)
430
{
431
*exists = (errno == ENOENT);
432
BAIL_MACRO(strerror(errno), 0);
433
434
} /* if */
435
436
*exists = 1;
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
if (S_ISREG(statbuf.st_mode))
{
st->filetype = PHYSFS_FILETYPE_REGULAR;
st->filesize = statbuf.st_size;
} /* if */
else if(S_ISDIR(statbuf.st_mode))
{
st->filetype = PHYSFS_FILETYPE_DIRECTORY;
st->filesize = 0;
} /* else if */
else
{
st->filetype = PHYSFS_FILETYPE_OTHER;
st->filesize = statbuf.st_size;
} /* else */
st->modtime = statbuf.st_mtime;
st->createtime = statbuf.st_ctime;
st->accesstime = statbuf.st_atime;
/* !!! FIXME: maybe we should just report full permissions? */
st->readonly = access(filename, W_OK);
461
return 1;
462
463
} /* __PHYSFS_platformStat */
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
#ifndef PHYSFS_PLATFORM_BEOS /* BeOS has its own code in platform_beos.cpp */
#if (defined PHYSFS_NO_THREAD_SUPPORT)
void *__PHYSFS_platformGetThreadID(void) { return ((void *) 0x0001); }
void *__PHYSFS_platformCreateMutex(void) { return ((void *) 0x0001); }
void __PHYSFS_platformDestroyMutex(void *mutex) {}
int __PHYSFS_platformGrabMutex(void *mutex) { return 1; }
void __PHYSFS_platformReleaseMutex(void *mutex) {}
#else
typedef struct
{
pthread_mutex_t mutex;
pthread_t owner;
PHYSFS_uint32 count;
} PthreadMutex;
void *__PHYSFS_platformGetThreadID(void)
{
return ( (void *) ((size_t) pthread_self()) );
} /* __PHYSFS_platformGetThreadID */
void *__PHYSFS_platformCreateMutex(void)
{
int rc;
PthreadMutex *m = (PthreadMutex *) allocator.Malloc(sizeof (PthreadMutex));
BAIL_IF_MACRO(m == NULL, ERR_OUT_OF_MEMORY, NULL);
rc = pthread_mutex_init(&m->mutex, NULL);
if (rc != 0)
{
allocator.Free(m);
BAIL_MACRO(strerror(rc), NULL);
} /* if */
m->count = 0;
m->owner = (pthread_t) 0xDEADBEEF;
return ((void *) m);
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
PthreadMutex *m = (PthreadMutex *) mutex;
/* Destroying a locked mutex is a bug, but we'll try to be helpful. */
if ((m->owner == pthread_self()) && (m->count > 0))
pthread_mutex_unlock(&m->mutex);
pthread_mutex_destroy(&m->mutex);
allocator.Free(m);
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
PthreadMutex *m = (PthreadMutex *) mutex;
pthread_t tid = pthread_self();
if (m->owner != tid)
{
if (pthread_mutex_lock(&m->mutex) != 0)
return 0;
m->owner = tid;
} /* if */
m->count++;
return 1;
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
PthreadMutex *m = (PthreadMutex *) mutex;
if (m->owner == pthread_self())
{
if (--m->count == 0)
{
m->owner = (pthread_t) 0xDEADBEEF;
pthread_mutex_unlock(&m->mutex);
} /* if */
} /* if */
} /* __PHYSFS_platformReleaseMutex */
#endif /* !PHYSFS_NO_THREAD_SUPPORT */
#endif /* !PHYSFS_PLATFORM_BEOS */
553
#endif /* PHYSFS_PLATFORM_POSIX */
554
555
/* end of posix.c ... */