physfs/platform/unix.c

311 lines
7.5 KiB
C
Raw Normal View History

2001-07-07 10:24:47 +02:00
/*
* Unix support routines for PhysicsFS.
*
* Please see the file LICENSE in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
2002-05-10 11:25:25 +02:00
#if HAVE_CONFIG_H
# include <config.h>
#endif
#if (!defined __BEOS__) /* BeOS uses beos.cpp and posix.c ... */
2002-03-05 20:16:38 +01:00
#if ((defined __APPLE__) && (defined __MACH__))
# if (!defined __DARWIN__)
# define __DARWIN__
# endif
#endif
2001-07-07 10:24:47 +02:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
2001-07-07 10:24:47 +02:00
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <dirent.h>
#include <time.h>
#include <errno.h>
2002-03-05 20:16:38 +01:00
2002-04-06 23:05:14 +02:00
#if (!defined __DARWIN__)
#include <mntent.h>
#else
2002-03-05 20:16:38 +01:00
#include <sys/ucred.h>
#endif
2001-07-07 10:24:47 +02:00
2002-04-06 23:05:14 +02:00
#include <sys/mount.h>
2001-07-07 10:24:47 +02:00
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
const char *__PHYSFS_platformDirSeparator = "/";
2002-03-05 20:16:38 +01:00
int __PHYSFS_platformInit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
2002-03-05 20:16:38 +01:00
#if (defined __DARWIN__)
char **__PHYSFS_platformDetectAvailableCDs(void)
{
char **retval = (char **) malloc(sizeof (char *));
int cd_count = 1; /* We count the NULL entry. */
struct statfs* mntbufp = NULL;
int mounts;
int ii;
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
2002-03-05 20:16:38 +01:00
mounts = getmntinfo( &mntbufp, MNT_WAIT );
for ( ii=0; ii < mounts; ++ii ) {
int add_it = 0;
if ( strcmp( mntbufp[ii].f_fstypename, "iso9660") == 0 )
add_it = 1;
2002-04-07 01:49:17 +02:00
else if ( strcmp( mntbufp[ii].f_fstypename, "cd9660") == 0 )
add_it = 1;
2002-05-21 13:29:00 +02:00
/* add other mount types here */
2002-03-05 20:16:38 +01:00
if (add_it)
{
char **tmp = realloc(retval, sizeof (char *) * cd_count + 1);
if (tmp)
{
retval = tmp;
retval[cd_count-1] = (char *)
malloc(strlen(mntbufp[ ii ].f_mntonname) + 1);
if (retval[cd_count-1])
{
strcpy(retval[cd_count-1], mntbufp[ ii ].f_mntonname);
cd_count++;
} /* if */
} /* if */
} /* if */
}
free( mntbufp );
retval[cd_count - 1] = NULL;
return(retval);
} /* __PHYSFS_platformDetectAvailableCDs */
#else /* non-Darwin implementation... */
2001-07-07 10:24:47 +02:00
char **__PHYSFS_platformDetectAvailableCDs(void)
{
2001-08-07 05:33:44 +02:00
char **retval = (char **) malloc(sizeof (char *));
int cd_count = 1; /* We count the NULL entry. */
FILE *mounts = NULL;
struct mntent *ent = NULL;
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
2001-08-07 05:33:44 +02:00
*retval = NULL;
mounts = setmntent("/etc/mtab", "r");
BAIL_IF_MACRO(mounts == NULL, ERR_IO_ERROR, retval);
while ( (ent = getmntent(mounts)) != NULL )
{
int add_it = 0;
if (strcmp(ent->mnt_type, "iso9660") == 0)
add_it = 1;
2002-05-21 13:29:00 +02:00
/* add other mount types here */
2001-08-07 05:33:44 +02:00
if (add_it)
{
char **tmp = realloc(retval, sizeof (char *) * cd_count + 1);
if (tmp)
{
retval = tmp;
retval[cd_count-1] = (char *) malloc(strlen(ent->mnt_dir) + 1);
if (retval[cd_count-1])
{
strcpy(retval[cd_count-1], ent->mnt_dir);
cd_count++;
} /* if */
} /* if */
} /* if */
} /* while */
endmntent(mounts);
2001-08-07 05:33:44 +02:00
retval[cd_count - 1] = NULL;
return(retval);
2002-03-05 20:16:38 +01:00
} /* __PHYSFS_platformDetectAvailableCDs */
#endif
2001-07-07 10:24:47 +02:00
/* this is in posix.c ... */
extern char *__PHYSFS_platformCopyEnvironmentVariable(const char *varname);
2002-05-21 13:29:00 +02:00
/*
* 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.
*
* (envr) will be scribbled over, and you are expected to free() the
* return value when you're done with it.
*/
static char *findBinaryInPath(const char *bin, char *envr)
{
2002-05-21 13:29:00 +02:00
size_t alloc_size = 0;
char *exe = NULL;
char *start = envr;
char *ptr;
2002-05-21 13:29:00 +02:00
BAIL_IF_MACRO(bin == NULL, ERR_INVALID_ARGUMENT, NULL);
BAIL_IF_MACRO(envr == NULL, ERR_INVALID_ARGUMENT, NULL);
do
{
2002-05-21 13:29:00 +02:00
size_t size;
ptr = strchr(start, ':'); /* find next $PATH separator. */
if (ptr)
*ptr = '\0';
2002-05-21 13:29:00 +02:00
size = strlen(start) + strlen(bin) + 2;
if (size > alloc_size)
{
2002-05-21 13:29:00 +02:00
char *x = (char *) realloc(exe, size);
if (x == NULL)
{
if (exe != NULL)
free(exe);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
alloc_size = size;
exe = x;
} /* if */
2002-05-21 13:29:00 +02:00
/* build full binary path... */
strcpy(exe, start);
2001-08-29 05:31:43 +02:00
if (exe[strlen(exe) - 1] != '/')
strcat(exe, "/");
2002-05-21 13:29:00 +02:00
strcat(exe, bin);
if (access(exe, X_OK) == 0) /* Exists as executable? We're done. */
{
2002-05-21 13:29:00 +02:00
strcpy(exe, start); /* i'm lazy. piss off. */
return(exe);
} /* if */
2002-05-21 13:29:00 +02:00
start = ptr + 1; /* start points to beginning of next element. */
} while (ptr != NULL);
2002-05-21 13:29:00 +02:00
if (exe != NULL)
free(exe);
return(NULL); /* doesn't exist in path. */
} /* findBinaryInPath */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
/* If there isn't a path on argv0, then look through the $PATH for it. */
char *retval;
char *envr;
if (strchr(argv0, '/') != NULL) /* default behaviour can handle this. */
return(NULL);
envr = __PHYSFS_platformCopyEnvironmentVariable("PATH");
2002-05-21 13:29:00 +02:00
BAIL_IF_MACRO(!envr, NULL, NULL);
retval = findBinaryInPath(argv0, envr);
free(envr);
return(retval);
} /* __PHYSFS_platformCalcBaseDir */
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
2001-07-07 10:24:47 +02:00
{
2002-04-06 23:05:14 +02:00
return((PHYSFS_uint64) ((PHYSFS_uint32) pthread_self()));
2001-07-07 10:24:47 +02:00
} /* __PHYSFS_platformGetThreadID */
/* Much like my college days, try to sleep for 10 milliseconds at a time... */
void __PHYSFS_platformTimeslice(void)
{
usleep( 10 * 1000 ); /* don't care if it fails. */
} /* __PHYSFS_platformTimeslice */
char *__PHYSFS_platformRealPath(const char *path)
{
char resolved_path[MAXPATHLEN];
char *retval = NULL;
errno = 0;
BAIL_IF_MACRO(!realpath(path, resolved_path), strerror(errno), NULL);
retval = (char *) malloc(strlen(resolved_path) + 1);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, resolved_path);
return(retval);
} /* __PHYSFS_platformRealPath */
2002-03-30 17:44:09 +01:00
void *__PHYSFS_platformCreateMutex(void)
{
int rc;
pthread_mutex_t *m = (pthread_mutex_t *) malloc(sizeof (pthread_mutex_t));
BAIL_IF_MACRO(m == NULL, ERR_OUT_OF_MEMORY, NULL);
rc = pthread_mutex_init(m, NULL);
if (rc != 0)
{
free(m);
BAIL_MACRO(strerror(rc), NULL);
} /* if */
return((void *) m);
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
pthread_mutex_destroy((pthread_mutex_t *) mutex);
free(mutex);
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
return(pthread_mutex_lock((pthread_mutex_t *) mutex) == 0);
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
pthread_mutex_unlock((pthread_mutex_t *) mutex);
} /* __PHYSFS_platformReleaseMutex */
#endif /* !defined __BEOS__ */
2001-07-07 10:24:47 +02:00
/* end of unix.c ... */