#include <CoreFoundation/CFRunLoop.h>

#include <CoreFoundation/CFSet.h>

#include <CoreFoundation/CFBag.h>

#include <CoreFoundation/CFNumber.h>

#include <CoreFoundation/CFPreferences.h>

#include "CFInternal.h"

#include <math.h>

#include <stdio.h>

#include <limits.h>

#include <pthread.h>

#include <dispatch/dispatch.h>

#if DEPLOYMENT_TARGET_WINDOWS

#include <typeinfo.h>

#include <checkint.h>

#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI

#include <sys/param.h>

#include <dispatch/private.h>

#include <CoreFoundation/CFUserNotification.h>

#include <mach/mach.h>

#include <mach/clock_types.h>

#include <mach/clock.h>

#include <unistd.h>

#include <dlfcn.h>

#include <pthread/private.h>

#include <os/voucher_private.h>

extern mach_port_t _dispatch_get_main_queue_port_4CF(void);

extern void _dispatch_main_queue_callback_4CF(mach_msg_header_t *msg);

#elif DEPLOYMENT_TARGET_WINDOWS

#include <process.h>

DISPATCH_EXPORT HANDLE _dispatch_get_main_queue_handle_4CF(void);

DISPATCH_EXPORT void _dispatch_main_queue_callback_4CF(void);

#define MACH_PORT_NULL 0

#define mach_port_name_t HANDLE

#define mach_port_t HANDLE

#define _dispatch_get_main_queue_port_4CF _dispatch_get_main_queue_handle_4CF

#define _dispatch_main_queue_callback_4CF(x) _dispatch_main_queue_callback_4CF()

#define AbsoluteTime LARGE_INTEGER

#if DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_IPHONESIMULATOR

CF_EXPORT pthread_t _CF_pthread_main_thread_np(void);

#define pthread_main_thread_np() _CF_pthread_main_thread_np()

#include <Block.h>

#include <Block_private.h>

#if DEPLOYMENT_TARGET_MACOSX

#define USE_DISPATCH_SOURCE_FOR_TIMERS 1

#define USE_MK_TIMER_TOO 1

#define USE_DISPATCH_SOURCE_FOR_TIMERS 0

#define USE_MK_TIMER_TOO 1

static int _LogCFRunLoop = 0;

static void _runLoopTimerWithBlockContext(CFRunLoopTimerRef timer, void *opaqueBlock);

#define TIMER_DATE_LIMIT 4039289856.0

#define TIMER_INTERVAL_LIMIT 504911232.0

#define HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY 0

#define CRASH(string, errcode) do { char msg[256]; snprintf(msg, 256, string, errcode); CRSetCrashLogMessage(msg); HALT; } while (0)

#if DEPLOYMENT_TARGET_WINDOWS

static pthread_t kNilPthreadT = { nil, nil };

#define pthreadPointer(a) a.p

typedef int kern_return_t;

#define KERN_SUCCESS 0

static pthread_t kNilPthreadT = (pthread_t)0;

#define pthreadPointer(a) a

#define lockCount(a) a

#pragma mark -

#define CF_RUN_LOOP_PROBES 0

#if CF_RUN_LOOP_PROBES

#include "CFRunLoopProbes.h"

#define CFRUNLOOP_NEXT_TIMER_ARMED(arg0) do { } while (0)

#define CFRUNLOOP_NEXT_TIMER_ARMED_ENABLED() (0)

#define CFRUNLOOP_POLL() do { } while (0)

#define CFRUNLOOP_POLL_ENABLED() (0)

#define CFRUNLOOP_SLEEP() do { } while (0)

#define CFRUNLOOP_SLEEP_ENABLED() (0)

#define CFRUNLOOP_SOURCE_FIRED(arg0, arg1, arg2) do { } while (0)

#define CFRUNLOOP_SOURCE_FIRED_ENABLED() (0)

#define CFRUNLOOP_TIMER_CREATED(arg0, arg1, arg2, arg3, arg4, arg5, arg6) do { } while (0)

#define CFRUNLOOP_TIMER_CREATED_ENABLED() (0)

#define CFRUNLOOP_TIMER_FIRED(arg0, arg1, arg2, arg3, arg4) do { } while (0)

#define CFRUNLOOP_TIMER_FIRED_ENABLED() (0)

#define CFRUNLOOP_TIMER_RESCHEDULED(arg0, arg1, arg2, arg3, arg4, arg5) do { } while (0)

#define CFRUNLOOP_TIMER_RESCHEDULED_ENABLED() (0)

#define CFRUNLOOP_WAKEUP(arg0) do { } while (0)

#define CFRUNLOOP_WAKEUP_ENABLED() (0)

#define CFRUNLOOP_WAKEUP_FOR_DISPATCH() do { } while (0)

#define CFRUNLOOP_WAKEUP_FOR_DISPATCH_ENABLED() (0)

#define CFRUNLOOP_WAKEUP_FOR_NOTHING() do { } while (0)

#define CFRUNLOOP_WAKEUP_FOR_NOTHING_ENABLED() (0)

#define CFRUNLOOP_WAKEUP_FOR_SOURCE() do { } while (0)

#define CFRUNLOOP_WAKEUP_FOR_SOURCE_ENABLED() (0)

#define CFRUNLOOP_WAKEUP_FOR_TIMEOUT() do { } while (0)

#define CFRUNLOOP_WAKEUP_FOR_TIMEOUT_ENABLED() (0)

#define CFRUNLOOP_WAKEUP_FOR_TIMER() do { } while (0)

#define CFRUNLOOP_WAKEUP_FOR_TIMER_ENABLED() (0)

#define CFRUNLOOP_WAKEUP_FOR_WAKEUP() do { } while (0)

#define CFRUNLOOP_WAKEUP_FOR_WAKEUP_ENABLED() (0)

#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI

CF_PRIVATE uint32_t __CFGetProcessPortCount(void) {

ipc_info_space_t info;

ipc_info_name_array_t table = 0;

mach_msg_type_number_t tableCount = 0;

ipc_info_tree_name_array_t tree = 0;

mach_msg_type_number_t treeCount = 0;

kern_return_t ret = mach_port_space_info(mach_task_self(), &info, &table, &tableCount, &tree, &treeCount);

if (ret != KERN_SUCCESS) {

return (uint32_t)0;

}

if (table != NULL) {

ret = vm_deallocate(mach_task_self(), (vm_address_t)table, tableCount * sizeof(*table));

}

if (tree != NULL) {

ret = vm_deallocate(mach_task_self(), (vm_address_t)tree, treeCount * sizeof(*tree));

}

return (uint32_t)tableCount;

}

CF_PRIVATE CFArrayRef __CFStopAllThreads(void) {

CFMutableArrayRef suspended_list = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, NULL);

mach_port_t my_task = mach_task_self();

mach_port_t my_thread = mach_thread_self();

thread_act_array_t thr_list = 0;

mach_msg_type_number_t thr_cnt = 0;

// really, should loop doing the stopping until no more threads get added to the list N times in a row

kern_return_t ret = task_threads(my_task, &thr_list, &thr_cnt);

if (ret == KERN_SUCCESS) {

for (CFIndex idx = 0; idx < thr_cnt; idx++) {

thread_act_t thread = thr_list[idx];

if (thread == my_thread) continue;

if (CFArrayContainsValue(suspended_list, CFRangeMake(0, CFArrayGetCount(suspended_list)), (const void *)(uintptr_t)thread)) continue;

ret = thread_suspend(thread);

if (ret == KERN_SUCCESS) {

CFArrayAppendValue(suspended_list, (const void *)(uintptr_t)thread);

} else {

mach_port_deallocate(my_task, thread);

}

}

vm_deallocate(my_task, (vm_address_t)thr_list, sizeof(thread_t) * thr_cnt);

}

mach_port_deallocate(my_task, my_thread);

return suspended_list;

}

CF_PRIVATE void __CFRestartAllThreads(CFArrayRef threads) {

for (CFIndex idx = 0; idx < CFArrayGetCount(threads); idx++) {

thread_act_t thread = (thread_act_t)(uintptr_t)CFArrayGetValueAtIndex(threads, idx);

kern_return_t ret = thread_resume(thread);

if (ret != KERN_SUCCESS) CRASH("*** Failure from thread_resume (%d) ***", ret);

mach_port_deallocate(mach_task_self(), thread);

}

}

static uint32_t __CF_last_warned_port_count = 0;

static void foo() __attribute__((unused));

static void foo() {

uint32_t pcnt = __CFGetProcessPortCount();

if (__CF_last_warned_port_count + 1000 < pcnt) {

CFArrayRef threads = __CFStopAllThreads();

CFOptionFlags responseFlags = 0;

SInt32 result = CFUserNotificationDisplayAlert(0.0, kCFUserNotificationCautionAlertLevel, NULL, NULL, NULL, CFSTR("High Mach Port Usage"), CFSTR("This application is using a lot of Mach ports."), CFSTR("Default"), CFSTR("Altern"), CFSTR("Other b"), &responseFlags);

if (0 != result) {

CFLog(3, CFSTR("ERROR"));

} else {

switch (responseFlags) {

case kCFUserNotificationDefaultResponse: CFLog(3, CFSTR("DefaultR")); break;

case kCFUserNotificationAlternateResponse: CFLog(3, CFSTR("AltR")); break;

case kCFUserNotificationOtherResponse: CFLog(3, CFSTR("OtherR")); break;

case kCFUserNotificationCancelResponse: CFLog(3, CFSTR("CancelR")); break;

}

}

__CFRestartAllThreads(threads);

CFRelease(threads);

__CF_last_warned_port_count = pcnt;

}

}

typedef mach_port_t __CFPort;

#define CFPORT_NULL MACH_PORT_NULL

typedef mach_port_t __CFPortSet;

static void __THE_SYSTEM_HAS_NO_PORTS_AVAILABLE__(kern_return_t ret) __attribute__((noinline));

static void __THE_SYSTEM_HAS_NO_PORTS_AVAILABLE__(kern_return_t ret) { HALT; };

static __CFPort __CFPortAllocate(void) {

__CFPort result = CFPORT_NULL;

kern_return_t ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &result);

if (KERN_SUCCESS != ret) {

char msg[256];

snprintf(msg, 256, "*** The system has no mach ports available. You may be able to diagnose which application(s) are using ports by using 'top' or Activity Monitor. (%d) ***", ret);

CRSetCrashLogMessage(msg);

__THE_SYSTEM_HAS_NO_PORTS_AVAILABLE__(ret);

return CFPORT_NULL;

}

ret = mach_port_insert_right(mach_task_self(), result, result, MACH_MSG_TYPE_MAKE_SEND);

if (KERN_SUCCESS != ret) CRASH("*** Unable to set send right on mach port. (%d) ***", ret);

mach_port_limits_t limits;

limits.mpl_qlimit = 1;

ret = mach_port_set_attributes(mach_task_self(), result, MACH_PORT_LIMITS_INFO, (mach_port_info_t)&limits, MACH_PORT_LIMITS_INFO_COUNT);

if (KERN_SUCCESS != ret) CRASH("*** Unable to set attributes on mach port. (%d) ***", ret);

return result;

}

CF_INLINE void __CFPortFree(__CFPort port) {

mach_port_destroy(mach_task_self(), port);

}

static void __THE_SYSTEM_HAS_NO_PORT_SETS_AVAILABLE__(kern_return_t ret) __attribute__((noinline));

static void __THE_SYSTEM_HAS_NO_PORT_SETS_AVAILABLE__(kern_return_t ret) { HALT; };

CF_INLINE __CFPortSet __CFPortSetAllocate(void) {

__CFPortSet result;

kern_return_t ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_PORT_SET, &result);

if (KERN_SUCCESS != ret) { __THE_SYSTEM_HAS_NO_PORT_SETS_AVAILABLE__(ret); }

return (KERN_SUCCESS == ret) ? result : CFPORT_NULL;

}

CF_INLINE kern_return_t __CFPortSetInsert(__CFPort port, __CFPortSet portSet) {

if (MACH_PORT_NULL == port) {

return -1;

}

return mach_port_insert_member(mach_task_self(), port, portSet);

}

CF_INLINE kern_return_t __CFPortSetRemove(__CFPort port, __CFPortSet portSet) {

if (MACH_PORT_NULL == port) {

return -1;

}

return mach_port_extract_member(mach_task_self(), port, portSet);

}

CF_INLINE void __CFPortSetFree(__CFPortSet portSet) {

kern_return_t ret;

mach_port_name_array_t array;

mach_msg_type_number_t idx, number;

ret = mach_port_get_set_status(mach_task_self(), portSet, &array, &number);

if (KERN_SUCCESS == ret) {

for (idx = 0; idx < number; idx++) {

mach_port_extract_member(mach_task_self(), array[idx], portSet);

}

vm_deallocate(mach_task_self(), (vm_address_t)array, number * sizeof(mach_port_name_t));

}

mach_port_destroy(mach_task_self(), portSet);

}

#elif DEPLOYMENT_TARGET_WINDOWS

typedef HANDLE __CFPort;

#define CFPORT_NULL NULL

typedef struct ___CFPortSet {

} *__CFPortSet;

CF_INLINE __CFPort __CFPortAllocate(void) {

return CreateEventA(NULL, true, false, NULL);

}

CF_INLINE void __CFPortFree(__CFPort port) {

CloseHandle(port);

}

static __CFPortSet __CFPortSetAllocate(void) {

__CFPortSet result = (__CFPortSet)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(struct ___CFPortSet), 0);

result->used = 0;

result->size = 4;

result->handles = (HANDLE *)CFAllocatorAllocate(kCFAllocatorSystemDefault, result->size * sizeof(HANDLE), 0);

CF_SPINLOCK_INIT_FOR_STRUCTS(result->lock);

return result;

}

static void __CFPortSetFree(__CFPortSet portSet) {

CFAllocatorDeallocate(kCFAllocatorSystemDefault, portSet->handles);

CFAllocatorDeallocate(kCFAllocatorSystemDefault, portSet);

}

static __CFPort *__CFPortSetGetPorts(__CFPortSet portSet, __CFPort *portBuf, uint32_t bufSize, uint32_t *portsUsed) {

__CFLock(&(portSet->lock));

__CFPort *result = portBuf;

if (bufSize < portSet->used)

result = (__CFPort *)CFAllocatorAllocate(kCFAllocatorSystemDefault, portSet->used * sizeof(HANDLE), 0);

if (portSet->used > 1) {

// rotate the ports to vaguely simulate round-robin behaviour

uint16_t lastPort = portSet->used - 1;

HANDLE swapHandle = portSet->handles[0];

memmove(portSet->handles, &portSet->handles[1], lastPort * sizeof(HANDLE));

portSet->handles[lastPort] = swapHandle;

}

memmove(result, portSet->handles, portSet->used * sizeof(HANDLE));

*portsUsed = portSet->used;

__CFUnlock(&(portSet->lock));

return result;

}

static kern_return_t __CFPortSetInsert(__CFPort port, __CFPortSet portSet) {

if (NULL == port) {

return -1;

}

__CFLock(&(portSet->lock));

if (portSet->used >= portSet->size) {

portSet->size += 4;

portSet->handles = (HANDLE *)CFAllocatorReallocate(kCFAllocatorSystemDefault, portSet->handles, portSet->size * sizeof(HANDLE), 0);

}

if (portSet->used >= MAXIMUM_WAIT_OBJECTS) {

CFLog(kCFLogLevelWarning, CFSTR("*** More than MAXIMUM_WAIT_OBJECTS (%d) ports add to a port set. The last ones will be ignored."), MAXIMUM_WAIT_OBJECTS);

}

portSet->handles[portSet->used++] = port;

__CFUnlock(&(portSet->lock));

return KERN_SUCCESS;

}

static kern_return_t __CFPortSetRemove(__CFPort port, __CFPortSet portSet) {

int i, j;

if (NULL == port) {

return -1;

}

__CFLock(&(portSet->lock));

for (i = 0; i < portSet->used; i++) {

if (portSet->handles[i] == port) {

for (j = i+1; j < portSet->used; j++) {

portSet->handles[j-1] = portSet->handles[j];

}

portSet->used--;

__CFUnlock(&(portSet->lock));

return true;

}

}

__CFUnlock(&(portSet->lock));

return KERN_SUCCESS;

}

#if !defined(__MACTYPES__) && !defined(_OS_OSTYPES_H)

#if defined(__BIG_ENDIAN__)

typedef struct UnsignedWide {

UInt32 hi;

UInt32 lo;

} UnsignedWide;

#elif defined(__LITTLE_ENDIAN__)

typedef struct UnsignedWide {

UInt32 lo;

UInt32 hi;

} UnsignedWide;

typedef UnsignedWide AbsoluteTime;

#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI

#if USE_DISPATCH_SOURCE_FOR_TIMERS

#if USE_MK_TIMER_TOO

extern mach_port_name_t mk_timer_create(void);

extern kern_return_t mk_timer_destroy(mach_port_name_t name);

extern kern_return_t mk_timer_arm(mach_port_name_t name, AbsoluteTime expire_time);

extern kern_return_t mk_timer_cancel(mach_port_name_t name, AbsoluteTime *result_time);

CF_INLINE AbsoluteTime __CFUInt64ToAbsoluteTime(uint64_t x) {

AbsoluteTime a;

a.hi = x >> 32;

a.lo = x & (uint64_t)0xFFFFFFFF;

return a;

}

static uint32_t __CFSendTrivialMachMessage(mach_port_t port, uint32_t msg_id, CFOptionFlags options, uint32_t timeout) {

kern_return_t result;

mach_msg_header_t header;

header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);

header.msgh_size = sizeof(mach_msg_header_t);

header.msgh_remote_port = port;

header.msgh_local_port = MACH_PORT_NULL;

header.msgh_id = msg_id;

result = mach_msg(&header, MACH_SEND_MSG|options, header.msgh_size, 0, MACH_PORT_NULL, timeout, MACH_PORT_NULL);

if (result == MACH_SEND_TIMED_OUT) mach_msg_destroy(&header);

return result;

}

#elif DEPLOYMENT_TARGET_WINDOWS

static HANDLE mk_timer_create(void) {

return CreateWaitableTimer(NULL, FALSE, NULL);

}

static kern_return_t mk_timer_destroy(HANDLE name) {

BOOL res = CloseHandle(name);

if (!res) {

DWORD err = GetLastError();

CFLog(kCFLogLevelError, CFSTR("CFRunLoop: Unable to destroy timer: %d"), err);

}

return (int)res;

}

static kern_return_t mk_timer_arm(HANDLE name, LARGE_INTEGER expire_time) {

BOOL res = SetWaitableTimer(name, &expire_time, 0, NULL, NULL, FALSE);

if (!res) {

DWORD err = GetLastError();

CFLog(kCFLogLevelError, CFSTR("CFRunLoop: Unable to set timer: %d"), err);

}

return (int)res;

}

static kern_return_t mk_timer_cancel(HANDLE name, LARGE_INTEGER *result_time) {

BOOL res = CancelWaitableTimer(name);

if (!res) {

DWORD err = GetLastError();

CFLog(kCFLogLevelError, CFSTR("CFRunLoop: Unable to cancel timer: %d"), err);

}

return (int)res;

}

CF_INLINE LARGE_INTEGER __CFUInt64ToAbsoluteTime(uint64_t desiredFireTime) {

LARGE_INTEGER result;

// There is a race we know about here, (timer fire time calculated -> thread suspended -> timer armed == late timer fire), but we don't have a way to avoid it at this time, since the only way to specify an absolute value to the timer is to calculate the relative time first. Fixing that would probably require not using the TSR for timers on Windows.

uint64_t now = mach_absolute_time();

if (now > desiredFireTime) {

result.QuadPart = 0;

} else {

uint64_t timeDiff = desiredFireTime - now;

CFTimeInterval amountOfTimeToWait = __CFTSRToTimeInterval(timeDiff);

// Result is in 100 ns (10**-7 sec) units to be consistent with a FILETIME.

// CFTimeInterval is in seconds.

result.QuadPart = -(amountOfTimeToWait * 10000000);

}

return result;

}

#pragma mark -

#pragma mark Modes

static CFTypeID __kCFRunLoopModeTypeID = _kCFRuntimeNotATypeID;

static CFTypeID __kCFRunLoopTypeID = _kCFRuntimeNotATypeID;

static CFTypeID __kCFRunLoopSourceTypeID = _kCFRuntimeNotATypeID;

static CFTypeID __kCFRunLoopObserverTypeID = _kCFRuntimeNotATypeID;

static CFTypeID __kCFRunLoopTimerTypeID = _kCFRuntimeNotATypeID;

CF_INLINE void __CFRunLoopModeLock(CFRunLoopModeRef rlm) {

pthread_mutex_lock(&(rlm->_lock));

//CFLog(6, CFSTR("__CFRunLoopModeLock locked %p"), rlm);

}

CF_INLINE void __CFRunLoopModeUnlock(CFRunLoopModeRef rlm) {

//CFLog(6, CFSTR("__CFRunLoopModeLock unlocking %p"), rlm);

pthread_mutex_unlock(&(rlm->_lock));

}

static Boolean __CFRunLoopModeEqual(CFTypeRef cf1, CFTypeRef cf2) {

CFRunLoopModeRef rlm1 = (CFRunLoopModeRef)cf1;

CFRunLoopModeRef rlm2 = (CFRunLoopModeRef)cf2;

return CFEqual(rlm1->_name, rlm2->_name);

}

static CFHashCode __CFRunLoopModeHash(CFTypeRef cf) {

CFRunLoopModeRef rlm = (CFRunLoopModeRef)cf;

return CFHash(rlm->_name);

}

static CFStringRef __CFRunLoopModeCopyDescription(CFTypeRef cf) {

CFRunLoopModeRef rlm = (CFRunLoopModeRef)cf;

CFMutableStringRef result;

result = CFStringCreateMutable(kCFAllocatorSystemDefault, 0);

CFStringAppendFormat(result, NULL, CFSTR("<CFRunLoopMode %p [%p]>{name = %@, "), rlm, CFGetAllocator(rlm), rlm->_name);

CFStringAppendFormat(result, NULL, CFSTR("port set = 0x%x, "), rlm->_portSet);

#if USE_DISPATCH_SOURCE_FOR_TIMERS

CFStringAppendFormat(result, NULL, CFSTR("queue = %p, "), rlm->_queue);

CFStringAppendFormat(result, NULL, CFSTR("source = %p (%s), "), rlm->_timerSource, rlm->_timerFired ? "fired" : "not fired");

#if USE_MK_TIMER_TOO

CFStringAppendFormat(result, NULL, CFSTR("timer port = 0x%x, "), rlm->_timerPort);

#if DEPLOYMENT_TARGET_WINDOWS

CFStringAppendFormat(result, NULL, CFSTR("MSGQ mask = %p, "), rlm->_msgQMask);

CFStringAppendFormat(result, NULL, CFSTR("\n\tsources0 = %@,\n\tsources1 = %@,\n\tobservers = %@,\n\ttimers = %@,\n\tcurrently %0.09g (%lld) / soft deadline in: %0.09g sec (@ %lld) / hard deadline in: %0.09g sec (@ %lld)\n},\n"), rlm->_sources0, rlm->_sources1, rlm->_observers, rlm->_timers, CFAbsoluteTimeGetCurrent(), mach_absolute_time(), __CFTSRToTimeInterval(rlm->_timerSoftDeadline - mach_absolute_time()), rlm->_timerSoftDeadline, __CFTSRToTimeInterval(rlm->_timerHardDeadline - mach_absolute_time()), rlm->_timerHardDeadline);

return result;

}

static void __CFRunLoopModeDeallocate(CFTypeRef cf) {

CFRunLoopModeRef rlm = (CFRunLoopModeRef)cf;

if (NULL != rlm->_sources0) CFRelease(rlm->_sources0);

if (NULL != rlm->_sources1) CFRelease(rlm->_sources1);

if (NULL != rlm->_observers) CFRelease(rlm->_observers);

if (NULL != rlm->_timers) CFRelease(rlm->_timers);

if (NULL != rlm->_portToV1SourceMap) CFRelease(rlm->_portToV1SourceMap);

CFRelease(rlm->_name);

__CFPortSetFree(rlm->_portSet);

#if USE_DISPATCH_SOURCE_FOR_TIMERS

if (rlm->_timerSource) {

dispatch_source_cancel(rlm->_timerSource);

dispatch_release(rlm->_timerSource);

}

if (rlm->_queue) {

dispatch_release(rlm->_queue);

}

#if USE_MK_TIMER_TOO

if (MACH_PORT_NULL != rlm->_timerPort) mk_timer_destroy(rlm->_timerPort);

pthread_mutex_destroy(&rlm->_lock);

memset((char *)cf + sizeof(CFRuntimeBase), 0x7C, sizeof(struct __CFRunLoopMode) - sizeof(CFRuntimeBase));

}

#pragma mark -

#pragma mark Run Loops

struct _block_item {

};

typedef struct _per_run_data {

} _per_run_data;

struct __CFRunLoop {

};

typedef struct __CFRunLoopMode *CFRunLoopModeRef;

struct __CFRunLoopMode {

};

CONST_STRING_DECL(kCFRunLoopDefaultMode, "kCFRunLoopDefaultMode")

CONST_STRING_DECL(kCFRunLoopCommonModes, "kCFRunLoopCommonModes")

CF_INLINE volatile _per_run_data *__CFRunLoopPushPerRunData(CFRunLoopRef rl) {

volatile _per_run_data *previous = rl->_perRunData;

rl->_perRunData = (volatile _per_run_data *)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(_per_run_data), 0);

rl->_perRunData->a = 0x4346524C;

rl->_perRunData->b = 0x4346524C; // 'CFRL'

rl->_perRunData->stopped = 0x00000000;

rl->_perRunData->ignoreWakeUps = 0x00000000;

return previous;

}

CF_INLINE void __CFRunLoopPopPerRunData(CFRunLoopRef rl, volatile _per_run_data *previous) {

if (rl->_perRunData) CFAllocatorDeallocate(kCFAllocatorSystemDefault, (void *)rl->_perRunData);

rl->_perRunData = previous;

}

CF_INLINE Boolean __CFRunLoopIsStopped(CFRunLoopRef rl) {

return (rl->_perRunData->stopped) ? true : false;

}

CF_INLINE void __CFRunLoopSetStopped(CFRunLoopRef rl) {

rl->_perRunData->stopped = 0x53544F50; // 'STOP'

}

CF_INLINE void __CFRunLoopUnsetStopped(CFRunLoopRef rl) {

rl->_perRunData->stopped = 0x0;

}

CF_INLINE Boolean __CFRunLoopIsIgnoringWakeUps(CFRunLoopRef rl) {

return (rl->_perRunData->ignoreWakeUps) ? true : false;

}

CF_INLINE void __CFRunLoopSetIgnoreWakeUps(CFRunLoopRef rl) {

rl->_perRunData->ignoreWakeUps = 0x57414B45; // 'WAKE'

}

CF_INLINE void __CFRunLoopUnsetIgnoreWakeUps(CFRunLoopRef rl) {

rl->_perRunData->ignoreWakeUps = 0x0;

}

CF_INLINE Boolean __CFRunLoopIsSleeping(CFRunLoopRef rl) {

return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)rl)->_cfinfo[CF_INFO_BITS], 1, 1);

}

CF_INLINE void __CFRunLoopSetSleeping(CFRunLoopRef rl) {

__CFBitfieldSetValue(((CFRuntimeBase *)rl)->_cfinfo[CF_INFO_BITS], 1, 1, 1);

}

CF_INLINE void __CFRunLoopUnsetSleeping(CFRunLoopRef rl) {

__CFBitfieldSetValue(((CFRuntimeBase *)rl)->_cfinfo[CF_INFO_BITS], 1, 1, 0);

}

CF_INLINE Boolean __CFRunLoopIsDeallocating(CFRunLoopRef rl) {

return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)rl)->_cfinfo[CF_INFO_BITS], 2, 2);

}

CF_INLINE void __CFRunLoopSetDeallocating(CFRunLoopRef rl) {

__CFBitfieldSetValue(((CFRuntimeBase *)rl)->_cfinfo[CF_INFO_BITS], 2, 2, 1);

}

CF_INLINE void __CFRunLoopLock(CFRunLoopRef rl) {

pthread_mutex_lock(&(((CFRunLoopRef)rl)->_lock));

// CFLog(6, CFSTR("__CFRunLoopLock locked %p"), rl);

}

CF_INLINE void __CFRunLoopUnlock(CFRunLoopRef rl) {

// CFLog(6, CFSTR("__CFRunLoopLock unlocking %p"), rl);

pthread_mutex_unlock(&(((CFRunLoopRef)rl)->_lock));

}

static CFStringRef __CFRunLoopCopyDescription(CFTypeRef cf) {

CFRunLoopRef rl = (CFRunLoopRef)cf;

CFMutableStringRef result;

result = CFStringCreateMutable(kCFAllocatorSystemDefault, 0);

#if DEPLOYMENT_TARGET_WINDOWS

CFStringAppendFormat(result, NULL, CFSTR("<CFRunLoop %p [%p]>{wakeup port = 0x%x, stopped = %s, ignoreWakeUps = %s, \ncurrent mode = %@,\n"), cf, CFGetAllocator(cf), rl->_wakeUpPort, __CFRunLoopIsStopped(rl) ? "true" : "false", __CFRunLoopIsIgnoringWakeUps(rl) ? "true" : "false", rl->_currentMode ? rl->_currentMode->_name : CFSTR("(none)"));

CFStringAppendFormat(result, NULL, CFSTR("<CFRunLoop %p [%p]>{wakeup port = 0x%x, stopped = %s, ignoreWakeUps = %s, \ncurrent mode = %@,\n"), cf, CFGetAllocator(cf), rl->_wakeUpPort, __CFRunLoopIsStopped(rl) ? "true" : "false", __CFRunLoopIsIgnoringWakeUps(rl) ? "true" : "false", rl->_currentMode ? rl->_currentMode->_name : CFSTR("(none)"));

CFStringAppendFormat(result, NULL, CFSTR("common modes = %@,\ncommon mode items = %@,\nmodes = %@}\n"), rl->_commonModes, rl->_commonModeItems, rl->_modes);

return result;

}

CF_PRIVATE void __CFRunLoopDump() { // __private_extern__ to keep the compiler from discarding it

CFShow(CFCopyDescription(CFRunLoopGetCurrent()));

}

CF_INLINE void __CFRunLoopLockInit(pthread_mutex_t *lock) {

pthread_mutexattr_t mattr;

pthread_mutexattr_init(&mattr);

pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);

int32_t mret = pthread_mutex_init(lock, &mattr);

pthread_mutexattr_destroy(&mattr);

if (0 != mret) {

}

}

static CFRunLoopModeRef __CFRunLoopFindMode(CFRunLoopRef rl, CFStringRef modeName, Boolean create) {

CHECK_FOR_FORK();

CFRunLoopModeRef rlm;

struct __CFRunLoopMode srlm;

memset(&srlm, 0, sizeof(srlm));

_CFRuntimeSetInstanceTypeIDAndIsa(&srlm, __kCFRunLoopModeTypeID);

srlm._name = modeName;

rlm = (CFRunLoopModeRef)CFSetGetValue(rl->_modes, &srlm);

if (NULL != rlm) {

__CFRunLoopModeLock(rlm);

return rlm;

}

if (!create) {

return NULL;

}

rlm = (CFRunLoopModeRef)_CFRuntimeCreateInstance(kCFAllocatorSystemDefault, __kCFRunLoopModeTypeID, sizeof(struct __CFRunLoopMode) - sizeof(CFRuntimeBase), NULL);

if (NULL == rlm) {

return NULL;

}

__CFRunLoopLockInit(&rlm->_lock);

rlm->_name = CFStringCreateCopy(kCFAllocatorSystemDefault, modeName);

rlm->_stopped = false;

rlm->_portToV1SourceMap = NULL;

rlm->_sources0 = NULL;

rlm->_sources1 = NULL;

rlm->_observers = NULL;

rlm->_timers = NULL;

rlm->_observerMask = 0;

rlm->_portSet = __CFPortSetAllocate();

rlm->_timerSoftDeadline = UINT64_MAX;

rlm->_timerHardDeadline = UINT64_MAX;

kern_return_t ret = KERN_SUCCESS;

#if USE_DISPATCH_SOURCE_FOR_TIMERS

rlm->_timerFired = false;

rlm->_queue = _dispatch_runloop_root_queue_create_4CF("Run Loop Mode Queue", 0);

mach_port_t queuePort = _dispatch_runloop_root_queue_get_port_4CF(rlm->_queue);

if (queuePort == MACH_PORT_NULL) CRASH("*** Unable to create run loop mode queue port. (%d) ***", -1);

rlm->_timerSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, rlm->_queue);

__block Boolean *timerFiredPointer = &(rlm->_timerFired);

dispatch_source_set_event_handler(rlm->_timerSource, ^{

*timerFiredPointer = true;

});

// Set timer to far out there. The unique leeway makes this timer easy to spot in debug output.

_dispatch_source_set_runloop_timer_4CF(rlm->_timerSource, DISPATCH_TIME_FOREVER, DISPATCH_TIME_FOREVER, 321);

dispatch_resume(rlm->_timerSource);

ret = __CFPortSetInsert(queuePort, rlm->_portSet);

if (KERN_SUCCESS != ret) CRASH("*** Unable to insert timer port into port set. (%d) ***", ret);

#if USE_MK_TIMER_TOO

rlm->_timerPort = mk_timer_create();

ret = __CFPortSetInsert(rlm->_timerPort, rlm->_portSet);

if (KERN_SUCCESS != ret) CRASH("*** Unable to insert timer port into port set. (%d) ***", ret);

ret = __CFPortSetInsert(rl->_wakeUpPort, rlm->_portSet);

if (KERN_SUCCESS != ret) CRASH("*** Unable to insert wake up port into port set. (%d) ***", ret);

#if DEPLOYMENT_TARGET_WINDOWS

rlm->_msgQMask = 0;

rlm->_msgPump = NULL;

CFSetAddValue(rl->_modes, rlm);

CFRelease(rlm);

__CFRunLoopModeLock(rlm); /* return mode locked */

return rlm;

}

static Boolean __CFRunLoopModeIsEmpty(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFRunLoopModeRef previousMode) {

CHECK_FOR_FORK();

if (NULL == rlm) return true;

#if DEPLOYMENT_TARGET_WINDOWS

if (0 != rlm->_msgQMask) return false;

Boolean libdispatchQSafe = pthread_main_np() && ((HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && NULL == previousMode) || (!HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && 0 == _CFGetTSD(__CFTSDKeyIsInGCDMainQ)));

if (libdispatchQSafe && (CFRunLoopGetMain() == rl) && CFSetContainsValue(rl->_commonModes, rlm->_name)) return false; // represents the libdispatch main queue

if (NULL != rlm->_sources0 && 0 < CFSetGetCount(rlm->_sources0)) return false;

if (NULL != rlm->_sources1 && 0 < CFSetGetCount(rlm->_sources1)) return false;

if (NULL != rlm->_timers && 0 < CFArrayGetCount(rlm->_timers)) return false;

struct _block_item *item = rl->_blocks_head;

while (item) {

struct _block_item *curr = item;

item = item->_next;

Boolean doit = false;

if (CFStringGetTypeID() == CFGetTypeID(curr->_mode)) {

doit = CFEqual(curr->_mode, rlm->_name) || (CFEqual(curr->_mode, kCFRunLoopCommonModes) && CFSetContainsValue(rl->_commonModes, rlm->_name));

} else {

doit = CFSetContainsValue((CFSetRef)curr->_mode, rlm->_name) || (CFSetContainsValue((CFSetRef)curr->_mode, kCFRunLoopCommonModes) && CFSetContainsValue(rl->_commonModes, rlm->_name));

}

if (doit) return false;

}

return true;

}

#if DEPLOYMENT_TARGET_WINDOWS

uint32_t _CFRunLoopGetWindowsMessageQueueMask(CFRunLoopRef rl, CFStringRef modeName) {

if (modeName == kCFRunLoopCommonModes) {

CFLog(kCFLogLevelError, CFSTR("_CFRunLoopGetWindowsMessageQueueMask: kCFRunLoopCommonModes unsupported"));

HALT;

}

DWORD result = 0;

__CFRunLoopLock(rl);

CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, false);

if (rlm) {

result = rlm->_msgQMask;

__CFRunLoopModeUnlock(rlm);

}

__CFRunLoopUnlock(rl);

return (uint32_t)result;

}

void _CFRunLoopSetWindowsMessageQueueMask(CFRunLoopRef rl, uint32_t mask, CFStringRef modeName) {

if (modeName == kCFRunLoopCommonModes) {

CFLog(kCFLogLevelError, CFSTR("_CFRunLoopSetWindowsMessageQueueMask: kCFRunLoopCommonModes unsupported"));

HALT;

}

__CFRunLoopLock(rl);

CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, true);

rlm->_msgQMask = (DWORD)mask;

__CFRunLoopModeUnlock(rlm);

__CFRunLoopUnlock(rl);

}

uint32_t _CFRunLoopGetWindowsThreadID(CFRunLoopRef rl) {

return rl->_winthread;

}

CFWindowsMessageQueueHandler _CFRunLoopGetWindowsMessageQueueHandler(CFRunLoopRef rl, CFStringRef modeName) {

if (modeName == kCFRunLoopCommonModes) {

CFLog(kCFLogLevelError, CFSTR("_CFRunLoopGetWindowsMessageQueueMask: kCFRunLoopCommonModes unsupported"));

HALT;

}

if (rl != CFRunLoopGetCurrent()) {

CFLog(kCFLogLevelError, CFSTR("_CFRunLoopGetWindowsMessageQueueHandler: run loop parameter must be the current run loop"));

HALT;

}

void (*result)(void) = NULL;

__CFRunLoopLock(rl);

CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, false);

if (rlm) {

result = rlm->_msgPump;

__CFRunLoopModeUnlock(rlm);

}

__CFRunLoopUnlock(rl);

return result;

}

void _CFRunLoopSetWindowsMessageQueueHandler(CFRunLoopRef rl, CFStringRef modeName, CFWindowsMessageQueueHandler func) {

if (modeName == kCFRunLoopCommonModes) {

CFLog(kCFLogLevelError, CFSTR("_CFRunLoopGetWindowsMessageQueueMask: kCFRunLoopCommonModes unsupported"));

HALT;

}

if (rl != CFRunLoopGetCurrent()) {

CFLog(kCFLogLevelError, CFSTR("_CFRunLoopGetWindowsMessageQueueHandler: run loop parameter must be the current run loop"));

HALT;

}

__CFRunLoopLock(rl);

CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, true);

rlm->_msgPump = func;

__CFRunLoopModeUnlock(rlm);

__CFRunLoopUnlock(rl);

}

#pragma mark -

#pragma mark Sources

CF_INLINE Boolean __CFIsValid(const void *cf) {

return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)cf)->_cfinfo[CF_INFO_BITS], 3, 3);

}

CF_INLINE void __CFSetValid(void *cf) {

__CFBitfieldSetValue(((CFRuntimeBase *)cf)->_cfinfo[CF_INFO_BITS], 3, 3, 1);

}

CF_INLINE void __CFUnsetValid(void *cf) {

__CFBitfieldSetValue(((CFRuntimeBase *)cf)->_cfinfo[CF_INFO_BITS], 3, 3, 0);

}

struct __CFRunLoopSource {

};

CF_INLINE Boolean __CFRunLoopSourceIsSignaled(CFRunLoopSourceRef rls) {

return (Boolean)__CFBitfieldGetValue(rls->_bits, 1, 1);

}

CF_INLINE void __CFRunLoopSourceSetSignaled(CFRunLoopSourceRef rls) {

__CFBitfieldSetValue(rls->_bits, 1, 1, 1);

}

CF_INLINE void __CFRunLoopSourceUnsetSignaled(CFRunLoopSourceRef rls) {

__CFBitfieldSetValue(rls->_bits, 1, 1, 0);

}

CF_INLINE void __CFRunLoopSourceLock(CFRunLoopSourceRef rls) {

pthread_mutex_lock(&(rls->_lock));

}

CF_INLINE void __CFRunLoopSourceUnlock(CFRunLoopSourceRef rls) {

pthread_mutex_unlock(&(rls->_lock));

}