/
physfs_platform_unix.c
369 lines (300 loc) · 9.84 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
#if PHYSFS_NO_CDROM_SUPPORT
27
#elif PHYSFS_PLATFORM_LINUX
28
# define PHYSFS_HAVE_MNTENT_H 1
29
30
31
#elif defined __CYGWIN__
# define PHYSFS_HAVE_MNTENT_H 1
#elif PHYSFS_PLATFORM_SOLARIS
32
# define PHYSFS_HAVE_SYS_MNTTAB_H 1
33
#elif PHYSFS_PLATFORM_BSD
34
35
36
37
# define PHYSFS_HAVE_SYS_UCRED_H 1
#else
# warning No CD-ROM support included. Either define your platform here,
# warning or define PHYSFS_NO_CDROM_SUPPORT=1 to confirm this is intentional.
38
39
#endif
40
41
42
43
#ifdef PHYSFS_HAVE_SYS_UCRED_H
# ifdef PHYSFS_HAVE_MNTENT_H
# undef PHYSFS_HAVE_MNTENT_H /* don't do both... */
# endif
44
# include <sys/mount.h>
45
# include <sys/ucred.h>
46
#endif
47
48
49
50
#ifdef PHYSFS_HAVE_MNTENT_H
#include <mntent.h>
#endif
51
52
53
54
55
#ifdef PHYSFS_HAVE_SYS_MNTTAB_H
#include <sys/mnttab.h>
#endif
56
#ifdef PHYSFS_PLATFORM_FREEBSD
57
58
59
#include <sys/sysctl.h>
#endif
60
61
#include "physfs_internal.h"
62
63
int __PHYSFS_platformInit(void)
{
64
return 1; /* always succeed. */
65
66
67
68
69
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
70
return 1; /* always succeed. */
71
72
73
} /* __PHYSFS_platformDeinit */
74
/* Stub version for platforms without CD-ROM support. */
75
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
76
{
77
78
#if (defined PHYSFS_NO_CDROM_SUPPORT)
/* no-op. */
79
80
#elif (defined PHYSFS_HAVE_SYS_UCRED_H)
81
int i;
82
struct statfs *mntbufp = NULL;
83
int mounts = getmntinfo(&mntbufp, MNT_NOWAIT);
84
85
86
for (i = 0; i < mounts; i++)
{
87
88
int add_it = 0;
89
if (strcmp(mntbufp[i].f_fstypename, "iso9660") == 0)
90
add_it = 1;
91
else if (strcmp( mntbufp[i].f_fstypename, "cd9660") == 0)
92
add_it = 1;
93
94
/* add other mount types here */
95
96
if (add_it)
97
cb(data, mntbufp[i].f_mntonname);
98
} /* for */
99
100
#elif (defined PHYSFS_HAVE_MNTENT_H)
101
102
103
104
FILE *mounts = NULL;
struct mntent *ent = NULL;
mounts = setmntent("/etc/mtab", "r");
105
BAIL_IF(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
106
107
108
109
110
111
while ( (ent = getmntent(mounts)) != NULL )
{
int add_it = 0;
if (strcmp(ent->mnt_type, "iso9660") == 0)
add_it = 1;
112
113
114
115
116
117
118
119
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;
120
121
122
/* !!! FIXME: udf? automount? */
123
/* add other mount types here */
124
125
if (add_it)
126
cb(data, ent->mnt_dir);
127
128
129
} /* while */
endmntent(mounts);
130
131
132
133
134
#elif (defined PHYSFS_HAVE_SYS_MNTTAB_H)
FILE *mounts = fopen(MNTTAB, "r");
struct mnttab ent;
135
BAIL_IF(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
136
137
138
139
140
141
142
143
144
145
146
147
148
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);
149
#endif
150
} /* __PHYSFS_platformDetectAvailableCDs */
151
152
153
154
155
156
157
158
/*
* 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.
*
159
* (envr) will be scribbled over, and you are expected to allocator.Free() the
160
161
162
* return value when you're done with it.
*/
static char *findBinaryInPath(const char *bin, char *envr)
163
{
164
165
166
size_t alloc_size = 0;
char *exe = NULL;
char *start = envr;
167
168
char *ptr;
169
170
assert(bin != NULL);
assert(envr != NULL);
171
172
173
do
{
174
size_t size;
175
176
size_t binlen;
177
ptr = strchr(start, ':'); /* find next $PATH separator. */
178
179
180
if (ptr)
*ptr = '\0';
181
182
binlen = strlen(bin);
size = strlen(start) + binlen + 2;
183
if (size >= alloc_size)
184
{
185
char *x = (char *) allocator.Realloc(exe, size);
186
if (!x)
187
188
{
if (exe != NULL)
189
allocator.Free(exe);
190
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
191
192
193
194
} /* if */
alloc_size = size;
exe = x;
195
} /* if */
196
197
/* build full binary path... */
198
strcpy(exe, start);
199
if ((exe[0] == '\0') || (exe[strlen(exe) - 1] != '/'))
200
strcat(exe, "/");
201
202
203
strcat(exe, bin);
if (access(exe, X_OK) == 0) /* Exists as executable? We're done. */
204
{
205
exe[(size - binlen) - 1] = '\0'; /* chop off filename, leave '/' */
206
return exe;
207
} /* if */
208
209
start = ptr + 1; /* start points to beginning of next element. */
210
211
} while (ptr != NULL);
212
if (exe != NULL)
213
allocator.Free(exe);
214
215
return NULL; /* doesn't exist in path. */
216
217
218
} /* findBinaryInPath */
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
248
249
250
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 */
251
252
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
253
char *retval = NULL;
254
const char *envr = NULL;
255
256
/* Try to avoid using argv0 unless forced to. Try system-specific stuff. */
257
258
#if defined(PHYSFS_PLATFORM_FREEBSD)
259
260
261
262
263
264
265
{
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);
}
266
#elif defined(PHYSFS_PLATFORM_SOLARIS)
267
268
269
270
271
272
273
274
275
{
const char *path = getexecname();
if ((path != NULL) && (path[0] == '/')) /* must be absolute path... */
retval = __PHYSFS_strdup(path);
}
#endif
/* 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 (!retval && (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
return retval;
} /* __PHYSFS_platformCalcPrefDir */
366
#endif /* PHYSFS_PLATFORM_UNIX */
367
368
/* end of physfs_platform_unix.c ... */