void DNSXRefDeAlloc(DNSXConnRef connRef)
{
if (connRef == NULL)
{
os_log(OS_LOG_DEFAULT, "dns_services: DNSXRefDeAlloc called with NULL DNSXConnRef");
return;
}
// Schedule this work on the internal library queue
dispatch_sync(connRef->lib_q, ^{
xpc_connection_set_event_handler((connRef)->conn_ref, ^(__unused xpc_object_t event){}); // ignore any more events
xpc_release(connRef->conn_ref);
connRef->conn_ref = NULL;
dispatch_release(connRef->lib_q);
connRef->lib_q = NULL;
connRef->AppCallBack = NULL;
os_log_info(OS_LOG_DEFAULT, "dns_services: DNSXRefDeAlloc successfully DeAllocated conn_ref & lib_q");
dispatch_async((connRef)->client_q, ^{
dispatch_release(connRef->client_q);
connRef->client_q = NULL;
free(connRef);
os_log_info(OS_LOG_DEFAULT, "dns_services: DNSXRefDeAlloc successfully DeAllocated client_q & freed connRef");
});
});
int
smb_gss_get_cred_list(struct smb_gss_cred_list **list, gss_OID mech)
{
struct cred_iter_ctx ctx;
ctx.s = dispatch_semaphore_create(0);
if (ctx.s == NULL)
return ENOMEM;
ctx.clist = malloc(sizeof (struct smb_gss_cred_list));
if (ctx.clist == NULL) {
dispatch_release(ctx.s);
return ENOMEM;
}
TAILQ_INIT(ctx.clist);
gss_iter_creds_f(NULL, 0, mech, &ctx, cred_iter);
dispatch_semaphore_wait(ctx.s, DISPATCH_TIME_FOREVER);
dispatch_release(ctx.s);
*list = ctx.clist;
return 0;
}
static bool
_dispatch_transform_buffer_new(dispatch_transform_buffer_s *buffer,
size_t required, size_t size)
{
size_t remaining = buffer->size - (buffer->ptr.u8 - buffer->start);
if (required == 0 || remaining < required) {
if (buffer->start) {
if (buffer->ptr.u8 > buffer->start) {
dispatch_data_t _new = dispatch_data_create(buffer->start,
buffer->ptr.u8 - buffer->start, NULL,
DISPATCH_DATA_DESTRUCTOR_FREE);
dispatch_data_t _concat = dispatch_data_create_concat(
buffer->data, _new);
dispatch_release(_new);
dispatch_release(buffer->data);
buffer->data = _concat;
} else {
free(buffer->start);
}
}
buffer->size = required + size;
buffer->start = NULL;
if (buffer->size > 0) {
if (buffer->size > BUFFER_MALLOC_MAX) {
return false;
}
buffer->start = (uint8_t*)malloc(buffer->size);
if (buffer->start == NULL) {
return false;
}
}
buffer->ptr.u8 = buffer->start;
}
return true;
}
static bool
dispatch_test_check_evfilt_vm(void)
{
int kq = kqueue();
assert(kq != -1);
struct kevent ke = {
.filter = EVFILT_VM,
.flags = EV_ADD|EV_ENABLE|EV_RECEIPT,
.fflags = NOTE_VM_PRESSURE,
};
int r = kevent(kq, &ke, 1, &ke, 1, NULL);
close(kq);
return !(r > 0 && ke.flags & EV_ERROR && ke.data == ENOTSUP);
}
static void
cleanup(void)
{
dispatch_source_cancel(vm_source);
dispatch_release(vm_source);
dispatch_release(vm_queue);
int32_t pc = 0, i;
for (i = 0; i < max_page_count; ++i) {
if (pages[i]) {
pc++;
free(pages[i]);
}
}
if (pc) {
log_msg("Freed %ldMB\n", pg2mb(pc));
}
free(pages);
test_stop();
}
static void
gcdpoll_watch_free(AvahiWatch *w)
{
AvahiWatch *prev;
AvahiWatch *cur;
if (w->w_read)
{
dispatch_source_cancel(w->w_read);
dispatch_release(w->w_read);
}
if (w->w_write)
{
dispatch_source_cancel(w->w_write);
dispatch_release(w->w_write);
}
prev = NULL;
for (cur = all_w; cur; prev = cur, cur = cur->next)
{
if (cur != w)
continue;
if (prev == NULL)
all_w = w->next;
else
prev->next = w->next;
break;
}
free(w);
}
static void
mdns_deinit_task(void *arg)
{
struct mdns_group_entry *ge;
struct mdns_browser *mb;
AvahiWatch *w;
AvahiTimeout *t;
if (mdns_client)
avahi_client_free(mdns_client);
for (t = all_t; t; t = t->next)
{
if (t->timer)
{
dispatch_source_cancel(t->timer);
dispatch_release(t->timer);
t->timer = NULL;
}
}
for (w = all_w; w; w = w->next)
{
if (w->w_read)
{
dispatch_source_cancel(w->w_read);
dispatch_release(w->w_read);
}
if (w->w_write)
{
dispatch_source_cancel(w->w_write);
dispatch_release(w->w_write);
}
}
for (ge = group_entries; group_entries; ge = group_entries)
{
group_entries = ge->next;
free(ge->name);
free(ge->type);
avahi_string_list_free(ge->txt);
free(ge);
}
for (mb = browser_list; browser_list; mb = browser_list)
{
browser_list = mb->next;
free(mb->type);
free(mb);
}
}
/*
* This does the actual free.
* It is dispatched on the timer's dispatch source queue to make it safe.
*/
static void
timer_free(timer_t *t)
{
if (t == NULL) return;
if (t->deactivation_handler != NULL) Block_release(t->deactivation_handler);
if (t->contextp != NULL) free(t->contextp);
dispatch_release(t->t_src);
dispatch_release(t->t_queue);
memset(t, 0, sizeof(timer_t));
free(t);
}
static void cancelRepeatingTimer(struct nodeInstanceData *ctx)
{
dispatch_source_cancel(ctx->timer);
dispatch_release(ctx->timer);
ctx->timer = NULL;
dispatch_semaphore_wait(ctx->timerCanceled, DISPATCH_TIME_FOREVER);
}
static dispatch_data_t
execute_sectransform(SecTransformRef transformRef, dispatch_data_t data)
{
const void * bytes;
size_t size;
dispatch_data_t map = dispatch_data_create_map(data, &bytes, &size);
assert(map);
CFDataRef dataRef = CFDataCreate(kCFAllocatorDefault, bytes, size);
assert(dataRef);
dispatch_release(map);
SecTransformSetAttribute(transformRef, kSecTransformInputAttributeName, dataRef, NULL);
CFDataRef transformedDataRef = SecTransformExecute(transformRef, NULL);
assert(transformedDataRef);
CFRelease(dataRef);
dispatch_data_t output = dispatch_data_create(CFDataGetBytePtr(transformedDataRef), CFDataGetLength(transformedDataRef), dispatch_get_main_queue(), DISPATCH_DATA_DESTRUCTOR_DEFAULT);
CFRelease(transformedDataRef);
return output;
}
/*
* pj_sem_destroy()
*/
PJ_DEF(pj_status_t) pj_sem_destroy(pj_sem_t *sem)
{
#if PJ_HAS_THREADS
int result;
PJ_CHECK_STACK();
PJ_ASSERT_RETURN(sem, PJ_EINVAL);
PJ_LOG(6, (sem->obj_name, "Semaphore destroyed by thread %s",
pj_thread_this(sem->inst_id)->obj_name));
#if defined(PJ_DARWINOS) && PJ_DARWINOS!=0
#if 1
dispatch_release(sem->sem);
result = 0;
#else
result = sem_close( sem->sem );
#endif
#else
result = sem_destroy( sem->sem );
#endif
if (result == 0)
return PJ_SUCCESS;
else
return PJ_RETURN_OS_ERROR(pj_get_native_os_error());
#else
pj_assert( sem == (pj_sem_t*) 1 );
return PJ_SUCCESS;
#endif
}
void
test_timer(void)
{
dispatch_test_start("Dispatch Update Timer");
dispatch_queue_t main_q = dispatch_get_main_queue();
//test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
__block int i = 0;
struct timeval start_time;
gettimeofday(&start_time, NULL);
dispatch_source_t s = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, main_q);
test_ptr_notnull("dispatch_source_create", s);
dispatch_source_set_timer(s, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC), NSEC_PER_SEC, 0);
dispatch_source_set_cancel_handler(s, ^{
struct timeval end_time;
gettimeofday(&end_time, NULL);
// Make sure we actually managed to adjust the interval
// duration. Seven one second ticks would blow past
// this.
test_long_less_than("total duration", end_time.tv_sec - start_time.tv_sec, 3);
test_stop();
dispatch_release(s);
});
void SDMMD_USBMuxListenerSend(SDMMD_USBMuxListenerRef listener, struct USBMuxPacket **packet) {
listener->ivars.semaphore = dispatch_semaphore_create(0x0);
SDMMD_USBMuxSend(listener->ivars.socket, *packet);
dispatch_semaphore_wait(listener->ivars.semaphore, (*packet)->timeout);
CFMutableArrayRef updateWithRemove = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0x0, listener->ivars.responses);
struct USBMuxPacket *responsePacket = NULL;
uint32_t removeCounter = 0x0;
for (uint32_t i = 0x0; i < CFArrayGetCount(listener->ivars.responses); i++) {
struct USBMuxPacket *response = (struct USBMuxPacket *)CFArrayGetValueAtIndex(listener->ivars.responses, i);
if ((*packet)->body.tag == response->body.tag) {
responsePacket = response;
CFArrayRemoveValueAtIndex(updateWithRemove, i-removeCounter);
removeCounter++;
}
}
CFSafeRelease(listener->ivars.responses);
listener->ivars.responses = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0x0, updateWithRemove);
CFSafeRelease(updateWithRemove);
USBMuxPacketRelease(*packet);
if (!responsePacket) {
responsePacket = (struct USBMuxPacket *)calloc(0x1, sizeof(struct USBMuxPacket));
}
*packet = responsePacket;
dispatch_release(listener->ivars.semaphore);
}
static void do_test(void)
{
size_t i;
char buf[1000];
dispatch_group_t g = dispatch_group_create();
for (i = 0; i < QUEUES; i++) {
#ifdef WIN32
_snprintf(buf, sizeof(buf), "com.example.memoryload-node#%ld", i);
#else
snprintf(buf, sizeof(buf), "com.example.memoryload-node#%ld", (long int)i);
#endif
queues[i] = dispatch_queue_create(buf, NULL);
dispatch_suspend(queues[i]);
}
for (i = 0; i < QUEUES; i++) {
dispatch_group_async_f(g, queues[i], g, start_node);
}
dispatch_group_notify_f(g, dispatch_get_main_queue(), NULL, collect);
for (i = 0; i < QUEUES; i++) {
dispatch_resume(queues[i]);
dispatch_release(queues[i]);
}
}
static void
gcdpoll_timeout_free(AvahiTimeout *t)
{
AvahiTimeout *prev;
AvahiTimeout *cur;
if (t->timer)
{
dispatch_source_cancel(t->timer);
dispatch_release(t->timer);
t->timer = NULL;
}
prev = NULL;
for (cur = all_t; cur; prev = cur, cur = cur->next)
{
if (cur != t)
continue;
if (prev == NULL)
all_t = t->next;
else
prev->next = t->next;
break;
}
free(t);
}
void
mdns_deinit(void)
{
dispatch_sync_f(mdns_sq, NULL, mdns_deinit_task);
dispatch_release(mdns_sq);
}
WEAK void halide_mutex_cleanup(halide_mutex *mutex_arg) {
gcd_mutex *mutex = (gcd_mutex *)mutex_arg;
if (mutex->once != 0) {
dispatch_release(mutex->semaphore);
memset(mutex_arg, 0, sizeof(halide_mutex));
}
}
void
_notify_lib_port_proc_release(notify_state_t *ns, mach_port_t port, pid_t proc)
{
portproc_data_t *pdata = NULL;
if (ns == NULL) return;
if ((proc == 0) && (port == MACH_PORT_NULL)) return;
if (ns->lock != NULL) pthread_mutex_lock(ns->lock);
if (proc == 0) pdata = _nc_table_find_n(ns->port_table, port);
else pdata = _nc_table_find_n(ns->proc_table, proc);
if (pdata != NULL)
{
if (pdata->refcount > 0) pdata->refcount--;
if (pdata->refcount == 0)
{
if (proc == 0) _nc_table_delete_n(ns->port_table, port);
else _nc_table_delete_n(ns->proc_table, proc);
dispatch_source_cancel(pdata->src);
dispatch_release(pdata->src);
free(pdata);
}
}
if (ns->lock != NULL) pthread_mutex_unlock(ns->lock);
}
int
mdns_init(void)
{
DPRINTF(E_DBG, L_MDNS, "Initializing Avahi mDNS\n");
all_w = NULL;
all_t = NULL;
group_entries = NULL;
browser_list = NULL;
mdns_sq = dispatch_queue_create("org.forked-daapd.mdns", NULL);
if (!mdns_sq)
{
DPRINTF(E_FATAL, L_MDNS, "mdns_init: Could not create dispatch queue\n");
return -1;
}
dispatch_sync_f(mdns_sq, NULL, mdns_init_task);
if (!mdns_client)
goto client_fail;
return 0;
client_fail:
dispatch_release(mdns_sq);
return -1;
}
void
test_fin(void *cxt)
{
fprintf(stderr, "Called back every %llu us on average\n",
(delay/count)/NSEC_PER_USEC);
test_long_less_than("Frequency", 1, ceil((double)delay/(count*interval)));
int i;
for (i = 0; i < N; i++) {
dispatch_source_cancel(t[i]);
dispatch_release(t[i]);
}
dispatch_resume(q);
dispatch_release(q);
dispatch_release(g);
test_ptr("finalizer ran", cxt, cxt);
test_stop();
}
static void closeSocketClient(SocketClientRef client)
{
dispatch_resume(client->source);
dispatch_source_cancel(client->source);
dispatch_release(client->source);
close(client->fd);
free(client);
}
void __Platform_Red_Threading_Semaphore_Destroy ( __Platform_Semaphore_t & ToDestroy )
{
dispatch_release ( ToDestroy );
ToDestroy = NULL;
}
__attribute__((noreturn)) static void
xpc_server_exit(int status)
{
xpc_connection_cancel(listener);
xpc_release(listener);
dispatch_release(serverq);
exit(status);
}
TCController::~TCController()
{
TCDebugLog("TCController Destructor");
// Close client
size_t i, cnt = clients.size();
for (i = 0; i < cnt; i++)
{
clients[i]->stop();
clients[i]->release();
}
clients.clear();
// Stop buddies
cnt = buddies.size();
for (i = 0; i < cnt; i++)
{
buddies[i]->stop();
buddies[i]->release();
}
buddies.clear();
// Release delegate
if (nBlock)
Block_release(nBlock);
nBlock = NULL;
if (nQueue)
dispatch_release(nQueue);
nQueue = 0;
// Release config
config->release();
// Release avatar
pavatar->release();
// Release
dispatch_release(mainQueue);
dispatch_release(socketQueue);
}
void WorkQueue::platformInvalidate()
{
#if !ASSERT_DISABLED
MutexLocker locker(m_eventSourcesMutex);
ASSERT(m_eventSources.isEmpty());
#endif
dispatch_release(m_dispatchQueue);
}
int main( int argc, char **argv) {
dispatch_queue_t queue = gcl_create_dispatch_queue(CL_DEVICE_TYPE_GPU, NULL);
if(queue == NULL) {
queue = gcl_create_dispatch_queue(CL_DEVICE_TYPE_CPU, NULL);
}
dispatch_release(queue);
return 0;
}
void dispatch_group_function() {
long res;
dispatch_group_t group;
MU_BEGIN_TEST(dispatch_group_function);
group = create_group(100, 0);
MU_ASSERT_NOT_NULL(group);
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
// should be OK to re-use a group
dispatch_group_async_f(group, dispatch_get_global_queue(0, 0), 0, foo);
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_release(group);
group = NULL;
group = create_group(3, 7);
MU_ASSERT_NOT_NULL(group);
res = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC));
MU_ASSERT_EQUAL(!res, 0);
// retry after timeout (this time succeed)
res = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC));
MU_ASSERT_EQUAL(res, 0);
dispatch_release(group);
group = NULL;
group = create_group(100, 0);
MU_ASSERT_NOT_NULL(group);
dispatch_group_notify_f(group, dispatch_get_main_queue(), 0, group_notify);
dispatch_release(group);
group = NULL;
dispatch_main();
MU_FAIL("Should never reach this");
MU_END_TEST
}
void SDMMD_USBMuxListenerSend(SDMMD_USBMuxListenerRef listener, struct USBMuxPacket **packet)
{
__block struct USBMuxPacket *block_packet = *packet;
dispatch_sync(listener->ivars.operationQueue, ^{
// This semaphore will be signaled when a response is received
listener->ivars.semaphore = dispatch_semaphore_create(0);
// Send the outgoing packet
SDMMD_USBMuxSend(listener->ivars.socket, block_packet);
// Wait for a response-type packet to be received
dispatch_semaphore_wait(listener->ivars.semaphore, block_packet->timeout);
CFMutableArrayRef updateWithRemove = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0, listener->ivars.responses);
// Search responses for a packet that matches the one sent
struct USBMuxPacket *responsePacket = NULL;
uint32_t removeCounter = 0;
for (uint32_t i = 0; i < CFArrayGetCount(listener->ivars.responses); i++) {
struct USBMuxPacket *response = (struct USBMuxPacket *)CFArrayGetValueAtIndex(listener->ivars.responses, i);
if ((*packet)->body.tag == response->body.tag) {
// Equal tags indicate response to request
if (responsePacket) {
// Found additional response, destroy old one
USBMuxPacketRelease(responsePacket);
}
// Each matching packet is removed from the responses list
responsePacket = response;
CFArrayRemoveValueAtIndex(updateWithRemove, i - removeCounter);
removeCounter++;
}
}
if (responsePacket == NULL) {
// Didn't find an appropriate response, initialize an empty packet to return
responsePacket = (struct USBMuxPacket *)calloc(1, sizeof(struct USBMuxPacket));
}
CFSafeRelease(listener->ivars.responses);
listener->ivars.responses = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0, updateWithRemove);
CFSafeRelease(updateWithRemove);
// Destroy sent packet
USBMuxPacketRelease(block_packet);
// Return response packet to caller
block_packet = responsePacket;
// Discard "waiting for response" semaphore
dispatch_release(listener->ivars.semaphore);
});
// DESTRUCTOR
//------------------------------------------------------------------------------
Semaphore::~Semaphore()
{
#if defined( __WINDOWS__ )
VERIFY( CloseHandle( m_Semaphore ) );
#elif defined( __APPLE__ )
dispatch_release( m_Semaphore );
#elif defined( __LINUX__ )
VERIFY( sem_destroy( &m_Semaphore ) == 0 );
#endif
}
static int
smb_acquire_cred(const char *user, const char *domain, const char *password,
gss_OID mech, void **gssCreds)
{
gss_auth_identity_desc identity;
struct smb_gss_cred_ctx aq_cred_ctx;
uint32_t maj = !GSS_S_COMPLETE;
if (password == NULL || user == NULL || *user == '\0')
return 0;
identity.type = GSS_AUTH_IDENTITY_TYPE_1;
identity.flags = 0;
identity.username = strdup(user);
identity.realm = strdup(domain ? domain : "");
identity.password = strdup(password);
identity.credentialsRef = NULL;
if (identity.username == NULL ||
identity.realm == NULL ||
identity.password == NULL)
goto out;
aq_cred_ctx.sem = dispatch_semaphore_create(0);
if (aq_cred_ctx.sem == NULL)
goto out;
maj = gss_acquire_cred_ex_f(NULL,
GSS_C_NO_NAME,
0,
GSS_C_INDEFINITE,
mech,
GSS_C_INITIATE,
&identity,
&aq_cred_ctx,
acquire_cred_complete);
if (maj == GSS_S_COMPLETE) {
dispatch_semaphore_wait(aq_cred_ctx.sem, DISPATCH_TIME_FOREVER);
maj = aq_cred_ctx.maj;
*gssCreds = aq_cred_ctx.creds;
}
if (maj != GSS_S_COMPLETE)
smb_log_info("Acquiring NTLM creds for %s\%s failed. GSS returned %d",
ASL_LEVEL_INFO, domain, user, maj);
dispatch_release(aq_cred_ctx.sem);
out:
free(identity.username);
free(identity.realm);
free(identity.password);
return (maj == GSS_S_COMPLETE);
}
static void
rb_group_finalize(void *rcv, SEL sel)
{
rb_group_t *grp = RGroup(rcv);
if (grp->group != NULL) {
dispatch_release(grp->group);
}
if (rb_group_finalize_super != NULL) {
((void(*)(void *, SEL))rb_group_finalize_super)(rcv, sel);
}
}
