misc/libphysfs/src/platform_macosx.c
branchphysfslayer
changeset 8524 a65e9bcf0a03
parent 8522 1853628ae285
child 8526 9f2bd885d773
equal deleted inserted replaced
8522:1853628ae285 8524:a65e9bcf0a03
     1 /*
       
     2  * Mac OS X 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_MACOSX
       
    13 
       
    14 #include <CoreFoundation/CoreFoundation.h>
       
    15 
       
    16 #if !defined(PHYSFS_NO_CDROM_SUPPORT)
       
    17 #include <Carbon/Carbon.h>  /* !!! FIXME */
       
    18 #include <IOKit/storage/IOMedia.h>
       
    19 #include <IOKit/storage/IOCDMedia.h>
       
    20 #include <IOKit/storage/IODVDMedia.h>
       
    21 #include <sys/mount.h>
       
    22 #endif
       
    23 
       
    24 /* Seems to get defined in some system header... */
       
    25 #ifdef Free
       
    26 #undef Free
       
    27 #endif
       
    28 
       
    29 #include "physfs_internal.h"
       
    30 
       
    31 
       
    32 /* Wrap PHYSFS_Allocator in a CFAllocator... */
       
    33 static CFAllocatorRef cfallocator = NULL;
       
    34 
       
    35 static CFStringRef cfallocDesc(const void *info)
       
    36 {
       
    37     return CFStringCreateWithCString(cfallocator, "PhysicsFS",
       
    38                                      kCFStringEncodingASCII);
       
    39 } /* cfallocDesc */
       
    40 
       
    41 
       
    42 static void *cfallocMalloc(CFIndex allocSize, CFOptionFlags hint, void *info)
       
    43 {
       
    44     return allocator.Malloc(allocSize);
       
    45 } /* cfallocMalloc */
       
    46 
       
    47 
       
    48 static void cfallocFree(void *ptr, void *info)
       
    49 {
       
    50     allocator.Free(ptr);
       
    51 } /* cfallocFree */
       
    52 
       
    53 
       
    54 static void *cfallocRealloc(void *ptr, CFIndex newsize,
       
    55                             CFOptionFlags hint, void *info)
       
    56 {
       
    57     if ((ptr == NULL) || (newsize <= 0))
       
    58         return NULL;  /* ADC docs say you should always return NULL here. */
       
    59     return allocator.Realloc(ptr, newsize);
       
    60 } /* cfallocRealloc */
       
    61 
       
    62 
       
    63 int __PHYSFS_platformInit(void)
       
    64 {
       
    65     /* set up a CFAllocator, so Carbon can use the physfs allocator, too. */
       
    66     CFAllocatorContext ctx;
       
    67     memset(&ctx, '\0', sizeof (ctx));
       
    68     ctx.copyDescription = cfallocDesc;
       
    69     ctx.allocate = cfallocMalloc;
       
    70     ctx.reallocate = cfallocRealloc;
       
    71     ctx.deallocate = cfallocFree;
       
    72     cfallocator = CFAllocatorCreate(kCFAllocatorUseContext, &ctx);
       
    73     BAIL_IF_MACRO(!cfallocator, PHYSFS_ERR_OUT_OF_MEMORY, 0);
       
    74     return 1;  /* success. */
       
    75 } /* __PHYSFS_platformInit */
       
    76 
       
    77 
       
    78 int __PHYSFS_platformDeinit(void)
       
    79 {
       
    80     CFRelease(cfallocator);
       
    81     cfallocator = NULL;
       
    82     return 1;  /* always succeed. */
       
    83 } /* __PHYSFS_platformDeinit */
       
    84 
       
    85 
       
    86 
       
    87 /* CD-ROM detection code... */
       
    88 
       
    89 /*
       
    90  * Code based on sample from Apple Developer Connection:
       
    91  *  http://developer.apple.com/samplecode/Sample_Code/Devices_and_Hardware/Disks/VolumeToBSDNode/VolumeToBSDNode.c.htm
       
    92  */
       
    93 
       
    94 #if !defined(PHYSFS_NO_CDROM_SUPPORT)
       
    95 
       
    96 static int darwinIsWholeMedia(io_service_t service)
       
    97 {
       
    98     int retval = 0;
       
    99     CFTypeRef wholeMedia;
       
   100 
       
   101     if (!IOObjectConformsTo(service, kIOMediaClass))
       
   102         return 0;
       
   103         
       
   104     wholeMedia = IORegistryEntryCreateCFProperty(service,
       
   105                                                  CFSTR(kIOMediaWholeKey),
       
   106                                                  cfallocator, 0);
       
   107     if (wholeMedia == NULL)
       
   108         return 0;
       
   109 
       
   110     retval = CFBooleanGetValue(wholeMedia);
       
   111     CFRelease(wholeMedia);
       
   112 
       
   113     return retval;
       
   114 } /* darwinIsWholeMedia */
       
   115 
       
   116 
       
   117 static int darwinIsMountedDisc(char *bsdName, mach_port_t masterPort)
       
   118 {
       
   119     int retval = 0;
       
   120     CFMutableDictionaryRef matchingDict;
       
   121     kern_return_t rc;
       
   122     io_iterator_t iter;
       
   123     io_service_t service;
       
   124 
       
   125     if ((matchingDict = IOBSDNameMatching(masterPort, 0, bsdName)) == NULL)
       
   126         return 0;
       
   127 
       
   128     rc = IOServiceGetMatchingServices(masterPort, matchingDict, &iter);
       
   129     if ((rc != KERN_SUCCESS) || (!iter))
       
   130         return 0;
       
   131 
       
   132     service = IOIteratorNext(iter);
       
   133     IOObjectRelease(iter);
       
   134     if (!service)
       
   135         return 0;
       
   136 
       
   137     rc = IORegistryEntryCreateIterator(service, kIOServicePlane,
       
   138              kIORegistryIterateRecursively | kIORegistryIterateParents, &iter);
       
   139     
       
   140     if (!iter)
       
   141         return 0;
       
   142 
       
   143     if (rc != KERN_SUCCESS)
       
   144     {
       
   145         IOObjectRelease(iter);
       
   146         return 0;
       
   147     } /* if */
       
   148 
       
   149     IOObjectRetain(service);  /* add an extra object reference... */
       
   150 
       
   151     do
       
   152     {
       
   153         if (darwinIsWholeMedia(service))
       
   154         {
       
   155             if ( (IOObjectConformsTo(service, kIOCDMediaClass)) ||
       
   156                  (IOObjectConformsTo(service, kIODVDMediaClass)) )
       
   157             {
       
   158                 retval = 1;
       
   159             } /* if */
       
   160         } /* if */
       
   161         IOObjectRelease(service);
       
   162     } while ((service = IOIteratorNext(iter)) && (!retval));
       
   163                 
       
   164     IOObjectRelease(iter);
       
   165     IOObjectRelease(service);
       
   166 
       
   167     return retval;
       
   168 } /* darwinIsMountedDisc */
       
   169 
       
   170 #endif /* !defined(PHYSFS_NO_CDROM_SUPPORT) */
       
   171 
       
   172 
       
   173 void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
       
   174 {
       
   175 #if !defined(PHYSFS_NO_CDROM_SUPPORT)
       
   176     const char *devPrefix = "/dev/";
       
   177     const int prefixLen = strlen(devPrefix);
       
   178     mach_port_t masterPort = 0;
       
   179     struct statfs *mntbufp;
       
   180     int i, mounts;
       
   181 
       
   182     if (IOMasterPort(MACH_PORT_NULL, &masterPort) != KERN_SUCCESS)
       
   183         BAIL_MACRO(PHYSFS_ERR_OS_ERROR, ) /*return void*/;
       
   184 
       
   185     mounts = getmntinfo(&mntbufp, MNT_WAIT);  /* NOT THREAD SAFE! */
       
   186     for (i = 0; i < mounts; i++)
       
   187     {
       
   188         char *dev = mntbufp[i].f_mntfromname;
       
   189         char *mnt = mntbufp[i].f_mntonname;
       
   190         if (strncmp(dev, devPrefix, prefixLen) != 0)  /* a virtual device? */
       
   191             continue;
       
   192 
       
   193         dev += prefixLen;
       
   194         if (darwinIsMountedDisc(dev, masterPort))
       
   195             cb(data, mnt);
       
   196     } /* for */
       
   197 #endif /* !defined(PHYSFS_NO_CDROM_SUPPORT) */
       
   198 } /* __PHYSFS_platformDetectAvailableCDs */
       
   199 
       
   200 
       
   201 static char *convertCFString(CFStringRef cfstr)
       
   202 {
       
   203     CFIndex len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfstr),
       
   204                                                     kCFStringEncodingUTF8) + 1;
       
   205     char *retval = (char *) allocator.Malloc(len);
       
   206     BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
       
   207 
       
   208     if (CFStringGetCString(cfstr, retval, len, kCFStringEncodingUTF8))
       
   209     {
       
   210         /* shrink overallocated buffer if possible... */
       
   211         CFIndex newlen = strlen(retval) + 1;
       
   212         if (newlen < len)
       
   213         {
       
   214             void *ptr = allocator.Realloc(retval, newlen);
       
   215             if (ptr != NULL)
       
   216                 retval = (char *) ptr;
       
   217         } /* if */
       
   218     } /* if */
       
   219 
       
   220     else  /* probably shouldn't fail, but just in case... */
       
   221     {
       
   222         allocator.Free(retval);
       
   223         BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
       
   224     } /* else */
       
   225 
       
   226     return retval;
       
   227 } /* convertCFString */
       
   228 
       
   229 
       
   230 char *__PHYSFS_platformCalcBaseDir(const char *argv0)
       
   231 {
       
   232     CFURLRef cfurl = NULL;
       
   233     CFStringRef cfstr = NULL;
       
   234     CFMutableStringRef cfmutstr = NULL;
       
   235     char *retval = NULL;
       
   236 
       
   237     cfurl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
       
   238     BAIL_IF_MACRO(cfurl == NULL, PHYSFS_ERR_OS_ERROR, NULL);
       
   239     cfstr = CFURLCopyFileSystemPath(cfurl, kCFURLPOSIXPathStyle);
       
   240     CFRelease(cfurl);
       
   241     BAIL_IF_MACRO(!cfstr, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
       
   242     cfmutstr = CFStringCreateMutableCopy(cfallocator, 0, cfstr);
       
   243     CFRelease(cfstr);
       
   244     BAIL_IF_MACRO(!cfmutstr, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
       
   245     CFStringAppendCString(cfmutstr, "/", kCFStringEncodingUTF8);
       
   246     retval = convertCFString(cfmutstr);
       
   247     CFRelease(cfmutstr);
       
   248 
       
   249     return retval;  /* whew. */
       
   250 } /* __PHYSFS_platformCalcBaseDir */
       
   251 
       
   252 
       
   253 char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
       
   254 {
       
   255     /* !!! FIXME: there's a real API to determine this */
       
   256     const char *userdir = __PHYSFS_getUserDir();
       
   257     const char *append = "Library/Application Support/";
       
   258     const size_t len = strlen(userdir) + strlen(append) + strlen(app) + 2;
       
   259     char *retval = allocator.Malloc(len);
       
   260     BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
       
   261     snprintf(retval, len, "%s%s%s/", userdir, append, app);
       
   262     return retval;
       
   263 } /* __PHYSFS_platformCalcPrefDir */
       
   264 
       
   265 
       
   266 /* Platform allocator uses default CFAllocator at PHYSFS_init() time. */
       
   267 
       
   268 static CFAllocatorRef cfallocdef = NULL;
       
   269 
       
   270 static int macosxAllocatorInit(void)
       
   271 {
       
   272     int retval = 0;
       
   273     cfallocdef = CFAllocatorGetDefault();
       
   274     retval = (cfallocdef != NULL);
       
   275     if (retval)
       
   276         CFRetain(cfallocdef);
       
   277     return retval;
       
   278 } /* macosxAllocatorInit */
       
   279 
       
   280 
       
   281 static void macosxAllocatorDeinit(void)
       
   282 {
       
   283     if (cfallocdef != NULL)
       
   284     {
       
   285         CFRelease(cfallocdef);
       
   286         cfallocdef = NULL;
       
   287     } /* if */
       
   288 } /* macosxAllocatorDeinit */
       
   289 
       
   290 
       
   291 static void *macosxAllocatorMalloc(PHYSFS_uint64 s)
       
   292 {
       
   293     if (!__PHYSFS_ui64FitsAddressSpace(s))
       
   294         BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
       
   295     return CFAllocatorAllocate(cfallocdef, (CFIndex) s, 0);
       
   296 } /* macosxAllocatorMalloc */
       
   297 
       
   298 
       
   299 static void *macosxAllocatorRealloc(void *ptr, PHYSFS_uint64 s)
       
   300 {
       
   301     if (!__PHYSFS_ui64FitsAddressSpace(s))
       
   302         BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
       
   303     return CFAllocatorReallocate(cfallocdef, ptr, (CFIndex) s, 0);
       
   304 } /* macosxAllocatorRealloc */
       
   305 
       
   306 
       
   307 static void macosxAllocatorFree(void *ptr)
       
   308 {
       
   309     CFAllocatorDeallocate(cfallocdef, ptr);
       
   310 } /* macosxAllocatorFree */
       
   311 
       
   312 
       
   313 int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
       
   314 {
       
   315     allocator.Init = macosxAllocatorInit;
       
   316     allocator.Deinit = macosxAllocatorDeinit;
       
   317     allocator.Malloc = macosxAllocatorMalloc;
       
   318     allocator.Realloc = macosxAllocatorRealloc;
       
   319     allocator.Free = macosxAllocatorFree;
       
   320     return 1;  /* return non-zero: we're supplying custom allocator. */
       
   321 } /* __PHYSFS_platformSetDefaultAllocator */
       
   322 
       
   323 #endif /* PHYSFS_PLATFORM_MACOSX */
       
   324 
       
   325 /* end of macosx.c ... */
       
   326