#include <CoreFoundation/CFMessagePort.h>
#include <CoreFoundation/CFRunLoop.h>
#include <CoreFoundation/CFMachPort.h>
#include <CoreFoundation/CFDictionary.h>
#include <CoreFoundation/CFByteOrder.h>
#include <limits.h>
#include "CFInternal.h"
#include <mach/mach.h>
#include <mach/message.h>
#include <mach/mach_error.h>
#include <bootstrap_priv.h>
#include <math.h>
#include <mach/mach_time.h>
#include <dlfcn.h>
#include <dispatch/dispatch.h>
#include <dispatch/private.h>
extern pid_t getpid(void);
#define __kCFMessagePortMaxNameLengthMax 255
#if defined(BOOTSTRAP_MAX_NAME_LEN)
#define __kCFMessagePortMaxNameLength BOOTSTRAP_MAX_NAME_LEN
#else
#define __kCFMessagePortMaxNameLength 128
#endif
#if __kCFMessagePortMaxNameLengthMax < __kCFMessagePortMaxNameLength
#undef __kCFMessagePortMaxNameLength
#define __kCFMessagePortMaxNameLength __kCFMessagePortMaxNameLengthMax
#endif
#define __CFMessagePortMaxDataSize 0x60000000L
static CFSpinLock_t __CFAllMessagePortsLock = CFSpinLockInit;
static CFMutableDictionaryRef __CFAllLocalMessagePorts = NULL;
static CFMutableDictionaryRef __CFAllRemoteMessagePorts = NULL;
struct __CFMessagePort {
CFRuntimeBase _base;
CFSpinLock_t _lock;
CFStringRef _name;
CFMachPortRef _port;
CFMutableDictionaryRef _replies;
int32_t _convCounter;
int32_t _perPID;
CFMachPortRef _replyPort;
CFRunLoopSourceRef _source;
dispatch_source_t _dispatchSource;
dispatch_queue_t _dispatchQ;
CFMessagePortInvalidationCallBack _icallout;
CFMessagePortCallBack _callout;
CFMessagePortCallBackEx _calloutEx;
CFMessagePortContext _context;
};
CF_INLINE Boolean __CFMessagePortIsValid(CFMessagePortRef ms) {
return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 0, 0);
}
CF_INLINE void __CFMessagePortSetValid(CFMessagePortRef ms) {
__CFBitfieldSetValue(((CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 0, 0, 1);
}
CF_INLINE void __CFMessagePortUnsetValid(CFMessagePortRef ms) {
__CFBitfieldSetValue(((CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 0, 0, 0);
}
CF_INLINE Boolean __CFMessagePortExtraMachRef(CFMessagePortRef ms) {
return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 1, 1);
}
CF_INLINE void __CFMessagePortSetExtraMachRef(CFMessagePortRef ms) {
__CFBitfieldSetValue(((CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 1, 1, 1);
}
CF_INLINE void __CFMessagePortUnsetExtraMachRef(CFMessagePortRef ms) {
__CFBitfieldSetValue(((CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 1, 1, 0);
}
CF_INLINE Boolean __CFMessagePortIsRemote(CFMessagePortRef ms) {
return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 2, 2);
}
CF_INLINE void __CFMessagePortSetRemote(CFMessagePortRef ms) {
__CFBitfieldSetValue(((CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 2, 2, 1);
}
CF_INLINE void __CFMessagePortUnsetRemote(CFMessagePortRef ms) {
__CFBitfieldSetValue(((CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 2, 2, 0);
}
CF_INLINE Boolean __CFMessagePortIsDeallocing(CFMessagePortRef ms) {
return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 3, 3);
}
CF_INLINE void __CFMessagePortSetIsDeallocing(CFMessagePortRef ms) {
__CFBitfieldSetValue(((CFRuntimeBase *)ms)->_cfinfo[CF_INFO_BITS], 3, 3, 1);
}
CF_INLINE void __CFMessagePortLock(CFMessagePortRef ms) {
__CFSpinLock(&(ms->_lock));
}
CF_INLINE void __CFMessagePortUnlock(CFMessagePortRef ms) {
__CFSpinUnlock(&(ms->_lock));
}
#define __CFMessagePortMaxInlineBytes 4096*10
struct __CFMessagePortMachMessage0 {
mach_msg_base_t base;
int32_t magic;
int32_t msgid;
int32_t byteslen;
uint8_t bytes[0];
};
struct __CFMessagePortMachMessage1 {
mach_msg_base_t base;
mach_msg_ool_descriptor_t ool;
int32_t magic;
int32_t msgid;
int32_t byteslen;
};
#define MAGIC 0xF1F2F3F4
#define MSGP0_FIELD(msgp, ident) ((struct __CFMessagePortMachMessage0 *)msgp)->ident
#define MSGP1_FIELD(msgp, ident) ((struct __CFMessagePortMachMessage1 *)msgp)->ident
#define MSGP_GET(msgp, ident) \
((((mach_msg_base_t *)msgp)->body.msgh_descriptor_count) ? MSGP1_FIELD(msgp, ident) : MSGP0_FIELD(msgp, ident))
static mach_msg_base_t *__CFMessagePortCreateMessage(bool reply, mach_port_t port, mach_port_t replyPort, int32_t convid, int32_t msgid, const uint8_t *bytes, int32_t byteslen) {
if (__CFMessagePortMaxDataSize < byteslen) return NULL;
int32_t rounded_byteslen = ((byteslen + 3) & ~0x3);
if (rounded_byteslen <= __CFMessagePortMaxInlineBytes) {
int32_t size = sizeof(struct __CFMessagePortMachMessage0) + rounded_byteslen;
struct __CFMessagePortMachMessage0 *msg = CFAllocatorAllocate(kCFAllocatorSystemDefault, size, 0);
if (!msg) return NULL;
memset(msg, 0, size);
msg->base.header.msgh_id = convid;
msg->base.header.msgh_size = size;
msg->base.header.msgh_remote_port = port;
msg->base.header.msgh_local_port = replyPort;
msg->base.header.msgh_reserved = 0;
msg->base.header.msgh_bits = MACH_MSGH_BITS((reply ? MACH_MSG_TYPE_MOVE_SEND_ONCE : MACH_MSG_TYPE_COPY_SEND), (MACH_PORT_NULL != replyPort ? MACH_MSG_TYPE_MAKE_SEND_ONCE : 0));
msg->base.body.msgh_descriptor_count = 0;
msg->magic = MAGIC;
msg->msgid = CFSwapInt32HostToLittle(msgid);
msg->byteslen = CFSwapInt32HostToLittle(byteslen);
if (NULL != bytes && 0 < byteslen) {
memmove(msg->bytes, bytes, byteslen);
}
return (mach_msg_base_t *)msg;
} else {
int32_t size = sizeof(struct __CFMessagePortMachMessage1);
struct __CFMessagePortMachMessage1 *msg = CFAllocatorAllocate(kCFAllocatorSystemDefault, size, 0);
if (!msg) return NULL;
memset(msg, 0, size);
msg->base.header.msgh_id = convid;
msg->base.header.msgh_size = size;
msg->base.header.msgh_remote_port = port;
msg->base.header.msgh_local_port = replyPort;
msg->base.header.msgh_reserved = 0;
msg->base.header.msgh_bits = MACH_MSGH_BITS((reply ? MACH_MSG_TYPE_MOVE_SEND_ONCE : MACH_MSG_TYPE_COPY_SEND), (MACH_PORT_NULL != replyPort ? MACH_MSG_TYPE_MAKE_SEND_ONCE : 0));
msg->base.header.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
msg->base.body.msgh_descriptor_count = 1;
msg->magic = MAGIC;
msg->msgid = CFSwapInt32HostToLittle(msgid);
msg->byteslen = CFSwapInt32HostToLittle(byteslen);
msg->ool.deallocate = false;
msg->ool.copy = MACH_MSG_VIRTUAL_COPY;
msg->ool.address = (void *)bytes;
msg->ool.size = byteslen;
msg->ool.type = MACH_MSG_OOL_DESCRIPTOR;
return (mach_msg_base_t *)msg;
}
}
static CFStringRef __CFMessagePortCopyDescription(CFTypeRef cf) {
CFMessagePortRef ms = (CFMessagePortRef)cf;
CFStringRef result;
const char *locked;
CFStringRef contextDesc = NULL;
locked = ms->_lock ? "Yes" : "No";
if (__CFMessagePortIsRemote(ms)) {
result = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<CFMessagePort %p [%p]>{locked = %s, valid = %s, remote = %s, name = %@}"), cf, CFGetAllocator(ms), locked, (__CFMessagePortIsValid(ms) ? "Yes" : "No"), (__CFMessagePortIsRemote(ms) ? "Yes" : "No"), ms->_name);
} else {
if (NULL != ms->_context.info && NULL != ms->_context.copyDescription) {
contextDesc = ms->_context.copyDescription(ms->_context.info);
}
if (NULL == contextDesc) {
contextDesc = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<CFMessagePort context %p>"), ms->_context.info);
}
void *addr = ms->_callout ? (void *)ms->_callout : (void *)ms->_calloutEx;
Dl_info info;
const char *name = (dladdr(addr, &info) && info.dli_saddr == addr && info.dli_sname) ? info.dli_sname : "???";
result = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<CFMessagePort %p [%p]>{locked = %s, valid = %s, remote = %s, name = %@, source = %p, callout = %s (%p), context = %@}"), cf, CFGetAllocator(ms), locked, (__CFMessagePortIsValid(ms) ? "Yes" : "No"), (__CFMessagePortIsRemote(ms) ? "Yes" : "No"), ms->_name, ms->_source, name, addr, (NULL != contextDesc ? contextDesc : CFSTR("<no description>")));
}
if (NULL != contextDesc) {
CFRelease(contextDesc);
}
return result;
}
static void __CFMessagePortDeallocate(CFTypeRef cf) {
CFMessagePortRef ms = (CFMessagePortRef)cf;
__CFMessagePortSetIsDeallocing(ms);
CFMessagePortInvalidate(ms);
if (NULL != ms->_replies) {
CFRelease(ms->_replies);
}
if (NULL != ms->_name) {
CFRelease(ms->_name);
}
if (NULL != ms->_port) {
if (__CFMessagePortExtraMachRef(ms)) {
mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(ms->_port), MACH_PORT_RIGHT_SEND, -1);
mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(ms->_port), MACH_PORT_RIGHT_RECEIVE, -1);
}
CFMachPortInvalidate(ms->_port);
CFRelease(ms->_port);
}
__CFSpinLock(&__CFAllMessagePortsLock);
CFMessagePortRef *remotePorts = NULL;
CFIndex cnt = 0;
if (NULL != __CFAllRemoteMessagePorts) {
cnt = CFDictionaryGetCount(__CFAllRemoteMessagePorts);
remotePorts = CFAllocatorAllocate(kCFAllocatorSystemDefault, cnt * sizeof(CFMessagePortRef), __kCFAllocatorGCScannedMemory);
CFDictionaryGetKeysAndValues(__CFAllRemoteMessagePorts, NULL, (const void **)remotePorts);
for (CFIndex idx = 0; idx < cnt; idx++) {
CFRetain(remotePorts[idx]);
}
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
if (remotePorts) {
for (CFIndex idx = 0; idx < cnt; idx++) {
CFMessagePortIsValid(remotePorts[idx]);
CFRelease(remotePorts[idx]);
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, remotePorts);
}
}
static CFTypeID __kCFMessagePortTypeID = _kCFRuntimeNotATypeID;
static const CFRuntimeClass __CFMessagePortClass = {
0,
"CFMessagePort",
NULL, NULL, __CFMessagePortDeallocate,
NULL,
NULL,
NULL, __CFMessagePortCopyDescription
};
__private_extern__ void __CFMessagePortInitialize(void) {
__kCFMessagePortTypeID = _CFRuntimeRegisterClass(&__CFMessagePortClass);
}
CFTypeID CFMessagePortGetTypeID(void) {
return __kCFMessagePortTypeID;
}
static CFStringRef __CFMessagePortSanitizeStringName(CFStringRef name, uint8_t **utfnamep, CFIndex *utfnamelenp) {
uint8_t *utfname;
CFIndex utflen;
CFStringRef result = NULL;
utfname = CFAllocatorAllocate(kCFAllocatorSystemDefault, __kCFMessagePortMaxNameLength + 1, 0);
CFStringGetBytes(name, CFRangeMake(0, CFStringGetLength(name)), kCFStringEncodingUTF8, 0, false, utfname, __kCFMessagePortMaxNameLength, &utflen);
utfname[utflen] = '\0';
if (strlen((const char *)utfname) != utflen) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
utfname = NULL;
utfnamelenp = 0;
} else {
result = CFStringCreateWithBytes(kCFAllocatorSystemDefault, utfname, utflen, kCFStringEncodingUTF8, false);
}
if (NULL != utfnamep) {
*utfnamep = utfname;
} else if (NULL != utfname) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
}
if (NULL != utfnamelenp) {
*utfnamelenp = utflen;
}
return result;
}
static void __CFMessagePortDummyCallback(CFMachPortRef port, void *msg, CFIndex size, void *info) {
}
static void __CFMessagePortInvalidationCallBack(CFMachPortRef port, void *info) {
if (info) CFMessagePortInvalidate(info);
}
static CFMessagePortRef __CFMessagePortCreateLocal(CFAllocatorRef allocator, CFStringRef name, CFMessagePortCallBack callout, CFMessagePortContext *context, Boolean *shouldFreeInfo, Boolean perPID, CFMessagePortCallBackEx calloutEx) {
CFMessagePortRef memory;
uint8_t *utfname = NULL;
if (shouldFreeInfo) *shouldFreeInfo = true;
if (NULL != name) {
name = __CFMessagePortSanitizeStringName(name, &utfname, NULL);
}
__CFSpinLock(&__CFAllMessagePortsLock);
if (!perPID && NULL != name) {
CFMessagePortRef existing;
if (NULL != __CFAllLocalMessagePorts && CFDictionaryGetValueIfPresent(__CFAllLocalMessagePorts, name, (const void **)&existing)) {
CFRetain(existing);
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(name);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
if (!CFMessagePortIsValid(existing)) { CFRelease(existing);
existing = NULL;
}
return (CFMessagePortRef)(existing);
}
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFIndex size = sizeof(struct __CFMessagePort) - sizeof(CFRuntimeBase);
memory = (CFMessagePortRef)_CFRuntimeCreateInstance(allocator, __kCFMessagePortTypeID, size, NULL);
if (NULL == memory) {
if (NULL != name) {
CFRelease(name);
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
return NULL;
}
__CFMessagePortUnsetValid(memory);
__CFMessagePortUnsetExtraMachRef(memory);
__CFMessagePortUnsetRemote(memory);
memory->_lock = CFSpinLockInit;
memory->_name = name;
memory->_port = NULL;
memory->_replies = NULL;
memory->_convCounter = 0;
memory->_perPID = perPID ? getpid() : 0; memory->_replyPort = NULL;
memory->_source = NULL;
memory->_dispatchSource = NULL;
memory->_dispatchQ = NULL;
memory->_icallout = NULL;
memory->_callout = callout;
memory->_calloutEx = calloutEx;
memory->_context.info = NULL;
memory->_context.retain = NULL;
memory->_context.release = NULL;
memory->_context.copyDescription = NULL;
if (NULL != name) {
CFMachPortRef native = NULL;
kern_return_t ret;
mach_port_t bs, mp;
task_get_bootstrap_port(mach_task_self(), &bs);
if (!perPID) {
ret = bootstrap_check_in(bs, (char *)utfname, &mp);
if (ret == KERN_SUCCESS) {
ret = mach_port_insert_right(mach_task_self(), mp, mp, MACH_MSG_TYPE_MAKE_SEND);
if (KERN_SUCCESS == ret) {
CFMachPortContext ctx = {0, memory, NULL, NULL, NULL};
native = CFMachPortCreateWithPort(allocator, mp, __CFMessagePortDummyCallback, &ctx, NULL);
__CFMessagePortSetExtraMachRef(memory);
} else {
CFLog(kCFLogLevelDebug, CFSTR("*** CFMessagePort: mach_port_insert_member() after bootstrap_check_in(): failed %d (0x%x) '%s', port = 0x%x, name = '%s'"), ret, ret, bootstrap_strerror(ret), mp, utfname);
mach_port_destroy(mach_task_self(), mp);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
CFRelease(memory);
return NULL;
}
}
}
if (!native) {
CFMachPortContext ctx = {0, memory, NULL, NULL, NULL};
native = CFMachPortCreate(allocator, __CFMessagePortDummyCallback, &ctx, NULL);
if (!native) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
CFRelease(memory);
return NULL;
}
mp = CFMachPortGetPort(native);
ret = bootstrap_register2(bs, (char *)utfname, mp, perPID ? BOOTSTRAP_PER_PID_SERVICE : 0);
if (ret != KERN_SUCCESS) {
CFLog(kCFLogLevelDebug, CFSTR("*** CFMessagePort: bootstrap_register(): failed %d (0x%x) '%s', port = 0x%x, name = '%s'\nSee /usr/include/servers/bootstrap_defs.h for the error codes."), ret, ret, bootstrap_strerror(ret), mp, utfname);
CFMachPortInvalidate(native);
CFRelease(native);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
CFRelease(memory);
return NULL;
}
}
CFMachPortSetInvalidationCallBack(native, __CFMessagePortInvalidationCallBack);
memory->_port = native;
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
__CFMessagePortSetValid(memory);
if (NULL != context) {
memmove(&memory->_context, context, sizeof(CFMessagePortContext));
memory->_context.info = context->retain ? (void *)context->retain(context->info) : context->info;
}
__CFSpinLock(&__CFAllMessagePortsLock);
if (!perPID && NULL != name) {
CFMessagePortRef existing;
if (NULL != __CFAllLocalMessagePorts && CFDictionaryGetValueIfPresent(__CFAllLocalMessagePorts, name, (const void **)&existing)) {
CFRetain(existing);
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(memory);
return (CFMessagePortRef)(existing);
}
if (NULL == __CFAllLocalMessagePorts) {
__CFAllLocalMessagePorts = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, NULL);
}
CFDictionaryAddValue(__CFAllLocalMessagePorts, name, memory);
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
if (shouldFreeInfo) *shouldFreeInfo = false;
return memory;
}
CFMessagePortRef CFMessagePortCreateLocal(CFAllocatorRef allocator, CFStringRef name, CFMessagePortCallBack callout, CFMessagePortContext *context, Boolean *shouldFreeInfo) {
return __CFMessagePortCreateLocal(allocator, name, callout, context, shouldFreeInfo, false, NULL);
}
CFMessagePortRef CFMessagePortCreatePerProcessLocal(CFAllocatorRef allocator, CFStringRef name, CFMessagePortCallBack callout, CFMessagePortContext *context, Boolean *shouldFreeInfo) {
return __CFMessagePortCreateLocal(allocator, name, callout, context, shouldFreeInfo, true, NULL);
}
CFMessagePortRef _CFMessagePortCreateLocalEx(CFAllocatorRef allocator, CFStringRef name, Boolean perPID, uintptr_t unused, CFMessagePortCallBackEx calloutEx, CFMessagePortContext *context, Boolean *shouldFreeInfo) {
return __CFMessagePortCreateLocal(allocator, name, NULL, context, shouldFreeInfo, perPID, calloutEx);
}
static CFMessagePortRef __CFMessagePortCreateRemote(CFAllocatorRef allocator, CFStringRef name, Boolean perPID, CFIndex pid) {
CFMessagePortRef memory;
CFMachPortRef native;
CFMachPortContext ctx;
uint8_t *utfname = NULL;
CFIndex size;
mach_port_t bp, port;
kern_return_t ret;
name = __CFMessagePortSanitizeStringName(name, &utfname, NULL);
if (NULL == name) {
return NULL;
}
__CFSpinLock(&__CFAllMessagePortsLock);
if (!perPID && NULL != name) {
CFMessagePortRef existing;
if (NULL != __CFAllRemoteMessagePorts && CFDictionaryGetValueIfPresent(__CFAllRemoteMessagePorts, name, (const void **)&existing)) {
CFRetain(existing);
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(name);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
if (!CFMessagePortIsValid(existing)) { CFRelease(existing);
existing = NULL;
}
return (CFMessagePortRef)(existing);
}
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
size = sizeof(struct __CFMessagePort) - sizeof(CFMessagePortContext) - sizeof(CFRuntimeBase);
memory = (CFMessagePortRef)_CFRuntimeCreateInstance(allocator, __kCFMessagePortTypeID, size, NULL);
if (NULL == memory) {
if (NULL != name) {
CFRelease(name);
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
return NULL;
}
__CFMessagePortUnsetValid(memory);
__CFMessagePortUnsetExtraMachRef(memory);
__CFMessagePortSetRemote(memory);
memory->_lock = CFSpinLockInit;
memory->_name = name;
memory->_port = NULL;
memory->_replies = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, NULL);
memory->_convCounter = 0;
memory->_perPID = perPID ? pid : 0;
memory->_replyPort = NULL;
memory->_source = NULL;
memory->_dispatchSource = NULL;
memory->_dispatchQ = NULL;
memory->_icallout = NULL;
memory->_callout = NULL;
memory->_calloutEx = NULL;
ctx.version = 0;
ctx.info = memory;
ctx.retain = NULL;
ctx.release = NULL;
ctx.copyDescription = NULL;
task_get_bootstrap_port(mach_task_self(), &bp);
ret = bootstrap_look_up2(bp, (char *)utfname, &port, perPID ? (pid_t)pid : 0, perPID ? BOOTSTRAP_PER_PID_SERVICE : 0);
native = (KERN_SUCCESS == ret) ? CFMachPortCreateWithPort(allocator, port, __CFMessagePortDummyCallback, &ctx, NULL) : NULL;
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
if (NULL == native) {
CFRelease(memory);
return NULL;
}
memory->_port = native;
__CFMessagePortSetValid(memory);
__CFSpinLock(&__CFAllMessagePortsLock);
if (!perPID && NULL != name) {
CFMessagePortRef existing;
if (NULL != __CFAllRemoteMessagePorts && CFDictionaryGetValueIfPresent(__CFAllRemoteMessagePorts, name, (const void **)&existing)) {
CFRetain(existing);
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(memory);
return (CFMessagePortRef)(existing);
}
if (NULL == __CFAllRemoteMessagePorts) {
__CFAllRemoteMessagePorts = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, NULL);
}
CFDictionaryAddValue(__CFAllRemoteMessagePorts, name, memory);
}
CFRetain(native);
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFMachPortSetInvalidationCallBack(native, __CFMessagePortInvalidationCallBack);
if (!CFMachPortIsValid(native)) {
CFRelease(memory); CFRelease(native);
return NULL;
}
CFRelease(native);
return (CFMessagePortRef)memory;
}
CFMessagePortRef CFMessagePortCreateRemote(CFAllocatorRef allocator, CFStringRef name) {
return __CFMessagePortCreateRemote(allocator, name, false, 0);
}
CFMessagePortRef CFMessagePortCreatePerProcessRemote(CFAllocatorRef allocator, CFStringRef name, CFIndex pid) {
return __CFMessagePortCreateRemote(allocator, name, true, pid);
}
Boolean CFMessagePortIsRemote(CFMessagePortRef ms) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
return __CFMessagePortIsRemote(ms);
}
CFStringRef CFMessagePortGetName(CFMessagePortRef ms) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
return ms->_name;
}
Boolean CFMessagePortSetName(CFMessagePortRef ms, CFStringRef name) {
CFAllocatorRef allocator = CFGetAllocator(ms);
uint8_t *utfname = NULL;
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
if (ms->_perPID || __CFMessagePortIsRemote(ms)) return false;
name = __CFMessagePortSanitizeStringName(name, &utfname, NULL);
if (NULL == name) {
return false;
}
__CFSpinLock(&__CFAllMessagePortsLock);
if (NULL != name) {
CFMessagePortRef existing;
if (NULL != __CFAllLocalMessagePorts && CFDictionaryGetValueIfPresent(__CFAllLocalMessagePorts, name, (const void **)&existing)) {
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(name);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
return false;
}
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
if (NULL != name && (NULL == ms->_name || !CFEqual(ms->_name, name))) {
CFMachPortRef oldPort = ms->_port;
CFMachPortRef native = NULL;
kern_return_t ret;
mach_port_t bs, mp;
task_get_bootstrap_port(mach_task_self(), &bs);
ret = bootstrap_check_in(bs, (char *)utfname, &mp);
if (ret == KERN_SUCCESS) {
ret = mach_port_insert_right(mach_task_self(), mp, mp, MACH_MSG_TYPE_MAKE_SEND);
if (KERN_SUCCESS == ret) {
CFMachPortContext ctx = {0, ms, NULL, NULL, NULL};
native = CFMachPortCreateWithPort(allocator, mp, __CFMessagePortDummyCallback, &ctx, NULL);
__CFMessagePortSetExtraMachRef(ms);
} else {
mach_port_destroy(mach_task_self(), mp);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
CFRelease(name);
return false;
}
}
if (!native) {
CFMachPortContext ctx = {0, ms, NULL, NULL, NULL};
native = CFMachPortCreate(allocator, __CFMessagePortDummyCallback, &ctx, NULL);
if (!native) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
CFRelease(name);
return false;
}
mp = CFMachPortGetPort(native);
ret = bootstrap_register2(bs, (char *)utfname, mp, 0);
if (ret != KERN_SUCCESS) {
CFLog(kCFLogLevelDebug, CFSTR("*** CFMessagePort: bootstrap_register(): failed %d (0x%x) '%s', port = 0x%x, name = '%s'\nSee /usr/include/servers/bootstrap_defs.h for the error codes."), ret, ret, bootstrap_strerror(ret), mp, utfname);
CFMachPortInvalidate(native);
CFRelease(native);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
CFRelease(name);
return false;
}
}
CFMachPortSetInvalidationCallBack(native, __CFMessagePortInvalidationCallBack);
ms->_port = native;
if (NULL != oldPort && oldPort != native) {
if (__CFMessagePortExtraMachRef(ms)) {
mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(oldPort), MACH_PORT_RIGHT_SEND, -1);
mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(oldPort), MACH_PORT_RIGHT_RECEIVE, -1);
}
CFMachPortInvalidate(oldPort);
CFRelease(oldPort);
}
__CFSpinLock(&__CFAllMessagePortsLock);
if (NULL == __CFAllLocalMessagePorts) {
__CFAllLocalMessagePorts = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, NULL);
}
if (NULL != ms->_name) {
CFDictionaryRemoveValue(__CFAllLocalMessagePorts, ms->_name);
CFRelease(ms->_name);
}
ms->_name = name;
CFDictionaryAddValue(__CFAllLocalMessagePorts, name, ms);
__CFSpinUnlock(&__CFAllMessagePortsLock);
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, utfname);
return true;
}
void CFMessagePortGetContext(CFMessagePortRef ms, CFMessagePortContext *context) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
CFAssert1(0 == context->version, __kCFLogAssertion, "%s(): context version not initialized to 0", __PRETTY_FUNCTION__);
memmove(context, &ms->_context, sizeof(CFMessagePortContext));
}
void CFMessagePortInvalidate(CFMessagePortRef ms) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
if (!__CFMessagePortIsDeallocing(ms)) {
CFRetain(ms);
}
__CFMessagePortLock(ms);
if (__CFMessagePortIsValid(ms)) {
if (ms->_dispatchSource) {
dispatch_source_cancel(ms->_dispatchSource);
ms->_dispatchSource = NULL;
ms->_dispatchQ = NULL;
}
CFMessagePortInvalidationCallBack callout = ms->_icallout;
CFRunLoopSourceRef source = ms->_source;
CFMachPortRef replyPort = ms->_replyPort;
CFMachPortRef port = ms->_port;
CFStringRef name = ms->_name;
void *info = NULL;
__CFMessagePortUnsetValid(ms);
if (!__CFMessagePortIsRemote(ms)) {
info = ms->_context.info;
ms->_context.info = NULL;
}
ms->_source = NULL;
ms->_replyPort = NULL;
ms->_port = NULL;
__CFMessagePortUnlock(ms);
__CFSpinLock(&__CFAllMessagePortsLock);
if (0 == ms->_perPID && NULL != name && NULL != (__CFMessagePortIsRemote(ms) ? __CFAllRemoteMessagePorts : __CFAllLocalMessagePorts)) {
CFDictionaryRemoveValue(__CFMessagePortIsRemote(ms) ? __CFAllRemoteMessagePorts : __CFAllLocalMessagePorts, name);
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
if (NULL != callout) {
callout(ms, info);
}
if (!__CFMessagePortIsRemote(ms) && NULL != ms->_context.release) {
ms->_context.release(info);
}
if (NULL != source) {
CFRunLoopSourceInvalidate(source);
CFRelease(source);
}
if (NULL != replyPort) {
CFMachPortInvalidate(replyPort);
CFRelease(replyPort);
}
if (__CFMessagePortIsRemote(ms)) {
mach_port_deallocate(mach_task_self(), CFMachPortGetPort(port));
}
if (NULL != port) {
CFMachPortSetInvalidationCallBack(port, NULL);
if (__CFMessagePortExtraMachRef(ms)) {
mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(port), MACH_PORT_RIGHT_SEND, -1);
mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(port), MACH_PORT_RIGHT_RECEIVE, -1);
}
CFMachPortInvalidate(port);
CFRelease(port);
}
} else {
__CFMessagePortUnlock(ms);
}
if (!__CFMessagePortIsDeallocing(ms)) {
CFRelease(ms);
}
}
Boolean CFMessagePortIsValid(CFMessagePortRef ms) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
if (!__CFMessagePortIsValid(ms)) return false;
CFRetain(ms);
if (NULL != ms->_port && !CFMachPortIsValid(ms->_port)) {
CFMessagePortInvalidate(ms);
CFRelease(ms);
return false;
}
if (NULL != ms->_replyPort && !CFMachPortIsValid(ms->_replyPort)) {
CFMessagePortInvalidate(ms);
CFRelease(ms);
return false;
}
CFRelease(ms);
return true;
}
CFMessagePortInvalidationCallBack CFMessagePortGetInvalidationCallBack(CFMessagePortRef ms) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
return ms->_icallout;
}
void CFMessagePortSetInvalidationCallBack(CFMessagePortRef ms, CFMessagePortInvalidationCallBack callout) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
if (!__CFMessagePortIsValid(ms) && NULL != callout) {
callout(ms, ms->_context.info);
} else {
ms->_icallout = callout;
}
}
static void __CFMessagePortReplyCallBack(CFMachPortRef port, void *msg, CFIndex size, void *info) {
CFMessagePortRef ms = info;
mach_msg_base_t *msgp = msg;
mach_msg_base_t *replymsg;
__CFMessagePortLock(ms);
if (!__CFMessagePortIsValid(ms)) {
__CFMessagePortUnlock(ms);
return;
}
int32_t byteslen = 0;
Boolean invalidMagic = (MSGP_GET(msgp, magic) != MAGIC) && (CFSwapInt32(MSGP_GET(msgp, magic)) != MAGIC);
Boolean invalidComplex = (0 != msgp->body.msgh_descriptor_count) && !(msgp->header.msgh_bits & MACH_MSGH_BITS_COMPLEX);
invalidComplex = invalidComplex || ((msgp->header.msgh_bits & MACH_MSGH_BITS_COMPLEX) && (0 == msgp->body.msgh_descriptor_count));
Boolean wayTooBig = ((msgp->body.msgh_descriptor_count) ? sizeof(struct __CFMessagePortMachMessage1) : sizeof(struct __CFMessagePortMachMessage0) + __CFMessagePortMaxInlineBytes) < msgp->header.msgh_size;
Boolean wayTooSmall = msgp->header.msgh_size < sizeof(struct __CFMessagePortMachMessage0);
Boolean wrongSize = false;
if (!(invalidComplex || wayTooBig || wayTooSmall)) {
byteslen = CFSwapInt32LittleToHost(MSGP_GET(msgp, byteslen));
wrongSize = (byteslen < 0) || (__CFMessagePortMaxDataSize < byteslen);
if (0 != msgp->body.msgh_descriptor_count) {
wrongSize = wrongSize || (MSGP1_FIELD(msgp, ool).size != byteslen);
} else {
wrongSize = wrongSize || (msgp->header.msgh_size - sizeof(struct __CFMessagePortMachMessage0) < byteslen);
}
}
Boolean invalidMsgID = (0 <= msgp->header.msgh_id) && (msgp->header.msgh_id <= INT32_MAX); if (invalidMagic || invalidComplex || wayTooBig || wayTooSmall || wrongSize || invalidMsgID) {
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePort: dropping corrupt reply Mach message (0b%d%d%d%d%d%d)"), invalidMagic, invalidComplex, wayTooBig, wayTooSmall, wrongSize, invalidMsgID);
mach_msg_destroy((mach_msg_header_t *)msgp);
__CFMessagePortUnlock(ms);
return;
}
if (CFDictionaryContainsKey(ms->_replies, (void *)(uintptr_t)msgp->header.msgh_id)) {
CFDataRef reply = NULL;
replymsg = (mach_msg_base_t *)msg;
if (0 == replymsg->body.msgh_descriptor_count) {
uintptr_t msgp_extent = (uintptr_t)((uint8_t *)msgp + msgp->header.msgh_size);
uintptr_t data_extent = (uintptr_t)((uint8_t *)&(MSGP0_FIELD(replymsg, bytes)) + byteslen);
if (0 <= byteslen && data_extent <= msgp_extent) {
reply = CFDataCreate(kCFAllocatorSystemDefault, MSGP0_FIELD(replymsg, bytes), byteslen);
} else {
reply = (void *)~0; }
} else {
reply = CFDataCreate(kCFAllocatorSystemDefault, MSGP1_FIELD(replymsg, ool).address, MSGP1_FIELD(replymsg, ool).size);
vm_deallocate(mach_task_self(), (vm_address_t)MSGP1_FIELD(replymsg, ool).address, MSGP1_FIELD(replymsg, ool).size);
}
CFDictionarySetValue(ms->_replies, (void *)(uintptr_t)msgp->header.msgh_id, (void *)reply);
} else {
if (1 == msgp->body.msgh_descriptor_count) {
vm_deallocate(mach_task_self(), (vm_address_t)MSGP1_FIELD(msgp, ool).address, MSGP1_FIELD(msgp, ool).size);
}
}
__CFMessagePortUnlock(ms);
}
SInt32 CFMessagePortSendRequest(CFMessagePortRef remote, SInt32 msgid, CFDataRef data, CFTimeInterval sendTimeout, CFTimeInterval rcvTimeout, CFStringRef replyMode, CFDataRef *returnDatap) {
mach_msg_base_t *sendmsg;
CFRunLoopRef currentRL = CFRunLoopGetCurrent();
CFRunLoopSourceRef source = NULL;
CFDataRef reply = NULL;
int64_t termTSR;
uint32_t sendOpts = 0, sendTimeOut = 0;
int32_t desiredReply;
Boolean didRegister = false;
kern_return_t ret;
if (data && __CFMessagePortMaxDataSize < CFDataGetLength(data)) {
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePortSendRequest: CFMessagePort cannot send more than %lu bytes of data"), __CFMessagePortMaxDataSize);
return kCFMessagePortTransportError;
}
__CFMessagePortLock(remote);
if (!__CFMessagePortIsValid(remote)) {
__CFMessagePortUnlock(remote);
return kCFMessagePortIsInvalid;
}
CFRetain(remote); if (NULL == remote->_replyPort) {
CFMachPortContext context;
context.version = 0;
context.info = remote;
context.retain = (const void *(*)(const void *))CFRetain;
context.release = (void (*)(const void *))CFRelease;
context.copyDescription = (CFStringRef (*)(const void *))__CFMessagePortCopyDescription;
remote->_replyPort = CFMachPortCreate(CFGetAllocator(remote), __CFMessagePortReplyCallBack, &context, NULL);
}
remote->_convCounter++;
desiredReply = -remote->_convCounter;
sendmsg = __CFMessagePortCreateMessage(false, CFMachPortGetPort(remote->_port), (replyMode != NULL ? CFMachPortGetPort(remote->_replyPort) : MACH_PORT_NULL), -desiredReply, msgid, (data ? CFDataGetBytePtr(data) : NULL), (data ? CFDataGetLength(data) : 0));
if (!sendmsg) {
__CFMessagePortUnlock(remote);
CFRelease(remote);
return kCFMessagePortTransportError;
}
if (replyMode != NULL) {
CFDictionarySetValue(remote->_replies, (void *)(uintptr_t)desiredReply, NULL);
source = CFMachPortCreateRunLoopSource(CFGetAllocator(remote), remote->_replyPort, -100);
didRegister = !CFRunLoopContainsSource(currentRL, source, replyMode);
if (didRegister) {
CFRunLoopAddSource(currentRL, source, replyMode);
}
}
if (sendTimeout < 10.0*86400) {
sendOpts = MACH_SEND_TIMEOUT;
sendTimeout *= 1000.0;
if (sendTimeout < 1.0) sendTimeout = 0.0;
sendTimeOut = floor(sendTimeout);
}
__CFMessagePortUnlock(remote);
ret = mach_msg((mach_msg_header_t *)sendmsg, MACH_SEND_MSG|sendOpts, sendmsg->header.msgh_size, 0, MACH_PORT_NULL, sendTimeOut, MACH_PORT_NULL);
__CFMessagePortLock(remote);
if (KERN_SUCCESS != ret) {
if (replyMode != NULL) mach_port_deallocate(mach_task_self(), ((mach_msg_header_t *)sendmsg)->msgh_local_port);
if (didRegister) {
CFRunLoopRemoveSource(currentRL, source, replyMode);
}
if (source) CFRelease(source);
__CFMessagePortUnlock(remote);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, sendmsg);
CFRelease(remote);
return (MACH_SEND_TIMED_OUT == ret) ? kCFMessagePortSendTimeout : kCFMessagePortTransportError;
}
__CFMessagePortUnlock(remote);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, sendmsg);
if (replyMode == NULL) {
CFRelease(remote);
return kCFMessagePortSuccess;
}
_CFMachPortInstallNotifyPort(currentRL, replyMode);
termTSR = mach_absolute_time() + __CFTimeIntervalToTSR(rcvTimeout);
for (;;) {
CFRunLoopRunInMode(replyMode, __CFTSRToTimeInterval(termTSR - mach_absolute_time()), true);
reply = CFDictionaryGetValue(remote->_replies, (void *)(uintptr_t)desiredReply);
if (NULL != reply || termTSR < (int64_t)mach_absolute_time()) {
break;
}
if (!CFMessagePortIsValid(remote)) {
break;
}
}
if (didRegister) {
CFRunLoopRemoveSource(currentRL, source, replyMode);
}
if (source) CFRelease(source);
if (NULL == reply) {
CFDictionaryRemoveValue(remote->_replies, (void *)(uintptr_t)desiredReply);
CFRelease(remote);
return CFMessagePortIsValid(remote) ? kCFMessagePortReceiveTimeout : kCFMessagePortBecameInvalidError;
}
if (NULL != returnDatap) {
*returnDatap = ((void *)~0 == reply) ? NULL : reply;
} else if ((void *)~0 != reply) {
CFRelease(reply);
}
CFDictionaryRemoveValue(remote->_replies, (void *)(uintptr_t)desiredReply);
CFRelease(remote);
return kCFMessagePortSuccess;
}
static mach_port_t __CFMessagePortGetPort(void *info) {
CFMessagePortRef ms = info;
if (!ms->_port && __CFMessagePortIsValid(ms)) CFLog(kCFLogLevelWarning, CFSTR("*** Warning: A local CFMessagePort (%p) is being put in a run loop or dispatch queue, but it has not been named yet, so this will be a no-op and no messages are going to be received, even if named later."), info);
return ms->_port ? CFMachPortGetPort(ms->_port) : MACH_PORT_NULL;
}
static void *__CFMessagePortPerform(void *msg, CFIndex size, CFAllocatorRef allocator, void *info) {
CFMessagePortRef ms = info;
mach_msg_base_t *msgp = msg;
mach_msg_base_t *replymsg;
void *context_info;
void (*context_release)(const void *);
CFDataRef returnData, data = NULL;
void *return_bytes = NULL;
CFIndex return_len = 0;
int32_t msgid;
__CFMessagePortLock(ms);
if (!__CFMessagePortIsValid(ms)) {
__CFMessagePortUnlock(ms);
return NULL;
}
if (NULL != ms->_context.retain) {
context_info = (void *)ms->_context.retain(ms->_context.info);
context_release = ms->_context.release;
} else {
context_info = ms->_context.info;
context_release = NULL;
}
__CFMessagePortUnlock(ms);
int32_t byteslen = 0;
Boolean invalidMagic = (MSGP_GET(msgp, magic) != MAGIC) && (CFSwapInt32(MSGP_GET(msgp, magic)) != MAGIC);
Boolean invalidComplex = (0 != msgp->body.msgh_descriptor_count) && !(msgp->header.msgh_bits & MACH_MSGH_BITS_COMPLEX);
invalidComplex = invalidComplex || ((msgp->header.msgh_bits & MACH_MSGH_BITS_COMPLEX) && (0 == msgp->body.msgh_descriptor_count));
Boolean wayTooBig = ((msgp->body.msgh_descriptor_count) ? sizeof(struct __CFMessagePortMachMessage1) : sizeof(struct __CFMessagePortMachMessage0) + __CFMessagePortMaxInlineBytes) < msgp->header.msgh_size;
Boolean wayTooSmall = msgp->header.msgh_size < sizeof(struct __CFMessagePortMachMessage0);
Boolean wrongSize = false;
if (!(invalidComplex || wayTooBig || wayTooSmall)) {
byteslen = CFSwapInt32LittleToHost(MSGP_GET(msgp, byteslen));
wrongSize = (byteslen < 0) || (__CFMessagePortMaxDataSize < byteslen);
if (0 != msgp->body.msgh_descriptor_count) {
wrongSize = wrongSize || (MSGP1_FIELD(msgp, ool).size != byteslen);
} else {
wrongSize = wrongSize || (msgp->header.msgh_size - sizeof(struct __CFMessagePortMachMessage0) < byteslen);
}
}
Boolean invalidMsgID = (msgp->header.msgh_id <= 0) || (INT32_MAX < msgp->header.msgh_id); if (invalidMagic || invalidComplex || wayTooBig || wayTooSmall || wrongSize || invalidMsgID) {
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePort: dropping corrupt request Mach message (0b%d%d%d%d%d%d)"), invalidMagic, invalidComplex, wayTooBig, wayTooSmall, wrongSize, invalidMsgID);
mach_msg_destroy((mach_msg_header_t *)msgp);
return NULL;
}
if (0 == msgp->body.msgh_descriptor_count) {
uintptr_t msgp_extent = (uintptr_t)((uint8_t *)msgp + msgp->header.msgh_size);
uintptr_t data_extent = (uintptr_t)((uint8_t *)&(MSGP0_FIELD(msgp, bytes)) + byteslen);
msgid = CFSwapInt32LittleToHost(MSGP_GET(msgp, msgid));
if (0 <= byteslen && data_extent <= msgp_extent) {
data = CFDataCreateWithBytesNoCopy(allocator, MSGP0_FIELD(msgp, bytes), byteslen, kCFAllocatorNull);
}
} else {
msgid = CFSwapInt32LittleToHost(MSGP_GET(msgp, msgid));
data = CFDataCreateWithBytesNoCopy(allocator, MSGP1_FIELD(msgp, ool).address, MSGP1_FIELD(msgp, ool).size, kCFAllocatorNull);
}
if (ms->_callout) {
returnData = ms->_callout(ms, msgid, data, context_info);
} else {
mach_msg_trailer_t *trailer = (mach_msg_trailer_t *)(((uintptr_t)&(msgp->header) + msgp->header.msgh_size + sizeof(natural_t) - 1) & ~(sizeof(natural_t) - 1));
returnData = ms->_calloutEx(ms, msgid, data, context_info, trailer, 0);
}
if (NULL != returnData) {
return_len = CFDataGetLength(returnData);
if (__CFMessagePortMaxDataSize < return_len) {
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePort reply: CFMessagePort cannot send more than %lu bytes of data"), __CFMessagePortMaxDataSize);
return_len = 0;
returnData = NULL;
}
if (returnData && return_len < __CFMessagePortMaxInlineBytes) {
return_bytes = (void *)CFDataGetBytePtr(returnData);
} else if (returnData) {
return_bytes = NULL;
vm_allocate(mach_task_self(), (vm_address_t *)&return_bytes, return_len, VM_FLAGS_ANYWHERE | VM_MAKE_TAG(VM_MEMORY_MACH_MSG));
memmove(return_bytes, CFDataGetBytePtr(returnData), return_len);
}
}
replymsg = __CFMessagePortCreateMessage(true, msgp->header.msgh_remote_port, MACH_PORT_NULL, -1 * (int32_t)msgp->header.msgh_id, msgid, return_bytes, return_len);
if (1 == replymsg->body.msgh_descriptor_count) {
MSGP1_FIELD(replymsg, ool).deallocate = true;
}
if (data) CFRelease(data);
if (1 == msgp->body.msgh_descriptor_count) {
vm_deallocate(mach_task_self(), (vm_address_t)MSGP1_FIELD(msgp, ool).address, MSGP1_FIELD(msgp, ool).size);
}
if (returnData) CFRelease(returnData);
if (context_release) {
context_release(context_info);
}
return replymsg;
}
CFRunLoopSourceRef CFMessagePortCreateRunLoopSource(CFAllocatorRef allocator, CFMessagePortRef ms, CFIndex order) {
CFRunLoopSourceRef result = NULL;
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
if (!CFMessagePortIsValid(ms)) return NULL;
if (__CFMessagePortIsRemote(ms)) return NULL;
__CFMessagePortLock(ms);
if (NULL != ms->_source && !CFRunLoopSourceIsValid(ms->_source)) {
CFRelease(ms->_source);
ms->_source = NULL;
}
if (NULL == ms->_source && NULL == ms->_dispatchSource && __CFMessagePortIsValid(ms)) {
CFRunLoopSourceContext1 context;
context.version = 1;
context.info = (void *)ms;
context.retain = (const void *(*)(const void *))CFRetain;
context.release = (void (*)(const void *))CFRelease;
context.copyDescription = (CFStringRef (*)(const void *))__CFMessagePortCopyDescription;
context.equal = NULL;
context.hash = NULL;
context.getPort = __CFMessagePortGetPort;
context.perform = __CFMessagePortPerform;
ms->_source = CFRunLoopSourceCreate(allocator, order, (CFRunLoopSourceContext *)&context);
}
if (NULL != ms->_source) {
result = (CFRunLoopSourceRef)CFRetain(ms->_source);
}
__CFMessagePortUnlock(ms);
return result;
}
void CFMessagePortSetDispatchQueue(CFMessagePortRef ms, dispatch_queue_t queue) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
__CFMessagePortLock(ms);
if (!__CFMessagePortIsValid(ms)) {
__CFMessagePortUnlock(ms);
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePortSetDispatchQueue(): CFMessagePort is invalid"));
return;
}
if (__CFMessagePortIsRemote(ms)) {
__CFMessagePortUnlock(ms);
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePortSetDispatchQueue(): CFMessagePort is not a local port, queue cannot be set"));
return;
}
if (NULL != ms->_source) {
__CFMessagePortUnlock(ms);
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePortSetDispatchQueue(): CFMessagePort already has a CFRunLoopSourceRef, queue cannot be set"));
return;
}
if (ms->_dispatchSource) {
dispatch_source_cancel(ms->_dispatchSource);
ms->_dispatchSource = NULL;
ms->_dispatchQ = NULL;
}
if (queue) {
mach_port_t port = __CFMessagePortGetPort(ms);
if (MACH_PORT_NULL != port) {
static dispatch_queue_t mportQueue = NULL;
static dispatch_once_t once;
dispatch_once(&once, ^{
mportQueue = dispatch_queue_create("CFMessagePort Queue", NULL);
});
dispatch_source_t theSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_MACH_RECV, port, 0, mportQueue);
dispatch_source_set_cancel_handler(theSource, ^{
dispatch_release(queue);
dispatch_release(theSource);
});
dispatch_source_set_event_handler(theSource, ^{
CFRetain(ms);
mach_msg_header_t *msg = (mach_msg_header_t *)CFAllocatorAllocate(kCFAllocatorSystemDefault, 2048, 0);
msg->msgh_size = 2048;
for (;;) {
msg->msgh_bits = 0;
msg->msgh_local_port = port;
msg->msgh_remote_port = MACH_PORT_NULL;
msg->msgh_id = 0;
kern_return_t ret = mach_msg(msg, MACH_RCV_MSG|MACH_RCV_LARGE|MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0)|MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AV), 0, msg->msgh_size, port, 0, MACH_PORT_NULL);
if (MACH_MSG_SUCCESS == ret) break;
if (MACH_RCV_TOO_LARGE != ret) HALT;
uint32_t newSize = round_msg(msg->msgh_size + MAX_TRAILER_SIZE);
msg = CFAllocatorReallocate(kCFAllocatorSystemDefault, msg, newSize, 0);
msg->msgh_size = newSize;
}
dispatch_async(queue, ^{
mach_msg_header_t *reply = __CFMessagePortPerform(msg, msg->msgh_size, kCFAllocatorSystemDefault, ms);
if (NULL != reply) {
kern_return_t ret = mach_msg(reply, MACH_SEND_MSG, reply->msgh_size, 0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
if (KERN_SUCCESS != ret) mach_msg_destroy(reply);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, reply);
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, msg);
CFRelease(ms);
});
});
ms->_dispatchSource = theSource;
}
if (ms->_dispatchSource) {
dispatch_retain(queue);
ms->_dispatchQ = queue;
dispatch_resume(ms->_dispatchSource);
} else {
CFLog(kCFLogLevelWarning, CFSTR("*** CFMessagePortSetDispatchQueue(): dispatch source could not be created"));
}
}
__CFMessagePortUnlock(ms);
}