/
platform_posix.c
441 lines (348 loc) · 11.2 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
159
const int rc = mkdir(path, S_IRWXU);
BAIL_IF_MACRO(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_MACRO(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_MACRO(errcodeFromErrnoError(err), NULL);
184
185
186
} /* if */
} /* if */
187
retval = (int *) allocator.Malloc(sizeof (int));
188
if (!retval)
189
190
{
close(fd);
191
BAIL_MACRO(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
224
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
225
226
rc = read(fd, buffer, (size_t) len);
227
BAIL_IF_MACRO(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
241
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
242
243
rc = write(fd, (void *) buffer, (size_t) len);
244
BAIL_IF_MACRO(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
255
const int rc = lseek(fd, (off_t) pos, SEEK_SET);
BAIL_IF_MACRO(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_MACRO(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_MACRO(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
BAIL_IF_MACRO(fsync(fd) == -1, errcodeFromErrno(), 0);
283
return 1;
284
285
286
} /* __PHYSFS_platformFlush */
287
void __PHYSFS_platformClose(void *opaque)
288
{
289
290
const int fd = *((int *) opaque);
(void) close(fd); /* we don't check this. You should have used flush! */
291
allocator.Free(opaque);
292
293
294
295
296
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
297
BAIL_IF_MACRO(remove(path) == -1, errcodeFromErrno(), 0);
298
return 1;
299
300
} /* __PHYSFS_platformDelete */
301
302
303
304
305
int __PHYSFS_platformStat(const char *filename, int *exists, PHYSFS_Stat *st)
{
struct stat statbuf;
306
if (lstat(filename, &statbuf) == -1)
307
{
308
*exists = (errno != ENOENT);
309
BAIL_MACRO(errcodeFromErrno(), 0);
310
311
} /* if */
312
313
*exists = 1;
314
315
316
317
318
319
320
321
322
323
324
325
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 */
326
327
328
329
330
331
else if(S_ISLNK(statbuf.st_mode))
{
st->filetype = PHYSFS_FILETYPE_SYMLINK;
st->filesize = 0;
} /* else if */
332
333
334
335
336
337
338
339
340
341
342
343
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);
344
return 1;
345
346
} /* __PHYSFS_platformStat */
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
372
373
374
375
376
#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));
377
BAIL_IF_MACRO(!m, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
378
379
380
381
rc = pthread_mutex_init(&m->mutex, NULL);
if (rc != 0)
{
allocator.Free(m);
382
BAIL_MACRO(PHYSFS_ERR_OS_ERROR, NULL);
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
418
419
420
421
422
} /* 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;
423
424
assert(m->owner == pthread_self()); /* catch programming errors. */
assert(m->count > 0); /* catch programming errors. */
425
426
427
428
429
430
431
432
433
434
435
436
437
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 */
438
#endif /* PHYSFS_PLATFORM_POSIX */
439
440
/* end of posix.c ... */