/*
* Copyright (c) 2007 Apple Inc. All Rights Reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/***********************************************************************
* objc-os.m
* OS portability layer.
**********************************************************************/
#include "objc-os.h"
#include "objc-private.h"
#include "objc-loadmethod.h"
#if TARGET_OS_WIN32
#include "objc-runtime-old.h"
#include "objcrt.h"
malloc_zone_t *_objc_internal_zone(void)
{
return NULL;
}
int monitor_init(monitor_t *c)
{
// fixme error checking
HANDLE mutex = CreateMutex(NULL, TRUE, NULL);
while (!c->mutex) {
// fixme memory barrier here?
if (0 == InterlockedCompareExchangePointer(&c->mutex, mutex, 0)) {
// we win - finish construction
c->waiters = CreateSemaphore(NULL, 0, 0x7fffffff, NULL);
c->waitersDone = CreateEvent(NULL, FALSE, FALSE, NULL);
InitializeCriticalSection(&c->waitCountLock);
c->waitCount = 0;
c->didBroadcast = 0;
ReleaseMutex(c->mutex);
return 0;
}
}
// someone else allocated the mutex and constructed the monitor
ReleaseMutex(mutex);
CloseHandle(mutex);
return 0;
}
void mutex_init(mutex_t *m)
{
while (!m->lock) {
CRITICAL_SECTION *newlock = malloc(sizeof(CRITICAL_SECTION));
InitializeCriticalSection(newlock);
// fixme memory barrier here?
if (0 == InterlockedCompareExchangePointer(&m->lock, newlock, 0)) {
return;
}
// someone else installed their lock first
DeleteCriticalSection(newlock);
free(newlock);
}
}
void recursive_mutex_init(recursive_mutex_t *m)
{
// fixme error checking
HANDLE newmutex = CreateMutex(NULL, FALSE, NULL);
while (!m->mutex) {
// fixme memory barrier here?
if (0 == InterlockedCompareExchangePointer(&m->mutex, newmutex, 0)) {
// we win
return;
}
}
// someone else installed their lock first
CloseHandle(newmutex);
}
WINBOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
environ_init();
tls_init();
lock_init();
sel_init(NO, 3500); // old selector heuristic
exception_init();
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
OBJC_EXPORT void *_objc_init_image(HMODULE image, const objc_sections *sects)
{
header_info *hi = _malloc_internal(sizeof(header_info));
size_t count, i;
hi->mhdr = (const headerType *)image;
hi->info = sects->iiStart;
hi->allClassesRealized = NO;
hi->modules = sects->modStart ? (Module *)((void **)sects->modStart+1) : 0;
hi->moduleCount = (Module *)sects->modEnd - hi->modules;
hi->protocols = sects->protoStart ? (struct old_protocol **)((void **)sects->protoStart+1) : 0;
hi->protocolCount = (struct old_protocol **)sects->protoEnd - hi->protocols;
hi->imageinfo = NULL;
hi->imageinfoBytes = 0;
// hi->imageinfo = sects->iiStart ? (uint8_t *)((void **)sects->iiStart+1) : 0;;
// hi->imageinfoBytes = (uint8_t *)sects->iiEnd - hi->imageinfo;
hi->selrefs = sects->selrefsStart ? (SEL *)((void **)sects->selrefsStart+1) : 0;
hi->selrefCount = (SEL *)sects->selrefsEnd - hi->selrefs;
hi->clsrefs = sects->clsrefsStart ? (Class *)((void **)sects->clsrefsStart+1) : 0;
hi->clsrefCount = (Class *)sects->clsrefsEnd - hi->clsrefs;
count = 0;
for (i = 0; i < hi->moduleCount; i++) {
if (hi->modules[i]) count++;
}
hi->mod_count = 0;
hi->mod_ptr = 0;
if (count > 0) {
hi->mod_ptr = malloc(count * sizeof(struct objc_module));
for (i = 0; i < hi->moduleCount; i++) {
if (hi->modules[i]) memcpy(&hi->mod_ptr[hi->mod_count++], hi->modules[i], sizeof(struct objc_module));
}
}
hi->moduleName = malloc(MAX_PATH * sizeof(TCHAR));
GetModuleFileName((HMODULE)(hi->mhdr), hi->moduleName, MAX_PATH * sizeof(TCHAR));
appendHeader(hi);
if (PrintImages) {
_objc_inform("IMAGES: loading image for %s%s%s\n",
hi->fname,
headerIsBundle(hi) ? " (bundle)" : "",
_objcHeaderIsReplacement(hi) ? " (replacement)":"");
}
_read_images(&hi, 1);
return hi;
}
OBJC_EXPORT void _objc_load_image(HMODULE image, header_info *hinfo)
{
prepare_load_methods(hinfo);
call_load_methods();
}
OBJC_EXPORT void _objc_unload_image(HMODULE image, header_info *hinfo)
{
_objc_fatal("image unload not supported");
}
bool crashlog_header_name(header_info *hi)
{
return true;
}
// TARGET_OS_WIN32
#elif TARGET_OS_MAC
#if !__OBJC2__
#include "objc-file-old.h"
#endif
void mutex_init(mutex_t *m)
{
pthread_mutex_init(m, NULL);
}
void recursive_mutex_init(recursive_mutex_t *m)
{
// fixme error checking
pthread_mutex_t *newmutex;
// Build recursive mutex attributes, if needed
static pthread_mutexattr_t *attr;
if (!attr) {
pthread_mutexattr_t *newattr = (pthread_mutexattr_t *)
_malloc_internal(sizeof(pthread_mutexattr_t));
pthread_mutexattr_init(newattr);
pthread_mutexattr_settype(newattr, PTHREAD_MUTEX_RECURSIVE);
while (!attr) {
if (OSAtomicCompareAndSwapPtrBarrier(0, newattr, (void**)&attr)) {
// we win
goto attr_done;
}
}
// someone else built the attr first
_free_internal(newattr);
}
attr_done:
// Build the mutex itself
newmutex = (pthread_mutex_t *)_malloc_internal(sizeof(pthread_mutex_t));
pthread_mutex_init(newmutex, attr);
while (!m->mutex) {
if (OSAtomicCompareAndSwapPtrBarrier(0, newmutex, (void**)&m->mutex)) {
// we win
return;
}
}
// someone else installed their mutex first
pthread_mutex_destroy(newmutex);
}
/***********************************************************************
* bad_magic.
* Return YES if the header has invalid Mach-o magic.
**********************************************************************/
BOOL bad_magic(const headerType *mhdr)
{
return (mhdr->magic != MH_MAGIC && mhdr->magic != MH_MAGIC_64 &&
mhdr->magic != MH_CIGAM && mhdr->magic != MH_CIGAM_64);
}
static header_info * addHeader(const headerType *mhdr)
{
header_info *hi;
if (bad_magic(mhdr)) return NULL;
#if __OBJC2__
// Look for hinfo from the dyld shared cache.
hi = preoptimizedHinfoForHeader(mhdr);
if (hi) {
// Found an hinfo in the dyld shared cache.
// Weed out duplicates.
if (hi->loaded) {
return NULL;
}
// Initialize fields not set by the shared cache
// hi->next is set by appendHeader
hi->fname = dyld_image_path_containing_address(hi->mhdr);
hi->loaded = true;
hi->inSharedCache = true;
if (PrintPreopt) {
_objc_inform("PREOPTIMIZATION: honoring preoptimized header info at %p for %s", hi, hi->fname);
}
# if !NDEBUG
// Verify image_info
size_t info_size = 0;
const objc_image_info *image_info = _getObjcImageInfo(mhdr,&info_size);
assert(image_info == hi->info);
# endif
}
else
#endif
{
// Didn't find an hinfo in the dyld shared cache.
// Weed out duplicates
for (hi = FirstHeader; hi; hi = hi->next) {
if (mhdr == hi->mhdr) return NULL;
}
// Locate the __OBJC segment
size_t info_size = 0;
unsigned long seg_size;
const objc_image_info *image_info = _getObjcImageInfo(mhdr,&info_size);
const uint8_t *objc_segment = getsegmentdata(mhdr,SEG_OBJC,&seg_size);
if (!objc_segment && !image_info) return NULL;
// Allocate a header_info entry.
hi = (header_info *)_calloc_internal(sizeof(header_info), 1);
// Set up the new header_info entry.
hi->mhdr = mhdr;
#if !__OBJC2__
// mhdr must already be set
hi->mod_count = 0;
hi->mod_ptr = _getObjcModules(hi, &hi->mod_count);
#endif
hi->info = image_info;
hi->fname = dyld_image_path_containing_address(hi->mhdr);
hi->loaded = true;
hi->inSharedCache = false;
hi->allClassesRealized = NO;
}
// dylibs are not allowed to unload
// ...except those with image_info and nothing else (5359412)
if (hi->mhdr->filetype == MH_DYLIB && _hasObjcContents(hi)) {
dlopen(hi->fname, RTLD_NOLOAD);
}
appendHeader(hi);
return hi;
}
#if !SUPPORT_GC
const char *_gcForHInfo(const header_info *hinfo)
{
return "";
}
const char *_gcForHInfo2(const header_info *hinfo)
{
return "";
}
#else
/***********************************************************************
* _gcForHInfo.
**********************************************************************/
const char *_gcForHInfo(const header_info *hinfo)
{
if (_objcHeaderRequiresGC(hinfo)) {
if (_objcHeaderSupportsCompaction(hinfo))
return "requires GC, supports compaction";
else
return "requires GC";
} else if (_objcHeaderSupportsGC(hinfo)) {
if (_objcHeaderSupportsCompaction(hinfo))
return "supports GC, supports compaction";
else
return "supports GC";
} else {
return "does not support GC";
}
}
const char *_gcForHInfo2(const header_info *hinfo)
{
if (_objcHeaderRequiresGC(hinfo)) {
if (_objcHeaderSupportsCompaction(hinfo))
return "(requires GC) (supports compaction)";
else
return "(requires GC)";
} else if (_objcHeaderSupportsGC(hinfo)) {
if (_objcHeaderSupportsCompaction(hinfo))
return "(supports GC) (supports compaction)";
else
return "(supports GC)";
}
return "";
}
/***********************************************************************
* check_gc
* Check whether the executable supports or requires GC, and make sure
* all already-loaded libraries support the executable's GC mode.
* Returns TRUE if the executable wants GC on.
**********************************************************************/
static void check_wants_gc(BOOL *appWantsGC, BOOL *appSupportsCompaction)
{
const header_info *hi;
// Environment variables can override the following.
if (DisableGC) {
_objc_inform_on_crash("GC: forcing GC OFF because OBJC_DISABLE_GC is set");
*appWantsGC = NO;
*appSupportsCompaction = NO;
}
else {
// Find the executable and check its GC bits.
// If the executable cannot be found, default to NO.
// (The executable will not be found if the executable contains
// no Objective-C code.)
*appWantsGC = NO;
*appSupportsCompaction = NO;
for (hi = FirstHeader; hi != NULL; hi = hi->next) {
if (hi->mhdr->filetype == MH_EXECUTE) {
*appWantsGC = _objcHeaderSupportsGC(hi) ? YES : NO;
*appSupportsCompaction = (*appWantsGC && _objcHeaderSupportsCompaction(hi)) ? YES : NO;
if (PrintGC) {
_objc_inform("GC: executable '%s' %s",
hi->fname, _gcForHInfo(hi));
}
}
}
}
}
/***********************************************************************
* verify_gc_readiness
* if we want gc, verify that every header describes files compiled
* and presumably ready for gc.
************************************************************************/
static void verify_gc_readiness(BOOL wantsGC, BOOL *wantsCompaction,
header_info **hList, uint32_t hCount)
{
BOOL busted = NO;
uint32_t i;
// Find the libraries and check their GC bits against the app's request
for (i = 0; i < hCount; i++) {
header_info *hi = hList[i];
if (hi->mhdr->filetype == MH_EXECUTE) {
continue;
}
else if (hi->mhdr == &_mh_dylib_header) {
// libobjc itself works with anything even though it is not
// compiled with -fobjc-gc (fixme should it be?)
}
else if (wantsGC && ! _objcHeaderSupportsGC(hi)) {
// App wants GC but library does not support it - bad
_objc_inform_now_and_on_crash
("'%s' was not compiled with -fobjc-gc or -fobjc-gc-only, "
"but the application requires GC",
hi->fname);
busted = YES;
}
else if (!wantsGC && _objcHeaderRequiresGC(hi)) {
// App doesn't want GC but library requires it - bad
_objc_inform_now_and_on_crash
("'%s' was compiled with -fobjc-gc-only, "
"but the application does not support GC",
hi->fname);
busted = YES;
}
if (*wantsCompaction && !_objcHeaderSupportsCompaction(hi)) {
// App supports compaction, but library doesn't.
_objc_inform_now_and_on_crash
("'%s' was not linked with -Xlinker -objc_gc_compaction, "
"but the application wants compaction.",
hi->fname);
// Simply warn for now until radars are filed. Eventually,
// objc_disableCompaction() will block until any current compaction completes.
objc_disableCompaction();
*wantsCompaction = NO;
}
if (PrintGC) {
_objc_inform("GC: library '%s' %s",
hi->fname, _gcForHInfo(hi));
}
}
if (busted) {
// GC state is not consistent.
// Kill the process unless one of the forcing flags is set.
if (!DisableGC) {
_objc_fatal("*** GC capability of application and some libraries did not match");
}
}
}
/***********************************************************************
* gc_enforcer
* Make sure that images about to be loaded by dyld are GC-acceptable.
* Images linked to the executable are always permitted; they are
* enforced inside map_images() itself.
**********************************************************************/
static BOOL InitialDyldRegistration = NO;
static const char *gc_enforcer(enum dyld_image_states state,
uint32_t infoCount,
const struct dyld_image_info info[])
{
uint32_t i;
// Linked images get a free pass
if (InitialDyldRegistration) return NULL;
if (PrintImages) {
_objc_inform("IMAGES: checking %d images for compatibility...",
infoCount);
}
for (i = 0; i < infoCount; i++) {
crashlog_header_name_string(info[i].imageFilePath);
const headerType *mhdr = (const headerType *)info[i].imageLoadAddress;
if (bad_magic(mhdr)) continue;
objc_image_info *image_info;
size_t size;
if (mhdr == &_mh_dylib_header) {
// libobjc itself - OK
continue;
}
#if !__OBJC2__
unsigned long seg_size;
// 32-bit: __OBJC seg but no image_info means no GC support
if (!getsegmentdata(mhdr, "__OBJC", &seg_size)) {
// not objc - assume OK
continue;
}
image_info = _getObjcImageInfo(mhdr, &size);
if (!image_info) {
// No image_info - assume GC unsupported
if (!UseGC) {
// GC is OFF - ok
continue;
} else {
// GC is ON - bad
if (PrintImages || PrintGC) {
_objc_inform("IMAGES: rejecting %d images because %s doesn't support GC (no image_info)", infoCount, info[i].imageFilePath);
}
goto reject;
}
}
#else
// 64-bit: no image_info means no objc at all
image_info = _getObjcImageInfo(mhdr, &size);
if (!image_info) {
// not objc - assume OK
continue;
}
#endif
if (UseGC && !_objcInfoSupportsGC(image_info)) {
// GC is ON, but image does not support GC
if (PrintImages || PrintGC) {
_objc_inform("IMAGES: rejecting %d images because %s doesn't support GC", infoCount, info[i].imageFilePath);
}
goto reject;
}
if (!UseGC && _objcInfoRequiresGC(image_info)) {
// GC is OFF, but image requires GC
if (PrintImages || PrintGC) {
_objc_inform("IMAGES: rejecting %d images because %s requires GC", infoCount, info[i].imageFilePath);
}
goto reject;
}
}
crashlog_header_name_string(NULL);
return NULL;
reject:
crashlog_header_name_string(NULL);
return "GC capability mismatch";
}
// SUPPORT_GC
#endif
/***********************************************************************
* map_images_nolock
* Process the given images which are being mapped in by dyld.
* All class registration and fixups are performed (or deferred pending
* discovery of missing superclasses etc), and +load methods are called.
*
* info[] is in bottom-up order i.e. libobjc will be earlier in the
* array than any library that links to libobjc.
*
* Locking: loadMethodLock(old) or runtimeLock(new) acquired by map_images.
**********************************************************************/
#if __OBJC2__
#include "objc-file.h"
#else
#include "objc-file-old.h"
#endif
const char *
map_images_nolock(enum dyld_image_states state, uint32_t infoCount,
const struct dyld_image_info infoList[])
{
static BOOL firstTime = YES;
static BOOL wantsGC = NO;
static BOOL wantsCompaction = NO;
uint32_t i;
header_info *hi;
header_info *hList[infoCount];
uint32_t hCount;
size_t selrefCount = 0;
// Perform first-time initialization if necessary.
// This function is called before ordinary library initializers.
// fixme defer initialization until an objc-using image is found?
if (firstTime) {
preopt_init();
#if SUPPORT_GC
InitialDyldRegistration = YES;
dyld_register_image_state_change_handler(dyld_image_state_mapped, 0 /* batch */, &gc_enforcer);
InitialDyldRegistration = NO;
#endif
}
if (PrintImages) {
_objc_inform("IMAGES: processing %u newly-mapped images...\n", infoCount);
}
// Find all images with Objective-C metadata.
hCount = 0;
i = infoCount;
while (i--) {
const headerType *mhdr = (headerType *)infoList[i].imageLoadAddress;
hi = addHeader(mhdr);
if (!hi) {
// no objc data in this entry
continue;
}
if (mhdr->filetype == MH_EXECUTE) {
#if __OBJC2__
size_t count;
_getObjc2SelectorRefs(hi, &count);
selrefCount += count;
_getObjc2MessageRefs(hi, &count);
selrefCount += count;
#else
_getObjcSelectorRefs(hi, &selrefCount);
#endif
}
hList[hCount++] = hi;
if (PrintImages) {
_objc_inform("IMAGES: loading image for %s%s%s%s%s\n",
hi->fname,
mhdr->filetype == MH_BUNDLE ? " (bundle)" : "",
_objcHeaderIsReplacement(hi) ? " (replacement)" : "",
_objcHeaderOptimizedByDyld(hi)?" (preoptimized)" : "",
_gcForHInfo2(hi));
}
}
// Perform one-time runtime initialization that must be deferred until
// the executable itself is found. This needs to be done before
// further initialization.
// (The executable may not be present in this infoList if the
// executable does not contain Objective-C code but Objective-C
// is dynamically loaded later. In that case, check_wants_gc()
// will do the right thing.)
#if SUPPORT_GC
if (firstTime) {
check_wants_gc(&wantsGC, &wantsCompaction);
verify_gc_readiness(wantsGC, &wantsCompaction, hList, hCount);
gc_init(wantsGC, wantsCompaction); // needs executable for GC decision
rtp_init(); // needs GC decision first
} else {
verify_gc_readiness(wantsGC, &wantsCompaction, hList, hCount);
}
if (wantsGC) {
// tell the collector about the data segment ranges.
for (i = 0; i < hCount; ++i) {
uint8_t *seg;
unsigned long seg_size;
hi = hList[i];
seg = getsegmentdata(hi->mhdr, "__DATA", &seg_size);
if (seg) gc_register_datasegment((uintptr_t)seg, seg_size);
seg = getsegmentdata(hi->mhdr, "__OBJC", &seg_size);
if (seg) gc_register_datasegment((uintptr_t)seg, seg_size);
// __OBJC contains no GC data, but pointers to it are
// used as associated reference values (rdar://6953570)
}
}
// Need to fixup barriers in all libraries that call into libobjc, whether GC is on or not.
for (i = 0; i < infoCount; ++i) {
gc_fixup_barrier_stubs(&infoList[i]);
}
#endif
if (firstTime) {
extern SEL FwdSel; // in objc-msg-*.s
sel_init(wantsGC, selrefCount);
FwdSel = sel_registerName("forward::");
arr_init();
}
_read_images(hList, hCount);
firstTime = NO;
return NULL;
}
/***********************************************************************
* load_images_nolock
* Prepares +load in the given images which are being mapped in by dyld.
* Returns YES if there are now +load methods to be called by call_load_methods.
*
* Locking: loadMethodLock(both) and runtimeLock(new) acquired by load_images
**********************************************************************/
BOOL
load_images_nolock(enum dyld_image_states state,uint32_t infoCount,
const struct dyld_image_info infoList[])
{
BOOL found = NO;
uint32_t i;
i = infoCount;
while (i--) {
header_info *hi;
for (hi = FirstHeader; hi != NULL; hi = hi->next) {
const headerType *mhdr = (headerType*)infoList[i].imageLoadAddress;
if (hi->mhdr == mhdr) {
prepare_load_methods(hi);
found = YES;
}
}
}
return found;
}
/***********************************************************************
* unmap_image_nolock
* Process the given image which is about to be unmapped by dyld.
* mh is mach_header instead of headerType because that's what
* dyld_priv.h says even for 64-bit.
*
* Locking: loadMethodLock(both) and runtimeLock(new) acquired by unmap_image.
**********************************************************************/
void
unmap_image_nolock(const struct mach_header *mh)
{
if (PrintImages) {
_objc_inform("IMAGES: processing 1 newly-unmapped image...\n");
}
header_info *hi;
// Find the runtime's header_info struct for the image
for (hi = FirstHeader; hi != NULL; hi = hi->next) {
if (hi->mhdr == (const headerType *)mh) {
break;
}
}
if (!hi) return;
if (PrintImages) {
_objc_inform("IMAGES: unloading image for %s%s%s%s\n",
hi->fname,
hi->mhdr->filetype == MH_BUNDLE ? " (bundle)" : "",
_objcHeaderIsReplacement(hi) ? " (replacement)" : "",
_gcForHInfo2(hi));
}
#if SUPPORT_GC
if (UseGC) {
uint8_t *seg;
unsigned long seg_size;
seg = getsegmentdata(hi->mhdr, "__DATA", &seg_size);
if (seg) gc_unregister_datasegment((uintptr_t)seg, seg_size);
seg = getsegmentdata(hi->mhdr, "__OBJC", &seg_size);
if (seg) gc_unregister_datasegment((uintptr_t)seg, seg_size);
}
#endif
_unload_image(hi);
// Remove header_info from header list
removeHeader(hi);
_free_internal(hi);
}
/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Old ABI: called by dyld as a library initializer
* New ABI: called by libSystem BEFORE library initialization time
**********************************************************************/
#if !__OBJC2__
static __attribute__((constructor))
#endif
void _objc_init(void)
{
static bool initialized = false;
if (initialized) return;
initialized = true;
// fixme defer initialization until an objc-using image is found?
environ_init();
tls_init();
lock_init();
exception_init();
// Register for unmap first, in case some +load unmaps something
_dyld_register_func_for_remove_image(&unmap_image);
dyld_register_image_state_change_handler(dyld_image_state_bound,
1/*batch*/, &map_images);
dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
}
/***********************************************************************
* _headerForAddress.
* addr can be a class or a category
**********************************************************************/
static const header_info *_headerForAddress(void *addr)
{
#if __OBJC2__
const char *segname = "__DATA";
#else
const char *segname = "__OBJC";
#endif
header_info *hi;
// Check all headers in the vector
for (hi = FirstHeader; hi != NULL; hi = hi->next)
{
uint8_t *seg;
unsigned long seg_size;
seg = getsegmentdata(hi->mhdr, segname, &seg_size);
if (!seg) continue;
// Is the class in this header?
if ((uint8_t *)addr >= seg && (uint8_t *)addr < seg + seg_size)
return hi;
}
// Not found
return 0;
}
/***********************************************************************
* _headerForClass
* Return the image header containing this class, or NULL.
* Returns NULL on runtime-constructed classes, and the NSCF classes.
**********************************************************************/
const header_info *_headerForClass(Class cls)
{
return _headerForAddress(cls);
}
/**********************************************************************
* secure_open
* Securely open a file from a world-writable directory (like /tmp)
* If the file does not exist, it will be atomically created with mode 0600
* If the file exists, it must be, and remain after opening:
* 1. a regular file (in particular, not a symlink)
* 2. owned by euid
* 3. permissions 0600
* 4. link count == 1
* Returns a file descriptor or -1. Errno may or may not be set on error.
**********************************************************************/
int secure_open(const char *filename, int flags, uid_t euid)
{
struct stat fs, ls;
int fd = -1;
BOOL truncate = NO;
BOOL create = NO;
if (flags & O_TRUNC) {
// Don't truncate the file until after it is open and verified.
truncate = YES;
flags &= ~O_TRUNC;
}
if (flags & O_CREAT) {
// Don't create except when we're ready for it
create = YES;
flags &= ~O_CREAT;
flags &= ~O_EXCL;
}
if (lstat(filename, &ls) < 0) {
if (errno == ENOENT && create) {
// No such file - create it
fd = open(filename, flags | O_CREAT | O_EXCL, 0600);
if (fd >= 0) {
// File was created successfully.
// New file does not need to be truncated.
return fd;
} else {
// File creation failed.
return -1;
}
} else {
// lstat failed, or user doesn't want to create the file
return -1;
}
} else {
// lstat succeeded - verify attributes and open
if (S_ISREG(ls.st_mode) && // regular file?
ls.st_nlink == 1 && // link count == 1?
ls.st_uid == euid && // owned by euid?
(ls.st_mode & ALLPERMS) == (S_IRUSR | S_IWUSR)) // mode 0600?
{
// Attributes look ok - open it and check attributes again
fd = open(filename, flags, 0000);
if (fd >= 0) {
// File is open - double-check attributes
if (0 == fstat(fd, &fs) &&
fs.st_nlink == ls.st_nlink && // link count == 1?
fs.st_uid == ls.st_uid && // owned by euid?
fs.st_mode == ls.st_mode && // regular file, 0600?
fs.st_ino == ls.st_ino && // same inode as before?
fs.st_dev == ls.st_dev) // same device as before?
{
// File is open and OK
if (truncate) ftruncate(fd, 0);
return fd;
} else {
// Opened file looks funny - close it
close(fd);
return -1;
}
} else {
// File didn't open
return -1;
}
} else {
// Unopened file looks funny - don't open it
return -1;
}
}
}
/***********************************************************************
* _objc_internal_zone.
* Malloc zone for internal runtime data.
* By default this is the default malloc zone, but a dedicated zone is
* used if environment variable OBJC_USE_INTERNAL_ZONE is set.
**********************************************************************/
malloc_zone_t *_objc_internal_zone(void)
{
static malloc_zone_t *z = (malloc_zone_t *)-1;
if (z == (malloc_zone_t *)-1) {
if (UseInternalZone) {
z = malloc_create_zone(vm_page_size, 0);
malloc_set_zone_name(z, "ObjC");
} else {
z = malloc_default_zone();
}
}
return z;
}
bool crashlog_header_name(header_info *hi)
{
return crashlog_header_name_string(hi ? hi->fname : NULL);
}
bool crashlog_header_name_string(const char *name)
{
CRSetCrashLogMessage2(name);
return true;
}
#if TARGET_OS_IPHONE
const char *__crashreporter_info__ = NULL;
const char *CRSetCrashLogMessage(const char *msg)
{
__crashreporter_info__ = msg;
return msg;
}
const char *CRGetCrashLogMessage(void)
{
return __crashreporter_info__;
}
const char *CRSetCrashLogMessage2(const char *msg)
{
// sorry
return msg;
}
#endif
// TARGET_OS_MAC
#else
#error unknown OS
#endif