CFBundle_Binary.c

   1 /*
   2  * Copyright (c) 2015 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*      CFBundle_Binary.c
  25         Copyright (c) 1999-2014, Apple Inc.  All rights reserved.
  26         Responsibility: Tony Parker
  27 */
  28
  29 #include "CFBundle_Internal.h"
  30
  31 #if defined(BINARY_SUPPORT_DYLD)
  32 // Import the mach-o headers that define the macho magic numbers
  33 #include <mach-o/loader.h>
  34 #include <mach-o/fat.h>
  35 #include <mach-o/arch.h>
  36 #include <mach-o/dyld.h>
  37 #include <mach-o/getsect.h>
  38 #include <unistd.h>
  39 #include <fcntl.h>
  40 #include <sys/mman.h>
  41 #include <crt_externs.h>
  42 #if defined(USE_DYLD_PRIV)
  43 #include <mach-o/dyld_priv.h>
  44 #endif /* USE_DYLD_PRIV */
  45 #endif /* BINARY_SUPPORT_DYLD */
  46
  47 #if defined(BINARY_SUPPORT_DLFCN)
  48 #include <dlfcn.h>
  49 #endif /* BINARY_SUPPORT_DLFCN */
  50
  51 #if defined(BINARY_SUPPORT_DYLD)
  52 static CFStringRef _CFBundleDYLDCopyLoadedImagePathForPointer(void *p);
  53 #if !defined(BINARY_SUPPORT_DLFCN)
  54 static void *_CFBundleDYLDGetSymbolByNameWithSearch(CFBundleRef bundle, CFStringRef symbolName, Boolean globalSearch);
  55 #endif /* !BINARY_SUPPORT_DLFCN */
  56 #endif /* BINARY_SUPPORT_DYLD */
  57 #if defined(BINARY_SUPPORT_DLFCN)
  58 static void *_CFBundleDlfcnGetSymbolByNameWithSearch(CFBundleRef bundle, CFStringRef symbolName, Boolean globalSearch);
  59 #if !defined(BINARY_SUPPORT_DYLD)
  60 static CFStringRef _CFBundleDlfcnCopyLoadedImagePathForPointer(void *p);
  61 #endif /* !BINARY_SUPPORT_DYLD */
  62 #endif /* BINARY_SUPPORT_DLFCN */
  63
  64
  65 CF_PRIVATE SInt32 _CFBundleCurrentArchitecture(void) {
  66     SInt32 arch = 0;
  67 #if defined(__ppc__)
  68     arch = kCFBundleExecutableArchitecturePPC;
  69 #elif defined(__ppc64__)
  70     arch = kCFBundleExecutableArchitecturePPC64;
  71 #elif defined(__i386__)
  72     arch = kCFBundleExecutableArchitectureI386;
  73 #elif defined(__x86_64__)
  74     arch = kCFBundleExecutableArchitectureX86_64;
  75 #elif defined(BINARY_SUPPORT_DYLD)
  76     const NXArchInfo *archInfo = NXGetLocalArchInfo();
  77     if (archInfo) arch = archInfo->cputype;
  78 #endif
  79     return arch;
  80 }
  81
  82 #if defined(BINARY_SUPPORT_DYLD)
  83
  84 CF_PRIVATE CFArrayRef _CFBundleDYLDCopyLoadedImagePathsForHint(CFStringRef hint) {
  85     uint32_t i, numImages = _dyld_image_count();
  86     CFMutableArrayRef result = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
  87     CFRange range = CFRangeMake(0, CFStringGetLength(hint)), altRange = CFRangeMake(0, 0), testRange = CFRangeMake(0, 0);
  88     const char *processPath = _CFProcessPath();
  89     const void *mhp = (const void *)_NSGetMachExecuteHeader();
  90
  91     if (range.length > 14) {
  92         // handle some common variations on framework bundle identifiers
  93         if (CFStringFindWithOptions(hint, CFSTR(".framework"), range, kCFCompareAnchored|kCFCompareBackwards|kCFCompareCaseInsensitive, &testRange) && testRange.location > 0 && testRange.length > 0) {
  94             // identifier has .framework appended
  95             altRange.length = testRange.location;
  96         } else if (CFStringFindWithOptions(hint, CFSTR("framework"), range, kCFCompareAnchored|kCFCompareBackwards|kCFCompareCaseInsensitive, &testRange) && testRange.location > 0 && testRange.length > 0) {
  97             // identifier has Framework appended
  98             altRange.length = testRange.location;
  99         } else if (CFStringFindWithOptions(hint, CFSTR("fw"), range, kCFCompareAnchored|kCFCompareBackwards|kCFCompareCaseInsensitive, &testRange) && testRange.location > 0 && testRange.length > 0) {
 100             // identifier has FW appended
 101             altRange.length = testRange.location;
 102         }
 103     }
 104     for (i = 0; i < numImages; i++) {
 105         const char *curName = _dyld_get_image_name(i), *lastComponent = NULL;
 106         if (curName && (!processPath || 0 != strcmp(curName, processPath)) && mhp != (void *)_dyld_get_image_header(i)) lastComponent = strrchr(curName, '/');
 107         if (lastComponent) {
 108             CFStringRef str = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, lastComponent + 1);
 109             if (str) {
 110                 if (CFStringFindWithOptions(hint, str, range, kCFCompareAnchored|kCFCompareBackwards|kCFCompareCaseInsensitive, NULL) || (altRange.length > 0 && CFStringFindWithOptions(hint, str, altRange, kCFCompareAnchored|kCFCompareBackwards|kCFCompareCaseInsensitive, NULL))) {
 111                     CFStringRef curStr = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, curName);
 112                     if (curStr) {
 113                         CFArrayAppendValue(result, curStr);
 114                         CFRelease(curStr);
 115                     }
 116                 }
 117                 CFRelease(str);
 118             }
 119         }
 120     }
 121     return result;
 122 }
 123
 124 static char *_cleanedPathForPath(const char *curName) {
 125     char *thePath = strdup(curName);
 126     if (thePath) {
 127         // We are going to process the buffer replacing all "/./" and "//" with "/"
 128         CFIndex srcIndex = 0, dstIndex = 0;
 129         CFIndex len = strlen(thePath);
 130         for (srcIndex=0; srcIndex<len; srcIndex++) {
 131             thePath[dstIndex] = thePath[srcIndex];
 132             dstIndex++;
 133             while (srcIndex < len-1 && thePath[srcIndex] == '/' && (thePath[srcIndex+1] == '/' || (thePath[srcIndex+1] == '.' && srcIndex < len-2 && thePath[srcIndex+2] == '/'))) srcIndex += (thePath[srcIndex+1] == '/' ? 1 : 2);
 134         }
 135         thePath[dstIndex] = 0;
 136     }
 137     return thePath;
 138 }
 139
 140 CF_PRIVATE CFArrayRef _CFBundleDYLDCopyLoadedImagePathsIfChanged(void) {
 141     // This returns an array of the paths of all the dyld images in the process.  These paths may not be absolute, they may point at things that are not bundles, they may be staticly linked bundles or dynamically loaded bundles, they may be NULL.
 142     uint32_t i, numImages = _dyld_image_count();
 143     CFMutableArrayRef result = NULL;
 144     static uint32_t _cachedDYLDImageCount = -1;
 145
 146     if (numImages != _cachedDYLDImageCount) {
 147         const char *curName;
 148         char *cleanedCurName = NULL;
 149         CFStringRef curStr;
 150         const char *processPath = _CFProcessPath();
 151         const void *mhp = (const void *)_NSGetMachExecuteHeader();
 152
 153         result = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
 154
 155         for (i = 0; i < numImages; i++) {
 156             curName = _dyld_get_image_name(i);
 157             if (curName && i == 0) cleanedCurName = _cleanedPathForPath(curName);
 158             if (curName && (!processPath || 0 != strcmp(curName, processPath)) && (!processPath || !cleanedCurName || 0 != strcmp(cleanedCurName, processPath)) && mhp != (void *)_dyld_get_image_header(i)) {
 159                 curStr = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, curName);
 160                 if (curStr) {
 161                     CFArrayAppendValue(result, curStr);
 162                     CFRelease(curStr);
 163                 }
 164             }
 165             if (cleanedCurName) {
 166                 free(cleanedCurName);
 167                 cleanedCurName = NULL;
 168             }
 169         }
 170         _cachedDYLDImageCount = numImages;
 171     }
 172     return result;
 173 }
 174
 175 static CFStringRef _CFBundleDYLDCopyLoadedImagePathForPointer(void *p) {
 176     CFStringRef result = NULL;
 177 #if defined(USE_DYLD_PRIV)
 178     const char *name = dyld_image_path_containing_address(p);
 179     if (name) result = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, name);
 180 #else /* USE_DYLD_PRIV */
 181     if (!result) {
 182         uint32_t i, j, n = _dyld_image_count();
 183         Boolean foundit = false;
 184         const char *name;
 185 #if __LP64__
 186 #define MACH_HEADER_TYPE struct mach_header_64
 187 #define MACH_SEGMENT_CMD_TYPE struct segment_command_64
 188 #define MACH_SEGMENT_FLAVOR LC_SEGMENT_64
 189 #else
 190 #define MACH_HEADER_TYPE struct mach_header
 191 #define MACH_SEGMENT_CMD_TYPE struct segment_command
 192 #define MACH_SEGMENT_FLAVOR LC_SEGMENT
 193 #endif
 194         for (i = 0; !foundit && i < n; i++) {
 195             const MACH_HEADER_TYPE *mh = (const MACH_HEADER_TYPE *)_dyld_get_image_header(i);
 196             uintptr_t addr = (uintptr_t)p - _dyld_get_image_vmaddr_slide(i);
 197             if (mh) {
 198                 struct load_command *lc = (struct load_command *)((char *)mh + sizeof(MACH_HEADER_TYPE));
 199                 for (j = 0; !foundit && j < mh->ncmds; j++, lc = (struct load_command *)((char *)lc + lc->cmdsize)) {
 200                     if (MACH_SEGMENT_FLAVOR == lc->cmd && ((MACH_SEGMENT_CMD_TYPE *)lc)->vmaddr <= addr && addr < ((MACH_SEGMENT_CMD_TYPE *)lc)->vmaddr + ((MACH_SEGMENT_CMD_TYPE *)lc)->vmsize) {
 201                         foundit = true;
 202                         name = _dyld_get_image_name(i);
 203                         if (name) result = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, name);
 204                     }
 205                 }
 206             }
 207         }
 208 #undef MACH_HEADER_TYPE
 209 #undef MACH_SEGMENT_CMD_TYPE
 210 #undef MACH_SEGMENT_FLAVOR
 211     }
 212 #endif /* USE_DYLD_PRIV */
 213 #if LOG_BUNDLE_LOAD
 214     printf("dyld image path for pointer %p is %p\n", p, result);
 215 #endif /* LOG_BUNDLE_LOAD */
 216     return result;
 217 }
 218
 219 #if !defined(BINARY_SUPPORT_DLFCN)
 220
 221 static const void *__CFBundleDYLDFindImage(char *buff) {
 222     const void *header = NULL;
 223     uint32_t i, numImages = _dyld_image_count(), numMatches = 0;
 224     const char *curName, *p, *q;
 225
 226     for (i = 0; !header && i < numImages; i++) {
 227         curName = _dyld_get_image_name(i);
 228         if (curName && 0 == strncmp(curName, buff, CFMaxPathSize)) {
 229             header = _dyld_get_image_header(i);
 230             numMatches = 1;
 231         }
 232     }
 233     if (!header) {
 234         for (i = 0; i < numImages; i++) {
 235             curName = _dyld_get_image_name(i);
 236             if (curName) {
 237                 for (p = buff, q = curName; *p && *q && (q - curName < CFMaxPathSize); p++, q++) {
 238                     if (*p != *q && (q - curName > 11) && 0 == strncmp(q - 11, ".framework/Versions/", 20) && *(q + 9) && '/' == *(q + 10)) q += 11;
 239                     else if (*p != *q && (q - curName > 12) && 0 == strncmp(q - 12, ".framework/Versions/", 20) && *(q + 8) && '/' == *(q + 9)) q += 10;
 240                     if (*p != *q) break;
 241                 }
 242                 if (*p == *q) {
 243                     header = _dyld_get_image_header(i);
 244                     numMatches++;
 245                 }
 246             }
 247         }
 248     }
 249     return (numMatches == 1) ? header : NULL;
 250 }
 251
 252 CF_PRIVATE Boolean _CFBundleDYLDCheckLoaded(CFBundleRef bundle) {
 253     if (!bundle->_isLoaded) {
 254         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 255         char buff[CFMaxPathSize];
 256
 257         if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {
 258             const void *header = __CFBundleDYLDFindImage(buff);
 259             if (header) {
 260                 if (bundle->_binaryType == __CFBundleUnknownBinary) bundle->_binaryType = __CFBundleDYLDFrameworkBinary;
 261                 if (!bundle->_imageCookie) {
 262                     bundle->_imageCookie = header;
 263 #if LOG_BUNDLE_LOAD
 264                     printf("dyld check load bundle %p, find %s getting image %p\n", bundle, buff, bundle->_imageCookie);
 265 #endif /* LOG_BUNDLE_LOAD */
 266                 }
 267                 bundle->_isLoaded = true;
 268             } else {
 269 #if LOG_BUNDLE_LOAD
 270                 printf("dyld check load bundle %p, find %s no image\n", bundle, buff);
 271 #endif /* LOG_BUNDLE_LOAD */
 272             }
 273         }
 274         if (executableURL) CFRelease(executableURL);
 275     }
 276     return bundle->_isLoaded;
 277 }
 278
 279 CF_PRIVATE Boolean _CFBundleDYLDLoadBundle(CFBundleRef bundle, Boolean forceGlobal, CFErrorRef *error) {
 280     CFErrorRef localError = NULL, *subError = (error ? &localError : NULL);
 281     NSLinkEditErrors c = NSLinkEditUndefinedError;
 282     int errorNumber = 0;
 283     const char *fileName = NULL;
 284     const char *errorString = NULL;
 285
 286     if (!bundle->_isLoaded) {
 287         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 288         char buff[CFMaxPathSize];
 289
 290         if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {
 291             NSObjectFileImage image;
 292             NSObjectFileImageReturnCode retCode = NSCreateObjectFileImageFromFile(buff, &image);
 293 #if LOG_BUNDLE_LOAD
 294             printf("dyld load bundle %p, create image of %s returns image %p retcode %d\n", bundle, buff, image, retCode);
 295 #endif /* LOG_BUNDLE_LOAD */
 296             if (retCode == NSObjectFileImageSuccess) {
 297                 uint32_t options = forceGlobal ? NSLINKMODULE_OPTION_RETURN_ON_ERROR : (NSLINKMODULE_OPTION_BINDNOW | NSLINKMODULE_OPTION_PRIVATE | NSLINKMODULE_OPTION_RETURN_ON_ERROR);
 298                 NSModule module = NSLinkModule(image, buff, options);
 299 #if LOG_BUNDLE_LOAD
 300                 printf("dyld load bundle %p, link module of %s options 0x%x returns module %p image %p\n", bundle, buff, options, module, image);
 301 #endif /* LOG_BUNDLE_LOAD */
 302                 if (module) {
 303                     bundle->_imageCookie = image;
 304                     bundle->_moduleCookie = module;
 305                     bundle->_isLoaded = true;
 306                 } else {
 307                     NSLinkEditError(&c, &errorNumber, &fileName, &errorString);
 308                     if (error) {
 309 #if defined(BINARY_SUPPORT_DLFCN)
 310                         _CFBundleDlfcnPreflight(bundle, subError);
 311 #endif /* BINARY_SUPPORT_DLFCN */
 312                         if (!localError) {
 313                             CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), debugString = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("error code %d, error number %d (%@)"), c, errorNumber, tempString);
 314                             localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, debugString);
 315                             if (tempString) CFRelease(tempString);
 316                             if (debugString) CFRelease(debugString);
 317                         }
 318                     } else {
 319                         CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), executableString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, fileName);
 320                         CFLog(__kCFLogBundle, CFSTR("Error loading %@:  error code %d, error number %d (%@)"), executableString, c, errorNumber, tempString);
 321                         if (tempString) CFRelease(tempString);
 322                         if (executableString) CFRelease(executableString);
 323                     }
 324                     (void)NSDestroyObjectFileImage(image);
 325                 }
 326             } else {
 327                 if (error) {
 328                     if (retCode == NSObjectFileImageArch) {
 329                         localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableArchitectureMismatchError);
 330                     } else if (retCode == NSObjectFileImageInappropriateFile) {
 331                         Boolean hasRuntimeMismatch = false;
 332                         uint32_t mainFlags = 0, bundleFlags = 0;
 333                         if (_CFBundleGrokObjCImageInfoFromMainExecutable(NULL, &mainFlags) && (mainFlags & 0x2) != 0) {
 334                             if (_CFBundleGetObjCImageInfo(bundle, NULL, &bundleFlags) && (bundleFlags & 0x2) == 0) hasRuntimeMismatch = true;
 335                         }
 336                         if (hasRuntimeMismatch) {
 337                             localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableRuntimeMismatchError);
 338                         } else {
 339                             localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotLoadableError);
 340                         }
 341                     } else {
 342 #if defined(BINARY_SUPPORT_DLFCN)
 343                         _CFBundleDlfcnPreflight(bundle, subError);
 344 #endif /* BINARY_SUPPORT_DLFCN */
 345                         if (!localError) {
 346                             CFStringRef debugString = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("dyld returns %d"), retCode);
 347                             localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, debugString);
 348                             CFRelease(debugString);
 349                         }
 350                     }
 351                 } else {
 352                     CFLog(__kCFLogBundle, CFSTR("dyld returns %d when trying to load %@"), retCode, executableURL);
 353                 }
 354             }
 355         } else {
 356             if (error) {
 357                 localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);
 358             } else {
 359                 CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);
 360             }
 361         }
 362         if (executableURL) CFRelease(executableURL);
 363     }
 364     if (!bundle->_isLoaded && error) *error = localError;
 365     return bundle->_isLoaded;
 366 }
 367
 368 CF_PRIVATE Boolean _CFBundleDYLDLoadFramework(CFBundleRef bundle, CFErrorRef *error) {
 369     // !!! Framework loading should be better.  Can't unload frameworks.
 370     CFErrorRef localError = NULL, *subError = (error ? &localError : NULL);
 371     NSLinkEditErrors c = NSLinkEditUndefinedError;
 372     int errorNumber = 0;
 373     const char *fileName = NULL;
 374     const char *errorString = NULL;
 375
 376     if (!bundle->_isLoaded) {
 377         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 378         char buff[CFMaxPathSize];
 379
 380         if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {
 381             void *image = (void *)NSAddImage(buff, NSADDIMAGE_OPTION_RETURN_ON_ERROR);
 382 #if LOG_BUNDLE_LOAD
 383             printf("dyld load framework %p, add image of %s returns image %p\n", bundle, buff, image);
 384 #endif /* LOG_BUNDLE_LOAD */
 385             if (image) {
 386                 bundle->_imageCookie = image;
 387                 bundle->_isLoaded = true;
 388             } else {
 389                 NSLinkEditError(&c, &errorNumber, &fileName, &errorString);
 390                 if (error) {
 391 #if defined(BINARY_SUPPORT_DLFCN)
 392                     _CFBundleDlfcnPreflight(bundle, subError);
 393 #endif /* BINARY_SUPPORT_DLFCN */
 394                     if (!localError) {
 395                         CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), debugString = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("error code %d, error number %d (%@)"), c, errorNumber, tempString);
 396                         localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, debugString);
 397                         if (tempString) CFRelease(tempString);
 398                         if (debugString) CFRelease(debugString);
 399                     }
 400                 } else {
 401                     CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), executableString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, fileName);
 402                     CFLog(__kCFLogBundle, CFSTR("Error loading %@:  error code %d, error number %d (%@)"), executableString, c, errorNumber, tempString);
 403                     if (tempString) CFRelease(tempString);
 404                     if (executableString) CFRelease(executableString);
 405                 }
 406             }
 407         } else {
 408             if (error) {
 409                 localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);
 410             } else {
 411                 CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);
 412             }
 413         }
 414         if (executableURL) CFRelease(executableURL);
 415     }
 416     if (!bundle->_isLoaded && error) *error = localError;
 417     return bundle->_isLoaded;
 418 }
 419
 420 CF_PRIVATE void _CFBundleDYLDUnloadBundle(CFBundleRef bundle) {
 421     if (bundle->_isLoaded) {
 422 #if LOG_BUNDLE_LOAD
 423         printf("dyld unload bundle %p, handle %p module %p image %p\n", bundle, bundle->_handleCookie, bundle->_moduleCookie, bundle->_imageCookie);
 424 #endif /* LOG_BUNDLE_LOAD */
 425         if (bundle->_moduleCookie && !NSUnLinkModule((NSModule)(bundle->_moduleCookie), NSUNLINKMODULE_OPTION_NONE)) {
 426             CFLog(__kCFLogBundle, CFSTR("Internal error unloading bundle %@"), bundle);
 427         } else {
 428             if (bundle->_moduleCookie && bundle->_imageCookie) (void)NSDestroyObjectFileImage((NSObjectFileImage)(bundle->_imageCookie));
 429             bundle->_connectionCookie = bundle->_handleCookie = NULL;
 430             bundle->_imageCookie = bundle->_moduleCookie = NULL;
 431             bundle->_isLoaded = false;
 432         }
 433     }
 434 }
 435
 436 CF_PRIVATE void *_CFBundleDYLDGetSymbolByName(CFBundleRef bundle, CFStringRef symbolName) {
 437     return _CFBundleDYLDGetSymbolByNameWithSearch(bundle, symbolName, false);
 438 }
 439
 440 static void *_CFBundleDYLDGetSymbolByNameWithSearch(CFBundleRef bundle, CFStringRef symbolName, Boolean globalSearch) {
 441     void *result = NULL;
 442     char buff[1026];
 443     NSSymbol symbol = NULL;
 444
 445     buff[0] = '_';
 446     if (CFStringGetCString(symbolName, &(buff[1]), 1024, kCFStringEncodingUTF8)) {
 447         if (bundle->_moduleCookie) {
 448             symbol = NSLookupSymbolInModule((NSModule)(bundle->_moduleCookie), buff);
 449         } else if (bundle->_imageCookie) {
 450             symbol = NSLookupSymbolInImage(bundle->_imageCookie, buff, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND|NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
 451         }
 452         if (!symbol && !bundle->_moduleCookie && (!bundle->_imageCookie || globalSearch)) {
 453             char hintBuff[1026];
 454             CFStringRef executableName = _CFBundleCopyExecutableName(bundle, NULL, NULL);
 455             hintBuff[0] = '\0';
 456             if (executableName) {
 457                 if (!CFStringGetCString(executableName, hintBuff, 1024, kCFStringEncodingUTF8)) hintBuff[0] = '\0';
 458                 CFRelease(executableName);
 459             }
 460             // Nowdays, NSIsSymbolNameDefinedWithHint() and NSLookupAndBindSymbolWithHint()
 461             // are identical, except the first just returns a bool, so checking with the
 462             // Is function first just causes a redundant lookup.
 463             // This returns NULL on failure.
 464             symbol = NSLookupAndBindSymbolWithHint(buff, hintBuff);
 465         }
 466         if (symbol) result = NSAddressOfSymbol(symbol);
 467 #if defined(DEBUG)
 468         if (!result) CFLog(__kCFLogBundle, CFSTR("dyld cannot find symbol %@ in %@"), symbolName, bundle);
 469 #endif /* DEBUG */
 470 #if LOG_BUNDLE_LOAD
 471         printf("bundle %p handle %p module %p image %p dyld returns symbol %p for %s\n", bundle, bundle->_handleCookie, bundle->_moduleCookie, bundle->_imageCookie, result, buff + 1);
 472 #endif /* LOG_BUNDLE_LOAD */
 473     }
 474     return result;
 475 }
 476
 477 #endif /* !BINARY_SUPPORT_DLFCN */
 478 #endif /* BINARY_SUPPORT_DYLD */
 479
 480 #if defined(BINARY_SUPPORT_DLFCN)
 481
 482 CF_PRIVATE Boolean _CFBundleDlfcnCheckLoaded(CFBundleRef bundle) {
 483     if (!bundle->_isLoaded) {
 484         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 485         char buff[CFMaxPathSize];
 486
 487         if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {
 488             int mode = RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD | RTLD_FIRST;
 489             void *handle = dlopen(buff, mode);
 490             if (handle) {
 491                 if (!bundle->_handleCookie) {
 492                     bundle->_handleCookie = handle;
 493 #if LOG_BUNDLE_LOAD
 494                     printf("dlfcn check load bundle %p, dlopen of %s mode 0x%x getting handle %p\n", bundle, buff, mode, bundle->_handleCookie);
 495 #endif /* LOG_BUNDLE_LOAD */
 496                 }
 497                 bundle->_isLoaded = true;
 498             } else {
 499 #if LOG_BUNDLE_LOAD
 500                 printf("dlfcn check load bundle %p, dlopen of %s mode 0x%x no handle\n", bundle, buff, mode);
 501 #endif /* LOG_BUNDLE_LOAD */
 502             }
 503         }
 504         if (executableURL) CFRelease(executableURL);
 505     }
 506     return bundle->_isLoaded;
 507 }
 508
 509 CF_EXPORT Boolean _CFBundleDlfcnPreflight(CFBundleRef bundle, CFErrorRef *error) {
 510     Boolean retval = true;
 511     CFErrorRef localError = NULL;
 512     if (!bundle->_isLoaded) {
 513         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 514         char buff[CFMaxPathSize];
 515
 516         retval = false;
 517         if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {
 518             retval = dlopen_preflight(buff);
 519             if (!retval && error) {
 520                 CFArrayRef archs = CFBundleCopyExecutableArchitectures(bundle);
 521                 CFStringRef debugString = NULL;
 522                 const char *errorString = dlerror();
 523                 if (errorString && strlen(errorString) > 0) debugString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString);
 524                 if (archs) {
 525                     Boolean hasSuitableArch = false, hasRuntimeMismatch = false;
 526                     CFIndex i, count = CFArrayGetCount(archs);
 527                     SInt32 arch, curArch = _CFBundleCurrentArchitecture();
 528                     for (i = 0; !hasSuitableArch && i < count; i++) {
 529                         if (CFNumberGetValue((CFNumberRef)CFArrayGetValueAtIndex(archs, i), kCFNumberSInt32Type, (void *)&arch) && arch == curArch) hasSuitableArch = true;
 530                     }
 531 #if defined(BINARY_SUPPORT_DYLD)
 532                     if (hasSuitableArch) {
 533                         uint32_t mainFlags = 0;
 534                         if (_CFBundleGrokObjCImageInfoFromMainExecutable(NULL, &mainFlags) && (mainFlags & 0x2) != 0) {
 535 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
 536                             uint32_t bundleFlags = 0;
 537                             if (_CFBundleGetObjCImageInfo(bundle, NULL, &bundleFlags) && (bundleFlags & 0x2) == 0) hasRuntimeMismatch = true;
 538 #endif
 539                         }
 540                     }
 541 #endif /* BINARY_SUPPORT_DYLD */
 542                     if (hasRuntimeMismatch) {
 543                         localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableRuntimeMismatchError, debugString);
 544                     } else if (!hasSuitableArch) {
 545                         localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableArchitectureMismatchError, debugString);
 546                     } else {
 547                         localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLoadError, debugString);
 548                     }
 549                     CFRelease(archs);
 550                 } else {
 551                     localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLoadError, debugString);
 552                 }
 553                 if (debugString) CFRelease(debugString);
 554             }
 555         } else {
 556             if (error) localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);
 557         }
 558         if (executableURL) CFRelease(executableURL);
 559     }
 560     if (!retval && error) *error = localError;
 561     return retval;
 562 }
 563
 564 CF_PRIVATE Boolean _CFBundleDlfcnLoadBundle(CFBundleRef bundle, Boolean forceGlobal, CFErrorRef *error) {
 565     CFErrorRef localError = NULL, *subError = (error ? &localError : NULL);
 566     if (!bundle->_isLoaded) {
 567         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 568         char buff[CFMaxPathSize];
 569         if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {
 570             int mode = forceGlobal ? (RTLD_LAZY | RTLD_GLOBAL | RTLD_FIRST) : (RTLD_NOW | RTLD_LOCAL | RTLD_FIRST);
 571             void *cookie = dlopen(buff, mode);
 572 #if LOG_BUNDLE_LOAD
 573             printf("dlfcn load bundle %p, dlopen of %s mode 0x%x returns handle %p\n", bundle, buff, mode, cookie);
 574 #endif /* LOG_BUNDLE_LOAD */
 575             if (cookie && cookie == bundle->_handleCookie) {
 576                 // during the call to dlopen, arbitrary init routines may have run and caused bundle->_handleCookie to be set, in which case proper reference counting requires that reference to be released with dlclose
 577 #if LOG_BUNDLE_LOAD
 578                 printf("dlfcn load bundle %p closing existing reference to handle %p\n", bundle, cookie);
 579 #endif /* LOG_BUNDLE_LOAD */
 580                 dlclose(bundle->_handleCookie);
 581             }
 582             bundle->_handleCookie = cookie;
 583             if (bundle->_handleCookie) {
 584                 bundle->_isLoaded = true;
 585             } else {
 586                 const char *dyldError = dlerror();
 587                 CFStringRef errorString = dyldError ? CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, dyldError) : NULL;
 588                 if (error) {
 589                     _CFBundleDlfcnPreflight(bundle, subError);
 590                     if (!localError) localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, errorString);
 591                 } else {
 592                     CFStringRef executableString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, buff);
 593                     CFLog(__kCFLogBundle, CFSTR("Error loading %@:  %@"), executableString, errorString ? errorString : CFSTR("(no additional info)"));
 594                     if (executableString) CFRelease(executableString);
 595                 }
 596                 if (errorString) CFRelease(errorString);
 597             }
 598         } else {
 599             if (error) {
 600                 localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);
 601             } else {
 602                 CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);
 603             }
 604         }
 605         if (executableURL) CFRelease(executableURL);
 606     }
 607     if (!bundle->_isLoaded && error) *error = localError;
 608     return bundle->_isLoaded;
 609 }
 610
 611 CF_PRIVATE Boolean _CFBundleDlfcnLoadFramework(CFBundleRef bundle, CFErrorRef *error) {
 612     CFErrorRef localError = NULL, *subError = (error ? &localError : NULL);
 613     if (!bundle->_isLoaded) {
 614         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 615         char buff[CFMaxPathSize];
 616         if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {
 617             int mode = RTLD_LAZY | RTLD_GLOBAL | RTLD_FIRST;
 618             void *cookie = dlopen(buff, mode);
 619 #if LOG_BUNDLE_LOAD
 620             printf("dlfcn load framework %p, dlopen of %s mode 0x%x returns handle %p\n", bundle, buff, mode, cookie);
 621 #endif /* LOG_BUNDLE_LOAD */
 622             if (cookie && cookie == bundle->_handleCookie) {
 623                 // during the call to dlopen, arbitrary init routines may have run and caused bundle->_handleCookie to be set, in which case proper reference counting requires that reference to be released with dlclose
 624 #if LOG_BUNDLE_LOAD
 625                 printf("dlfcn load framework %p closing existing reference to handle %p\n", bundle, cookie);
 626 #endif /* LOG_BUNDLE_LOAD */
 627                 dlclose(bundle->_handleCookie);
 628             }
 629             bundle->_handleCookie = cookie;
 630             if (bundle->_handleCookie) {
 631                 bundle->_isLoaded = true;
 632             } else {
 633                 const char *dyldError = dlerror();
 634                 CFStringRef errorString = dyldError ? CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, dyldError) : NULL;
 635                 if (error) {
 636                     _CFBundleDlfcnPreflight(bundle, subError);
 637                     if (!localError) localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, errorString);
 638                 } else {
 639                     CFStringRef executableString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, buff);
 640                     CFLog(__kCFLogBundle, CFSTR("Error loading %@:  %@"), executableString, errorString ? errorString : CFSTR("(no additional info)"));
 641                 }
 642                 if (errorString) CFRelease(errorString);
 643             }
 644         } else {
 645             if (error) {
 646                 localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);
 647             } else {
 648                 CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);
 649             }
 650         }
 651         if (executableURL) CFRelease(executableURL);
 652     }
 653     if (!bundle->_isLoaded && error) *error = localError;
 654     return bundle->_isLoaded;
 655 }
 656
 657 CF_PRIVATE void _CFBundleDlfcnUnload(CFBundleRef bundle) {
 658     if (bundle->_isLoaded) {
 659 #if LOG_BUNDLE_LOAD
 660         printf("dlfcn unload bundle %p, handle %p module %p image %p\n", bundle, bundle->_handleCookie, bundle->_moduleCookie, bundle->_imageCookie);
 661 #endif /* LOG_BUNDLE_LOAD */
 662         if (0 != dlclose(bundle->_handleCookie)) {
 663             CFLog(__kCFLogBundle, CFSTR("Internal error unloading bundle %@"), bundle);
 664         } else {
 665             bundle->_connectionCookie = bundle->_handleCookie = NULL;
 666             bundle->_imageCookie = bundle->_moduleCookie = NULL;
 667             bundle->_isLoaded = false;
 668         }
 669     }
 670 }
 671
 672 CF_PRIVATE void *_CFBundleDlfcnGetSymbolByName(CFBundleRef bundle, CFStringRef symbolName) {
 673     return _CFBundleDlfcnGetSymbolByNameWithSearch(bundle, symbolName, false);
 674 }
 675
 676 static void *_CFBundleDlfcnGetSymbolByNameWithSearch(CFBundleRef bundle, CFStringRef symbolName, Boolean globalSearch) {
 677     void *result = NULL;
 678     char buff[1026];
 679
 680     if (CFStringGetCString(symbolName, buff, 1024, kCFStringEncodingUTF8)) {
 681         result = dlsym(bundle->_handleCookie, buff);
 682         if (!result && globalSearch) result = dlsym(RTLD_DEFAULT, buff);
 683 #if defined(DEBUG)
 684         if (!result) CFLog(__kCFLogBundle, CFSTR("dlsym cannot find symbol %@ in %@"), symbolName, bundle);
 685 #endif /* DEBUG */
 686 #if LOG_BUNDLE_LOAD
 687         printf("bundle %p handle %p module %p image %p dlsym returns symbol %p for %s\n", bundle, bundle->_handleCookie, bundle->_moduleCookie, bundle->_imageCookie, result, buff);
 688 #endif /* LOG_BUNDLE_LOAD */
 689     }
 690     return result;
 691 }
 692
 693 #if !defined(BINARY_SUPPORT_DYLD)
 694
 695 static CFStringRef _CFBundleDlfcnCopyLoadedImagePathForPointer(void *p) {
 696     CFStringRef result = NULL;
 697     Dl_info info;
 698     if (0 != dladdr(p, &info) && info.dli_fname) result = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, info.dli_fname);
 699 #if LOG_BUNDLE_LOAD
 700     printf("dlfcn image path for pointer %p is %p\n", p, result);
 701 #endif /* LOG_BUNDLE_LOAD */
 702     return result;
 703 }
 704
 705 #endif /* !BINARY_SUPPORT_DYLD */
 706 #endif /* BINARY_SUPPORT_DLFCN */
 707
 708 #if defined(BINARY_SUPPORT_DLL)
 709
 710 CF_PRIVATE Boolean _CFBundleDLLLoad(CFBundleRef bundle, CFErrorRef *error) {
 711     CFErrorRef localError = NULL;
 712     if (!bundle->_isLoaded) {
 713         CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
 714         wchar_t buff[CFMaxPathSize];
 715
 716         if (executableURL && _CFURLGetWideFileSystemRepresentation(executableURL, true, (wchar_t *)buff, CFMaxPathSize)) {
 717             bundle->_hModule = LoadLibraryW(buff);
 718             if (bundle->_hModule) {
 719                 bundle->_isLoaded = true;
 720             } else {
 721                 if (error) {
 722                     localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError);
 723                 } else {
 724                     CFLog(__kCFLogBundle, CFSTR("Failed to load bundle %@"), bundle);
 725                 }
 726             }
 727         } else {
 728             if (error) {
 729                 localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);
 730             } else {
 731                 CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);
 732             }
 733         }
 734         if (executableURL) CFRelease(executableURL);
 735     }
 736     if (!bundle->_isLoaded && error) *error = localError;
 737     return bundle->_isLoaded;
 738 }
 739
 740 CF_PRIVATE void _CFBundleDLLUnload(CFBundleRef bundle) {
 741     if (bundle->_isLoaded) {
 742        FreeLibrary(bundle->_hModule);
 743        bundle->_hModule = NULL;
 744        bundle->_isLoaded = false;
 745     }
 746 }
 747
 748 CF_PRIVATE void *_CFBundleDLLGetSymbolByName(CFBundleRef bundle, CFStringRef symbolName) {
 749     void *result = NULL;
 750     char buff[1024];
 751     if (CFStringGetCString(symbolName, buff, 1024, kCFStringEncodingWindowsLatin1)) result = GetProcAddress(bundle->_hModule, buff);
 752     return result;
 753 }
 754
 755 #endif /* BINARY_SUPPORT_DLL */
 756
 757 CF_PRIVATE CFStringRef _CFBundleCopyLoadedImagePathForPointer(void *p) {
 758     CFStringRef imagePath = NULL;
 759 #if defined(BINARY_SUPPORT_DYLD)
 760     if (!imagePath) imagePath = _CFBundleDYLDCopyLoadedImagePathForPointer(p);
 761 #elif defined(BINARY_SUPPORT_DLFCN)
 762     if (!imagePath) imagePath = _CFBundleDlfcnCopyLoadedImagePathForPointer(p);
 763 #endif /* BINARY_SUPPORT_DYLD */
 764     return imagePath;
 765 }
 766
 767 void *CFBundleGetFunctionPointerForName(CFBundleRef bundle, CFStringRef funcName) {
 768     void *tvp = NULL;
 769     // Load if necessary
 770     if (!bundle->_isLoaded) {
 771         if (!CFBundleLoadExecutable(bundle)) return NULL;
 772     }
 773
 774     switch (bundle->_binaryType) {
 775 #if defined(BINARY_SUPPORT_DYLD)
 776         case __CFBundleDYLDBundleBinary:
 777         case __CFBundleDYLDFrameworkBinary:
 778         case __CFBundleDYLDExecutableBinary:
 779 #if defined(BINARY_SUPPORT_DLFCN)
 780             if (bundle->_handleCookie) return _CFBundleDlfcnGetSymbolByName(bundle, funcName);
 781 #else /* BINARY_SUPPORT_DLFCN */
 782             return _CFBundleDYLDGetSymbolByName(bundle, funcName);
 783 #endif /* BINARY_SUPPORT_DLFCN */
 784             break;
 785 #endif /* BINARY_SUPPORT_DYLD */
 786 #if defined(BINARY_SUPPORT_DLL)
 787         case __CFBundleDLLBinary:
 788             tvp = _CFBundleDLLGetSymbolByName(bundle, funcName);
 789             break;
 790 #endif /* BINARY_SUPPORT_DLL */
 791         default:
 792 #if defined(BINARY_SUPPORT_DLFCN)
 793             if (bundle->_handleCookie) return _CFBundleDlfcnGetSymbolByName(bundle, funcName);
 794 #endif /* BINARY_SUPPORT_DLFCN */
 795             break;
 796     }
 797     return tvp;
 798 }
 799
 800 void *_CFBundleGetCFMFunctionPointerForName(CFBundleRef bundle, CFStringRef funcName) {
 801     void *fp = NULL;
 802     // Load if necessary
 803     if (!bundle->_isLoaded) {
 804         if (!CFBundleLoadExecutable(bundle)) return NULL;
 805     }
 806 #if defined (BINARY_SUPPORT_DYLD) || defined (BINARY_SUPPORT_DLFCN)
 807     switch (bundle->_binaryType) {
 808 #if defined(BINARY_SUPPORT_DYLD)
 809         case __CFBundleDYLDBundleBinary:
 810         case __CFBundleDYLDFrameworkBinary:
 811         case __CFBundleDYLDExecutableBinary:
 812 #if defined(BINARY_SUPPORT_DLFCN)
 813             if (bundle->_handleCookie) fp = _CFBundleDlfcnGetSymbolByNameWithSearch(bundle, funcName, true);
 814 #else /* BINARY_SUPPORT_DLFCN */
 815             fp = _CFBundleDYLDGetSymbolByNameWithSearch(bundle, funcName, true);
 816 #endif /* BINARY_SUPPORT_DLFCN */
 817             break;
 818 #endif /* BINARY_SUPPORT_DYLD */
 819         default:
 820 #if defined(BINARY_SUPPORT_DLFCN)
 821             if (bundle->_handleCookie) fp = _CFBundleDlfcnGetSymbolByNameWithSearch(bundle, funcName, true);
 822 #endif /* BINARY_SUPPORT_DLFCN */
 823             break;
 824     }
 825 #endif /* BINARY_SUPPORT_DYLD || BINARY_SUPPORT_DLFCN */
 826     return fp;
 827 }
 828
 829 void CFBundleGetFunctionPointersForNames(CFBundleRef bundle, CFArrayRef functionNames, void *ftbl[]) {
 830     SInt32 i, c;
 831
 832     if (!ftbl) return;
 833
 834     c = CFArrayGetCount(functionNames);
 835     for (i = 0; i < c; i++) ftbl[i] = CFBundleGetFunctionPointerForName(bundle, (CFStringRef)CFArrayGetValueAtIndex(functionNames, i));
 836 }
 837
 838 void _CFBundleGetCFMFunctionPointersForNames(CFBundleRef bundle, CFArrayRef functionNames, void *ftbl[]) {
 839     SInt32 i, c;
 840
 841     if (!ftbl) return;
 842
 843     c = CFArrayGetCount(functionNames);
 844     for (i = 0; i < c; i++) ftbl[i] = _CFBundleGetCFMFunctionPointerForName(bundle, (CFStringRef)CFArrayGetValueAtIndex(functionNames, i));
 845 }
 846
 847 void *CFBundleGetDataPointerForName(CFBundleRef bundle, CFStringRef symbolName) {
 848     void *dp = NULL;
 849     // Load if necessary
 850     if (!bundle->_isLoaded && !CFBundleLoadExecutable(bundle)) return NULL;
 851
 852     switch (bundle->_binaryType) {
 853 #if defined(BINARY_SUPPORT_DYLD)
 854         case __CFBundleDYLDBundleBinary:
 855         case __CFBundleDYLDFrameworkBinary:
 856         case __CFBundleDYLDExecutableBinary:
 857 #if defined(BINARY_SUPPORT_DLFCN)
 858             if (bundle->_handleCookie) dp = _CFBundleDlfcnGetSymbolByName(bundle, symbolName);
 859 #else /* BINARY_SUPPORT_DLFCN */
 860             dp = _CFBundleDYLDGetSymbolByName(bundle, symbolName);
 861 #endif /* BINARY_SUPPORT_DLFCN */
 862             break;
 863 #endif /* BINARY_SUPPORT_DYLD */
 864 #if defined(BINARY_SUPPORT_DLL)
 865         case __CFBundleDLLBinary:
 866             /* MF:!!! Handle this someday */
 867             break;
 868 #endif /* BINARY_SUPPORT_DLL */
 869         default:
 870 #if defined(BINARY_SUPPORT_DLFCN)
 871             if (bundle->_handleCookie) dp = _CFBundleDlfcnGetSymbolByName(bundle, symbolName);
 872 #endif /* BINARY_SUPPORT_DLFCN */
 873             break;
 874     }
 875     return dp;
 876 }
 877
 878 void CFBundleGetDataPointersForNames(CFBundleRef bundle, CFArrayRef symbolNames, void *stbl[]) {
 879     SInt32 i, c;
 880
 881     if (!stbl) return;
 882
 883     c = CFArrayGetCount(symbolNames);
 884     for (i = 0; i < c; i++) stbl[i] = CFBundleGetDataPointerForName(bundle, (CFStringRef)CFArrayGetValueAtIndex(symbolNames, i));
 885 }
 886