/
platform_posix.c
436 lines (344 loc) · 11 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
/* !!! FIXME: check for EINTR? */
11
12
13
14
#define __PHYSICSFS_INTERNAL__
#include "physfs_platforms.h"
#ifdef PHYSFS_PLATFORM_POSIX
15
16
#include <unistd.h>
17
#include <ctype.h>
18
19
#include <sys/types.h>
#include <sys/stat.h>
20
#include <pwd.h>
21
22
#include <dirent.h>
#include <errno.h>
23
#include <fcntl.h>
24
25
26
27
28
#if ((!defined PHYSFS_NO_THREAD_SUPPORT) && (!defined PHYSFS_PLATFORM_BEOS))
#include <pthread.h>
#endif
29
30
#include "physfs_internal.h"
31
32
33
34
35
36
37
38
39
40
41
42
43
static PHYSFS_ErrorCode errcodeFromErrnoError(const int err)
{
switch (err)
{
case 0: return PHYSFS_ERR_OK;
case EACCES: return PHYSFS_ERR_PERMISSION;
case EPERM: return PHYSFS_ERR_PERMISSION;
case EDQUOT: return PHYSFS_ERR_NO_SPACE;
case EIO: return PHYSFS_ERR_IO;
case ELOOP: return PHYSFS_ERR_SYMLINK_LOOP;
case EMLINK: return PHYSFS_ERR_NO_SPACE;
case ENAMETOOLONG: return PHYSFS_ERR_BAD_FILENAME;
44
case ENOENT: return PHYSFS_ERR_NOT_FOUND;
45
case ENOSPC: return PHYSFS_ERR_NO_SPACE;
46
case ENOTDIR: return PHYSFS_ERR_NOT_FOUND;
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
case EISDIR: return PHYSFS_ERR_NOT_A_FILE;
case EROFS: return PHYSFS_ERR_READ_ONLY;
case ETXTBSY: return PHYSFS_ERR_BUSY;
case EBUSY: return PHYSFS_ERR_BUSY;
case ENOMEM: return PHYSFS_ERR_OUT_OF_MEMORY;
case ENOTEMPTY: return PHYSFS_ERR_DIR_NOT_EMPTY;
default: return PHYSFS_ERR_OS_ERROR;
} /* switch */
} /* errcodeFromErrnoError */
static inline PHYSFS_ErrorCode errcodeFromErrno(void)
{
return errcodeFromErrnoError(errno);
} /* errcodeFromErrno */
64
65
66
67
68
69
70
static char *getUserDirByUID(void)
{
uid_t uid = getuid();
struct passwd *pw;
char *retval = NULL;
pw = getpwuid(uid);
71
if ((pw != NULL) && (pw->pw_dir != NULL) && (*pw->pw_dir != '\0'))
72
{
73
74
75
const size_t dlen = strlen(pw->pw_dir);
const size_t add_dirsep = (pw->pw_dir[dlen-1] != '/') ? 1 : 0;
retval = (char *) allocator.Malloc(dlen + 1 + add_dirsep);
76
if (retval != NULL)
77
{
78
strcpy(retval, pw->pw_dir);
79
80
81
82
83
84
if (add_dirsep)
{
retval[dlen] = '/';
retval[dlen+1] = '\0';
} /* if */
} /* if */
85
86
} /* if */
87
return retval;
88
89
90
} /* getUserDirByUID */
91
char *__PHYSFS_platformCalcUserDir(void)
92
{
93
94
char *retval = NULL;
char *envr = getenv("HOME");
95
96
/* if the environment variable was set, make sure it's really a dir. */
97
if (envr != NULL)
98
99
{
struct stat statbuf;
100
if ((stat(envr, &statbuf) != -1) && (S_ISDIR(statbuf.st_mode)))
101
{
102
103
104
105
106
107
108
109
110
111
112
113
const size_t envrlen = strlen(envr);
const size_t add_dirsep = (envr[envrlen-1] != '/') ? 1 : 0;
retval = allocator.Malloc(envrlen + 1 + add_dirsep);
if (retval)
{
strcpy(retval, envr);
if (add_dirsep)
{
retval[envrlen] = '/';
retval[envrlen+1] = '\0';
} /* if */
} /* if */
114
115
116
} /* if */
} /* if */
117
118
if (retval == NULL)
retval = getUserDirByUID();
119
120
return retval;
121
} /* __PHYSFS_platformCalcUserDir */
122
123
124
void __PHYSFS_platformEnumerateFiles(const char *dirname,
125
126
PHYSFS_EnumFilesCallback callback,
const char *origdir,
127
void *callbackdata)
128
129
130
131
132
133
134
135
136
{
DIR *dir;
struct dirent *ent;
char *buf = NULL;
errno = 0;
dir = opendir(dirname);
if (dir == NULL)
{
137
allocator.Free(buf);
138
return;
139
140
} /* if */
141
while ((ent = readdir(dir)) != NULL)
142
143
144
{
if (strcmp(ent->d_name, ".") == 0)
continue;
145
else if (strcmp(ent->d_name, "..") == 0)
146
147
continue;
148
callback(callbackdata, origdir, ent->d_name);
149
150
} /* while */
151
allocator.Free(buf);
152
153
154
155
156
157
closedir(dir);
} /* __PHYSFS_platformEnumerateFiles */
int __PHYSFS_platformMkDir(const char *path)
{
158
const int rc = mkdir(path, S_IRWXU);
159
BAIL_IF(rc == -1, errcodeFromErrno(), 0);
160
return 1;
161
162
163
} /* __PHYSFS_platformMkDir */
164
static void *doOpen(const char *filename, int mode)
165
{
166
const int appending = (mode & O_APPEND);
167
168
int fd;
int *retval;
169
170
errno = 0;
171
172
173
/* O_APPEND doesn't actually behave as we'd like. */
mode &= ~O_APPEND;
174
fd = open(filename, mode, S_IRUSR | S_IWUSR);
175
BAIL_IF(fd < 0, errcodeFromErrno(), NULL);
176
177
178
179
180
if (appending)
{
if (lseek(fd, 0, SEEK_END) < 0)
{
181
const int err = errno;
182
close(fd);
183
BAIL(errcodeFromErrnoError(err), NULL);
184
185
186
} /* if */
} /* if */
187
retval = (int *) allocator.Malloc(sizeof (int));
188
if (!retval)
189
190
{
close(fd);
191
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
192
193
194
} /* if */
*retval = fd;
195
return ((void *) retval);
196
197
198
199
200
} /* doOpen */
void *__PHYSFS_platformOpenRead(const char *filename)
{
201
return doOpen(filename, O_RDONLY);
202
203
204
205
206
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
207
return doOpen(filename, O_WRONLY | O_CREAT | O_TRUNC);
208
209
210
211
212
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
213
return doOpen(filename, O_WRONLY | O_CREAT | O_APPEND);
214
215
216
217
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
218
PHYSFS_uint64 len)
219
{
220
const int fd = *((int *) opaque);
221
ssize_t rc = 0;
222
223
if (!__PHYSFS_ui64FitsAddressSpace(len))
224
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
225
226
rc = read(fd, buffer, (size_t) len);
227
BAIL_IF(rc == -1, errcodeFromErrno(), -1);
228
229
230
assert(rc >= 0);
assert(rc <= len);
return (PHYSFS_sint64) rc;
231
232
233
234
} /* __PHYSFS_platformRead */
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
235
PHYSFS_uint64 len)
236
{
237
const int fd = *((int *) opaque);
238
ssize_t rc = 0;
239
240
if (!__PHYSFS_ui64FitsAddressSpace(len))
241
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
242
243
rc = write(fd, (void *) buffer, (size_t) len);
244
BAIL_IF(rc == -1, errcodeFromErrno(), rc);
245
246
247
assert(rc >= 0);
assert(rc <= len);
return (PHYSFS_sint64) rc;
248
249
250
251
252
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
253
const int fd = *((int *) opaque);
254
const int rc = lseek(fd, (off_t) pos, SEEK_SET);
255
BAIL_IF(rc == -1, errcodeFromErrno(), 0);
256
return 1;
257
258
259
260
261
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
262
const int fd = *((int *) opaque);
263
PHYSFS_sint64 retval;
264
retval = (PHYSFS_sint64) lseek(fd, 0, SEEK_CUR);
265
BAIL_IF(retval == -1, errcodeFromErrno(), -1);
266
return retval;
267
268
269
270
271
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
272
const int fd = *((int *) opaque);
273
struct stat statbuf;
274
BAIL_IF(fstat(fd, &statbuf) == -1, errcodeFromErrno(), -1);
275
return ((PHYSFS_sint64) statbuf.st_size);
276
277
278
279
280
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformFlush(void *opaque)
{
281
const int fd = *((int *) opaque);
282
if ((fcntl(fd, F_GETFL) & O_ACCMODE) != O_RDONLY)
283
BAIL_IF(fsync(fd) == -1, errcodeFromErrno(), 0);
284
return 1;
285
286
287
} /* __PHYSFS_platformFlush */
288
void __PHYSFS_platformClose(void *opaque)
289
{
290
291
const int fd = *((int *) opaque);
(void) close(fd); /* we don't check this. You should have used flush! */
292
allocator.Free(opaque);
293
294
295
296
297
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
298
BAIL_IF(remove(path) == -1, errcodeFromErrno(), 0);
299
return 1;
300
301
} /* __PHYSFS_platformDelete */
302
303
int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
304
305
306
{
struct stat statbuf;
307
BAIL_IF(lstat(filename, &statbuf) == -1, errcodeFromErrno(), 0);
308
309
310
311
312
313
314
315
316
317
318
319
320
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 */
321
322
323
324
325
326
else if(S_ISLNK(statbuf.st_mode))
{
st->filetype = PHYSFS_FILETYPE_SYMLINK;
st->filesize = 0;
} /* else if */
327
328
329
330
331
332
333
334
335
336
337
338
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);
339
return 1;
340
341
} /* __PHYSFS_platformStat */
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
#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));
372
BAIL_IF(!m, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
373
374
375
376
rc = pthread_mutex_init(&m->mutex, NULL);
if (rc != 0)
{
allocator.Free(m);
377
BAIL(PHYSFS_ERR_OS_ERROR, NULL);
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
} /* 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;
418
419
assert(m->owner == pthread_self()); /* catch programming errors. */
assert(m->count > 0); /* catch programming errors. */
420
421
422
423
424
425
426
427
428
429
430
431
432
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 */
433
#endif /* PHYSFS_PLATFORM_POSIX */
434
435
/* end of posix.c ... */