OM_uint32 GSSAPI_LIB_FUNCTION
gss_acquire_cred_ex(const gss_name_t desired_name,
OM_uint32 flags,
OM_uint32 time_req,
gss_const_OID desired_mech,
gss_cred_usage_t cred_usage,
gss_auth_identity_t identity,
gss_acquire_cred_complete complete)
{
OM_uint32 ret;
complete = (gss_acquire_cred_complete)Block_copy(complete);
ret = gss_acquire_cred_ex_f(NULL,
desired_name,
flags,
time_req,
desired_mech,
cred_usage,
identity,
complete,
complete_block);
if (ret != GSS_S_COMPLETE)
Block_release(complete);
return ret;
}
BOOL pl_imp_removeBlock(IMP anImp) {
#if SUPPORT_APPLE_FALLBACK
/* Prefer Apple's implementation */
if (&pl_imp_removeBlock != NULL)
return pl_imp_removeBlock(anImp);
#endif
/* Fetch the config data */
void **config = pl_trampoline_data_ptr(anImp);
struct Block_layout *bl = config[0];
pl_trampoline *tramp = config[1];
/* Drop the trampoline allocation */
if (bl->flags & BLOCK_USE_STRET) {
pl_trampoline_free(&blockimp_lock, &blockimp_table_stret, tramp);
} else {
pl_trampoline_free(&blockimp_lock, &blockimp_table, tramp);
}
/* Release the block */
Block_release(config[0]);
// TODO - what does this return value mean?
return YES;
}
BOOL imp_removeBlock(IMP anImp)
{
void *w = isBlockIMP((void*)anImp);
if (0 == w) { return NO; }
Block_release(((void**)anImp) - 1);
return YES;
}
int main()
{
__block int var = 0;
int shouldbe = 0;
void (^b)(void) = ^{ var++; /*printf("var is at %p with value %d\n", &var, var);*/ };
__typeof(b) _b;
//printf("before copy...\n");
b(); ++shouldbe;
size_t i;
for (i = 0; i < 10; i++) {
_b = Block_copy(b); // make a new copy each time
assert(_b);
++shouldbe;
_b(); // should still update the stack
Block_release(_b);
}
//printf("after...\n");
b(); ++shouldbe;
if (var != shouldbe) {
fail("var is %d but should be %d", var, shouldbe);
}
succeed(__FILE__);
}
static void * ThreadEntrypoint(void *info) {
dispatch_block_t block = (dispatch_block_t)info;
block();
// We had to create a copy of the block to pass it into pthread_create, so
// be sure to release it here.
Block_release(block);
return NULL;
}
static void
complete_block(void *ctx, OM_uint32 maj_stat,
gss_status_id_t status, gss_cred_id_t cred,
gss_OID_set set, OM_uint32 min_time)
{
gss_acquire_cred_complete complete = ctx;
complete(status, cred, set, min_time);
Block_release(complete);
}
int main(int argc, char **argv) {
voidVoid block = testFunction();
dirtyStack();
block();
Block_release(block);
printf("%s: success\n", argv[0]);
return 0;
}
// 6618342 Contact the team that owns the Instrument DTrace probe before renaming this symbol
static void
_dispatch_source_set_cancel_handler2(void *context)
{
dispatch_source_t ds = (dispatch_source_t)_dispatch_queue_get_current();
dispatch_assert(ds->do_vtable == &_dispatch_source_kevent_vtable);
if (ds->ds_cancel_is_block && ds->ds_cancel_handler) {
Block_release(ds->ds_cancel_handler);
}
ds->ds_cancel_handler = context;
ds->ds_cancel_is_block = true;
}
inline DISPATCH_ALWAYS_INLINE ~dispatch_block_private_data_s() noexcept
{
_dispatch_block_private_data_debug("destroy%s, block: %p",
dbpd_magic ? "" : " (stack)", dbpd_block);
if (dbpd_magic != DISPATCH_BLOCK_PRIVATE_DATA_MAGIC) return;
if (dbpd_group) {
if (!dbpd_performed) dispatch_group_leave(dbpd_group);
((void (*)(dispatch_group_t))dispatch_release)(dbpd_group);
}
if (dbpd_block) Block_release(dbpd_block);
if (dbpd_voucher) voucher_release(dbpd_voucher);
}
int main(int argc __unused, char *argv[]) {
voidVoid array[100];
for (int i = 0; i < 100; ++i) {
array[i] = testRoutine(argv[0]);
array[i]();
}
for (int i = 0; i < 100; ++i) {
Block_release(array[i]);
}
succeed(__FILE__);
}
int main (void)
{
quiz_1();
boringBlock();
Block_release(boringBlock);
quiz_2();
boringBlock();
Block_release(boringBlock);
quiz_3();
boringBlock();
Block_release(boringBlock);
quiz_3();
quiz_3_helper();
boringBlock();
Block_release(boringBlock);
BoringBlock retBlock = quiz_5();
boringBlock();
retBlock();
Block_release(boringBlock);
Block_release(retBlock);
printf("End of quiz 5\n\n");
return 0;
}
bool SOSTransportMessageSendMessageIfNeeded(SOSTransportMessageRef transport, CFStringRef circle_id, CFStringRef peer_id, CFErrorRef *error) {
SOSEnginePeerMessageSentBlock sent = NULL;
CFDataRef message_to_send = NULL;
bool ok = false;
SOSPeerRef peer = SOSPeerCreateWithEngine(SOSTransportMessageGetEngine(transport), peer_id);
CFDataRef coderData = SOSEngineGetCoderData(SOSTransportMessageGetEngine(transport), peer_id);
require(coderData, fail);
SOSCoderRef coder = SOSCoderCreateFromData(coderData, error);
require(coder, fail);
SOSPeerSetCoder(peer, coder);
ok = SOSPeerCoderSendMessageIfNeeded(peer, &message_to_send, circle_id, peer_id, &sent, error);
coder = SOSPeerGetCoder(peer);
if (message_to_send) {
CFDictionaryRef peer_dict = CFDictionaryCreateForCFTypes(kCFAllocatorDefault,
peer_id, message_to_send,
NULL);
CFDictionaryRef circle_peers = CFDictionaryCreateForCFTypes(kCFAllocatorDefault,
circle_id, peer_dict,
NULL);
ok = ok && SOSTransportMessageSendMessages(transport, circle_peers, error);
SOSPeerCoderConsume(&sent, ok);
CFReleaseSafe(peer_dict);
CFReleaseSafe(circle_peers);
}
Block_release(sent);
CFReleaseSafe(message_to_send);
coderData = SOSCoderCopyDER(coder, error);
if(!SOSEngineSetCoderData(SOSTransportMessageGetEngine(transport), peer_id, coderData, error)){
secerror("SOSTransportMessageSendMessageIfNeeded, Could not save peer state");
}
CFReleaseNull(coderData);
if (coder)
SOSCoderDispose(coder);
fail:
CFReleaseNull(peer);
return ok;
}
/*
* 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);
}
void
dispatch_source_attr_set_finalizer_f(dispatch_source_attr_t attr,
void *context, dispatch_source_finalizer_function_t finalizer)
{
#ifdef __BLOCKS__
if (attr->finalizer_func == (void*)_dispatch_call_block_and_release2) {
Block_release(attr->finalizer_ctxt);
}
#endif
attr->finalizer_ctxt = context;
attr->finalizer_func = finalizer;
}
// 6618342 Contact the team that owns the Instrument DTrace probe before renaming this symbol
dispatch_source_t
_dispatch_source_create2(dispatch_source_t ds,
dispatch_source_attr_t attr,
void *context,
dispatch_source_handler_function_t handler)
{
if (ds == NULL || handler == NULL) {
return NULL;
}
ds->ds_is_legacy = true;
ds->ds_handler_func = (dispatch_function_t)handler;
ds->ds_handler_ctxt = context;
if (attr && attr != DISPATCH_SOURCE_CREATE_SUSPENDED) {
ds->dq_finalizer_ctxt = attr->finalizer_ctxt;
ds->dq_finalizer_func = (typeof(ds->dq_finalizer_func))attr->finalizer_func;
ds->do_ctxt = attr->context;
}
#ifdef __BLOCKS__
if (ds->dq_finalizer_func == (void*)_dispatch_call_block_and_release2) {
ds->dq_finalizer_ctxt = Block_copy(ds->dq_finalizer_ctxt);
if (!ds->dq_finalizer_ctxt) {
goto out_bad;
}
}
if (handler == _dispatch_source_call_block) {
struct Block_layout *bl = ds->ds_handler_ctxt = Block_copy(context);
if (!ds->ds_handler_ctxt) {
if (ds->dq_finalizer_func == (void*)_dispatch_call_block_and_release2) {
Block_release(ds->dq_finalizer_ctxt);
}
goto out_bad;
}
ds->ds_handler_func = (void *)bl->invoke;
ds->ds_handler_is_block = true;
}
// all legacy sources get a cancellation event on the normal event handler.
dispatch_function_t func = ds->ds_handler_func;
dispatch_source_handler_t block = ds->ds_handler_ctxt;
void *ctxt = ds->ds_handler_ctxt;
bool handler_is_block = ds->ds_handler_is_block;
ds->ds_cancel_is_block = true;
if (handler_is_block) {
ds->ds_cancel_handler = _dispatch_Block_copy(^{
block(ds);
});
} else {
static void
_dispatch_source_set_cancel_handler_f(void *context)
{
dispatch_source_t ds = (dispatch_source_t)_dispatch_queue_get_current();
dispatch_assert(ds->do_vtable == &_dispatch_source_kevent_vtable);
#ifdef __BLOCKS__
if (ds->ds_cancel_is_block && ds->ds_cancel_handler) {
Block_release(ds->ds_cancel_handler);
}
#endif
ds->ds_cancel_handler = context;
ds->ds_cancel_is_block = false;
}
int main()
{
__block int i;
i = 0;
void (^block)() = ^{
printf("Hello world %d\n", i);
};
++i;
void (^block2)() = Block_copy(block);
++i;
block2();
Block_release(block2);
return 0;
}
int main() {
__block int c = 1;
//printf("&c = %p - c = %i\n", &c, c);
int i;
for(i =0; i < 2; i++) {
dispatch_block_t block = Block_copy(^{ c = i; });
block();
// printf("%i: &c = %p - c = %i\n", i, &c, c);
Block_release(block);
}
int main(int argc, char *argv[]) {
voidVoid array[100];
for (int i = 0; i < 100; ++i) {
array[i] = testRoutine(argv[0]);
array[i]();
}
for (int i = 0; i < 100; ++i) {
Block_release(array[i]);
}
printf("%s: success\n", argv[0]);
return 0;
}
void
_dispatch_source_cancel_callout(dispatch_source_t ds)
{
ds->ds_pending_data_mask = 0;
ds->ds_pending_data = 0;
ds->ds_data = 0;
#ifdef __BLOCKS__
if (ds->ds_handler_is_block) {
Block_release(ds->ds_handler_ctxt);
ds->ds_handler_is_block = false;
ds->ds_handler_func = NULL;
ds->ds_handler_ctxt = NULL;
}
#endif
if (!ds->ds_cancel_handler) {
return;
}
if (ds->ds_cancel_is_block) {
#ifdef __BLOCKS__
dispatch_block_t b = ds->ds_cancel_handler;
if (ds->ds_atomic_flags & DSF_CANCELED) {
b();
}
Block_release(ds->ds_cancel_handler);
ds->ds_cancel_is_block = false;
#endif
} else {
dispatch_function_t f = ds->ds_cancel_handler;
if (ds->ds_atomic_flags & DSF_CANCELED) {
f(ds->do_ctxt);
}
}
ds->ds_cancel_handler = NULL;
}
// 6618342 Contact the team that owns the Instrument DTrace probe before renaming this symbol
static void
_dispatch_source_set_event_handler2(void *context)
{
struct Block_layout *bl = context;
dispatch_source_t ds = (dispatch_source_t)_dispatch_queue_get_current();
dispatch_assert(ds->do_vtable == &_dispatch_source_kevent_vtable);
if (ds->ds_handler_is_block && ds->ds_handler_ctxt) {
Block_release(ds->ds_handler_ctxt);
}
ds->ds_handler_func = bl ? (void *)bl->invoke : NULL;
ds->ds_handler_ctxt = bl;
ds->ds_handler_is_block = true;
}
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);
}
sparse_error_t sparse_end(sparse_state_t *state)
{
sparse_error_t error = SP_NO_ERROR;
sparse_fn_t callback = state->callback;
void *context = state->context;
#ifdef __BLOCKS__
sparse_block_t block = state->block;
#endif
if (state->mode == SP_READ_NAME) {
SP_SEND_MSG(SP_NAME, state->buffer, state->buffer + state->buffer_size - state->num_spaces_trailing);
SP_SEND_MSG(SP_VALUE, sp_empty_str, sp_empty_str);
} else if (state->mode == SP_READ_VALUE) {
SP_SEND_MSG(SP_VALUE, state->buffer, state->buffer + state->buffer_size - state->num_spaces_trailing);
} else if (state->mode == SP_FIND_VALUE) {
SP_SEND_MSG(SP_VALUE, sp_empty_str, sp_empty_str);
}
if (state->depth != 0) {
error = SP_ERROR_INCOMPLETE_DOCUMENT;
SP_SEND_MSG(SP_ERROR, sp_errstr_incomplete_doc, SP_ERRSTR_END(sp_errstr_incomplete_doc));
state->error_begin = sp_errstr_incomplete_doc;
state->error_end = SP_ERRSTR_END(sp_errstr_incomplete_doc);
}
#ifdef __BLOCKS__
if (state->block != NULL)
Block_release(state->block);
#endif
if (state->buffer != NULL)
free(state->buffer);
if (error != SP_NO_ERROR)
memset(state, 0, sizeof(*state));
return error;
}
TouchableComponent::~TouchableComponent()
{
Block_release(mTouchHitBlock);
}
static void _apply_op_b_cb(char *error, void *user, uint32_t new_version) {
db_apply_bcb cb = (db_apply_bcb)user;
cb(error, new_version);
Block_release(cb);
}
static void _get_bcb(char *error, void *user, ot_document *doc) {
db_get_bcb cb = (db_get_bcb)user;
cb(error, doc);
Block_release(cb);
}
static void _create_bcb(char *error, ot_document *doc, void *user) {
db_create_bcb cb = (db_create_bcb)user;
cb(error, doc);
Block_release(cb);
}
