src/unison/physfs-1.1.1/platform/beos.cpp

   1 /*
   2  * BeOS platform-dependent support routines for PhysicsFS.
   3  *
   4  * Please see the file LICENSE.txt in the source's root directory.
   5  *
   6  *  This file written by Ryan C. Gordon.
   7  */
   8
   9 #define __PHYSICSFS_INTERNAL__
  10 #include "physfs_platforms.h"
  11
  12 #ifdef PHYSFS_PLATFORM_BEOS
  13
  14 #include <be/kernel/OS.h>
  15 #include <be/app/Roster.h>
  16 #include <be/storage/Volume.h>
  17 #include <be/storage/VolumeRoster.h>
  18 #include <be/storage/Directory.h>
  19 #include <be/storage/Entry.h>
  20 #include <be/storage/Path.h>
  21 #include <be/kernel/fs_info.h>
  22 #include <be/device/scsi.h>
  23 #include <be/support/Locker.h>
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <unistd.h>
  30
  31 #include "physfs_internal.h"
  32
  33
  34 int __PHYSFS_platformInit(void)
  35 {
  36     return(1);  /* always succeed. */
  37 } /* __PHYSFS_platformInit */
  38
  39
  40 int __PHYSFS_platformDeinit(void)
  41 {
  42     return(1);  /* always succeed. */
  43 } /* __PHYSFS_platformDeinit */
  44
  45
  46 static char *getMountPoint(const char *devname)
  47 {
  48     BVolumeRoster mounts;
  49     BVolume vol;
  50
  51     mounts.Rewind();
  52     while (mounts.GetNextVolume(&vol) == B_NO_ERROR)
  53     {
  54         fs_info fsinfo;
  55         fs_stat_dev(vol.Device(), &fsinfo);
  56         if (strcmp(devname, fsinfo.device_name) == 0)
  57         {
  58             //char buf[B_FILE_NAME_LENGTH];
  59             BDirectory directory;
  60             BEntry entry;
  61             BPath path;
  62             status_t rc;
  63             rc = vol.GetRootDirectory(&directory);
  64             BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL);
  65             rc = directory.GetEntry(&entry);
  66             BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL);
  67             rc = entry.GetPath(&path);
  68             BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL);
  69             const char *str = path.Path();
  70             BAIL_IF_MACRO(str == NULL, ERR_OS_ERROR, NULL);  /* ?! */
  71             char *retval = (char *) allocator.Malloc(strlen(str) + 1);
  72             BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
  73             strcpy(retval, str);
  74             return(retval);
  75         } /* if */
  76     } /* while */
  77
  78     return(NULL);
  79 } /* getMountPoint */
  80
  81
  82     /*
  83      * This function is lifted from Simple Directmedia Layer (SDL):
  84      *  http://www.libsdl.org/
  85      */
  86 static void tryDir(const char *d, PHYSFS_StringCallback callback, void *data)
  87 {
  88     BDirectory dir;
  89     dir.SetTo(d);
  90     if (dir.InitCheck() != B_NO_ERROR)
  91         return;
  92
  93     dir.Rewind();
  94     BEntry entry;
  95     while (dir.GetNextEntry(&entry) >= 0)
  96     {
  97         BPath path;
  98         const char *name;
  99         entry_ref e;
 100
 101         if (entry.GetPath(&path) != B_NO_ERROR)
 102             continue;
 103
 104         name = path.Path();
 105
 106         if (entry.GetRef(&e) != B_NO_ERROR)
 107             continue;
 108
 109         if (entry.IsDirectory())
 110         {
 111             if (strcmp(e.name, "floppy") != 0)
 112                 tryDir(name, callback, data);
 113         } /* if */
 114
 115         else
 116         {
 117             bool add_it = false;
 118             int devfd;
 119             device_geometry g;
 120
 121             if (strcmp(e.name, "raw") == 0)  /* ignore partitions. */
 122             {
 123                 int devfd = open(name, O_RDONLY);
 124                 if (devfd >= 0)
 125                 {
 126                     if (ioctl(devfd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
 127                     {
 128                         if (g.device_type == B_CD)
 129                         {
 130                             char *mntpnt = getMountPoint(name);
 131                             if (mntpnt != NULL)
 132                             {
 133                                 callback(data, mntpnt);
 134                                 allocator.Free(mntpnt);  /* !!! FIXME: lose this malloc! */
 135                             } /* if */
 136                         } /* if */
 137                     } /* if */
 138                 } /* if */
 139             } /* if */
 140
 141             close(devfd);
 142         } /* else */
 143     } /* while */
 144 } /* tryDir */
 145
 146
 147 void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
 148 {
 149     tryDir("/dev/disk", cb, data);
 150 } /* __PHYSFS_platformDetectAvailableCDs */
 151
 152
 153 static team_id getTeamID(void)
 154 {
 155     thread_info info;
 156     thread_id tid = find_thread(NULL);
 157     get_thread_info(tid, &info);
 158     return(info.team);
 159 } /* getTeamID */
 160
 161
 162 char *__PHYSFS_platformCalcBaseDir(const char *argv0)
 163 {
 164     /* in case there isn't a BApplication yet, we'll construct a roster. */
 165     BRoster roster;
 166     app_info info;
 167     status_t rc = roster.GetRunningAppInfo(getTeamID(), &info);
 168     BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL);
 169     BEntry entry(&(info.ref), true);
 170     BPath path;
 171     rc = entry.GetPath(&path);  /* (path) now has binary's path. */
 172     assert(rc == B_OK);
 173     rc = path.GetParent(&path); /* chop filename, keep directory. */
 174     assert(rc == B_OK);
 175     const char *str = path.Path();
 176     assert(str != NULL);
 177     char *retval = (char *) allocator.Malloc(strlen(str) + 1);
 178     BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
 179     strcpy(retval, str);
 180     return(retval);
 181 } /* __PHYSFS_platformCalcBaseDir */
 182
 183
 184 PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
 185 {
 186     return((PHYSFS_uint64) find_thread(NULL));
 187 } /* __PHYSFS_platformGetThreadID */
 188
 189
 190 char *__PHYSFS_platformRealPath(const char *path)
 191 {
 192     BPath normalized(path, NULL, true);  /* force normalization of path. */
 193     const char *resolved_path = normalized.Path();
 194     BAIL_IF_MACRO(resolved_path == NULL, ERR_NO_SUCH_FILE, NULL);
 195     char *retval = (char *) allocator.Malloc(strlen(resolved_path) + 1);
 196     BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
 197     strcpy(retval, resolved_path);
 198     return(retval);
 199 } /* __PHYSFS_platformRealPath */
 200
 201
 202 char *__PHYSFS_platformCurrentDir(void)
 203 {
 204     return(__PHYSFS_platformRealPath("."));  /* let BPath sort it out. */
 205 } /* __PHYSFS_platformCurrentDir */
 206
 207
 208 void *__PHYSFS_platformCreateMutex(void)
 209 {
 210     return(new BLocker("PhysicsFS lock", true));
 211 } /* __PHYSFS_platformCreateMutex */
 212
 213
 214 void __PHYSFS_platformDestroyMutex(void *mutex)
 215 {
 216     delete ((BLocker *) mutex);
 217 } /* __PHYSFS_platformDestroyMutex */
 218
 219
 220 int __PHYSFS_platformGrabMutex(void *mutex)
 221 {
 222     return ((BLocker *) mutex)->Lock() ? 1 : 0;
 223 } /* __PHYSFS_platformGrabMutex */
 224
 225
 226 void __PHYSFS_platformReleaseMutex(void *mutex)
 227 {
 228     ((BLocker *) mutex)->Unlock();
 229 } /* __PHYSFS_platformReleaseMutex */
 230
 231
 232 int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
 233 {
 234     return(0);  /* just use malloc() and friends. */
 235 } /* __PHYSFS_platformSetDefaultAllocator */
 236
 237 #endif  /* PHYSFS_PLATFORM_BEOS */
 238
 239 /* end of beos.cpp ... */
 240