/
platform_unix.c
375 lines (302 loc) · 9.96 KB
1
2
3
/*
* Unix 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_UNIX
13
14
15
#include <ctype.h>
#include <unistd.h>
16
#include <stdlib.h>
17
18
19
#include <sys/types.h>
#include <pwd.h>
#include <sys/stat.h>
20
#include <sys/param.h>
21
22
23
#include <dirent.h>
#include <time.h>
#include <errno.h>
24
#include <limits.h>
25
26
27
28
29
30
31
32
33
#if PHYSFS_PLATFORM_LINUX && !defined(PHYSFS_HAVE_MNTENT_H)
#define PHYSFS_HAVE_MNTENT_H 1
#elif PHYSFS_PLATFORM_SOLARIS && !defined(PHYSFS_HAVE_SYS_MNTTAB_H)
#define PHYSFS_HAVE_SYS_MNTTAB_H 1
#elif PHYSFS_PLATFORM_BSD && !defined(PHYSFS_HAVE_SYS_UCRED_H)
#define PHYSFS_HAVE_SYS_UCRED_H 1
#endif
34
35
36
37
#ifdef PHYSFS_HAVE_SYS_UCRED_H
# ifdef PHYSFS_HAVE_MNTENT_H
# undef PHYSFS_HAVE_MNTENT_H /* don't do both... */
# endif
38
# include <sys/mount.h>
39
# include <sys/ucred.h>
40
#endif
41
42
43
44
#ifdef PHYSFS_HAVE_MNTENT_H
#include <mntent.h>
#endif
45
46
47
48
49
#ifdef PHYSFS_HAVE_SYS_MNTTAB_H
#include <sys/mnttab.h>
#endif
50
51
52
53
#if PHYSFS_PLATFORM_FREEBSD
#include <sys/sysctl.h>
#endif
54
55
#include "physfs_internal.h"
56
57
int __PHYSFS_platformInit(void)
{
58
return 1; /* always succeed. */
59
60
61
62
63
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
64
return 1; /* always succeed. */
65
66
67
} /* __PHYSFS_platformDeinit */
68
/* Stub version for platforms without CD-ROM support. */
69
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
70
{
71
72
#if (defined PHYSFS_NO_CDROM_SUPPORT)
/* no-op. */
73
74
#elif (defined PHYSFS_HAVE_SYS_UCRED_H)
75
int i;
76
77
struct statfs *mntbufp = NULL;
int mounts = getmntinfo(&mntbufp, MNT_WAIT);
78
79
80
for (i = 0; i < mounts; i++)
{
81
82
int add_it = 0;
83
if (strcmp(mntbufp[i].f_fstypename, "iso9660") == 0)
84
add_it = 1;
85
else if (strcmp( mntbufp[i].f_fstypename, "cd9660") == 0)
86
add_it = 1;
87
88
/* add other mount types here */
89
90
if (add_it)
91
cb(data, mntbufp[i].f_mntonname);
92
} /* for */
93
94
#elif (defined PHYSFS_HAVE_MNTENT_H)
95
96
97
98
FILE *mounts = NULL;
struct mntent *ent = NULL;
mounts = setmntent("/etc/mtab", "r");
99
BAIL_IF(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
100
101
102
103
104
105
while ( (ent = getmntent(mounts)) != NULL )
{
int add_it = 0;
if (strcmp(ent->mnt_type, "iso9660") == 0)
add_it = 1;
106
107
108
109
110
111
112
113
else if (strcmp(ent->mnt_type, "udf") == 0)
add_it = 1;
/* !!! FIXME: these might pick up floppy drives, right? */
else if (strcmp(ent->mnt_type, "auto") == 0)
add_it = 1;
else if (strcmp(ent->mnt_type, "supermount") == 0)
add_it = 1;
114
115
116
/* !!! FIXME: udf? automount? */
117
/* add other mount types here */
118
119
if (add_it)
120
cb(data, ent->mnt_dir);
121
122
123
} /* while */
endmntent(mounts);
124
125
126
127
128
#elif (defined PHYSFS_HAVE_SYS_MNTTAB_H)
FILE *mounts = fopen(MNTTAB, "r");
struct mnttab ent;
129
BAIL_IF(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
while (getmntent(mounts, &ent) == 0)
{
int add_it = 0;
if (strcmp(ent.mnt_fstype, "hsfs") == 0)
add_it = 1;
/* add other mount types here */
if (add_it)
cb(data, ent.mnt_mountp);
} /* while */
fclose(mounts);
#else
#error Unknown platform. Should have defined PHYSFS_NO_CDROM_SUPPORT, perhaps.
146
#endif
147
} /* __PHYSFS_platformDetectAvailableCDs */
148
149
150
151
152
153
154
155
/*
* 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.
*
156
* (envr) will be scribbled over, and you are expected to allocator.Free() the
157
158
159
* return value when you're done with it.
*/
static char *findBinaryInPath(const char *bin, char *envr)
160
{
161
162
163
size_t alloc_size = 0;
char *exe = NULL;
char *start = envr;
164
165
char *ptr;
166
167
assert(bin != NULL);
assert(envr != NULL);
168
169
170
do
{
171
size_t size;
172
173
size_t binlen;
174
ptr = strchr(start, ':'); /* find next $PATH separator. */
175
176
177
if (ptr)
*ptr = '\0';
178
179
binlen = strlen(bin);
size = strlen(start) + binlen + 2;
180
if (size >= alloc_size)
181
{
182
char *x = (char *) allocator.Realloc(exe, size);
183
if (!x)
184
185
{
if (exe != NULL)
186
allocator.Free(exe);
187
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
188
189
190
191
} /* if */
alloc_size = size;
exe = x;
192
} /* if */
193
194
/* build full binary path... */
195
strcpy(exe, start);
196
if ((exe[0] == '\0') || (exe[strlen(exe) - 1] != '/'))
197
strcat(exe, "/");
198
199
200
strcat(exe, bin);
if (access(exe, X_OK) == 0) /* Exists as executable? We're done. */
201
{
202
exe[(size - binlen) - 1] = '\0'; /* chop off filename, leave '/' */
203
return exe;
204
} /* if */
205
206
start = ptr + 1; /* start points to beginning of next element. */
207
208
} while (ptr != NULL);
209
if (exe != NULL)
210
allocator.Free(exe);
211
212
return NULL; /* doesn't exist in path. */
213
214
215
} /* findBinaryInPath */
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
static char *readSymLink(const char *path)
{
ssize_t len = 64;
ssize_t rc = -1;
char *retval = NULL;
while (1)
{
char *ptr = (char *) allocator.Realloc(retval, (size_t) len);
if (ptr == NULL)
break; /* out of memory. */
retval = ptr;
rc = readlink(path, retval, len);
if (rc == -1)
break; /* not a symlink, i/o error, etc. */
else if (rc < len)
{
retval[rc] = '\0'; /* readlink doesn't null-terminate. */
return retval; /* we're good to go. */
} /* else if */
len *= 2; /* grow buffer, try again. */
} /* while */
if (retval != NULL)
allocator.Free(retval);
return NULL;
} /* readSymLink */
248
249
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
250
char *retval = NULL;
251
const char *envr = NULL;
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
/* Try to avoid using argv0 unless forced to. Try system-specific stuff. */
#if PHYSFS_PLATFORM_FREEBSD
{
char fullpath[PATH_MAX];
size_t buflen = sizeof (fullpath);
int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
if (sysctl(mib, 4, fullpath, &buflen, NULL, 0) != -1)
retval = __PHYSFS_strdup(fullpath);
}
#elif PHYSFS_PLATFORM_SOLARIS
{
const char *path = getexecname();
if ((path != NULL) && (path[0] == '/')) /* must be absolute path... */
retval = __PHYSFS_strdup(path);
}
#endif
if (retval)
return retval; /* already got it. */
/* If there's a Linux-like /proc filesystem, you can get the full path to
* the current process from a symlink in there.
276
*/
277
278
if (access("/proc", F_OK) == 0)
279
{
280
281
282
283
284
285
286
287
288
289
290
291
retval = readSymLink("/proc/self/exe");
if (!retval) retval = readSymLink("/proc/curproc/file");
if (!retval) retval = readSymLink("/proc/curproc/exe");
if (retval == NULL)
{
/* older kernels don't have /proc/self ... try PID version... */
const unsigned long long pid = (unsigned long long) getpid();
char path[64];
const int rc = (int) snprintf(path,sizeof(path),"/proc/%llu/exe",pid);
if ( (rc > 0) && (rc < sizeof(path)) )
retval = readSymLink(path);
} /* if */
292
293
} /* if */
294
if (retval != NULL) /* chop off filename. */
295
{
296
297
char *ptr = strrchr(retval, '/');
if (ptr != NULL)
298
*(ptr+1) = '\0';
299
300
301
302
303
else /* shouldn't happen, but just in case... */
{
allocator.Free(retval);
retval = NULL;
} /* else */
304
} /* if */
305
306
/* No /proc/self/exe, etc, but we have an argv[0] we can parse? */
307
308
if ((retval == NULL) && (argv0 != NULL))
{
309
310
311
312
/* fast path: default behaviour can handle this. */
if (strchr(argv0, '/') != NULL)
return NULL; /* higher level parses out real path from argv0. */
313
/* If there's no dirsep on argv0, then look through $PATH for it. */
314
315
316
317
envr = getenv("PATH");
if (envr != NULL)
{
char *path = (char *) __PHYSFS_smallAlloc(strlen(envr) + 1);
318
BAIL_IF(!path, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
319
320
321
322
strcpy(path, envr);
retval = findBinaryInPath(argv0, path);
__PHYSFS_smallFree(path);
} /* if */
323
} /* if */
324
325
326
327
328
329
330
331
332
if (retval != NULL)
{
/* try to shrink buffer... */
char *ptr = (char *) allocator.Realloc(retval, strlen(retval) + 1);
if (ptr != NULL)
retval = ptr; /* oh well if it failed. */
} /* if */
333
return retval;
334
335
336
} /* __PHYSFS_platformCalcBaseDir */
337
338
339
340
341
342
343
char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
{
/*
* We use XDG's base directory spec, even if you're not on Linux.
* This isn't strictly correct, but the results are relatively sane
* in any case.
*
344
* https://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
345
346
347
348
349
350
351
352
353
354
*/
const char *envr = getenv("XDG_DATA_HOME");
const char *append = "/";
char *retval = NULL;
size_t len = 0;
if (!envr)
{
/* You end up with "$HOME/.local/share/Game Name 2" */
envr = __PHYSFS_getUserDir();
355
BAIL_IF_ERRPASS(!envr, NULL); /* oh well. */
356
357
358
append = ".local/share/";
} /* if */
359
len = strlen(envr) + strlen(append) + strlen(app) + 2;
360
retval = (char *) allocator.Malloc(len);
361
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
362
snprintf(retval, len, "%s%s%s/", envr, append, app);
363
364
365
366
return retval;
} /* __PHYSFS_platformCalcPrefDir */
367
368
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
{
369
return 0; /* just use malloc() and friends. */
370
371
} /* __PHYSFS_platformSetDefaultAllocator */
372
#endif /* PHYSFS_PLATFORM_UNIX */
373
374
/* end of unix.c ... */