void exc_raise_status(int s) { EXCEPTION * new_exception; new_exception = (EXCEPTION *)malloc(sizeof(EXCEPTION)); /* XXX What if new_exception == NULL ?? Add error processing */ EXCEPTION_INIT(*new_exception); exc_set_status(new_exception, s); _exc_reraise(new_exception); }
int main() { pthread_setcancel(CANCEL_ON); printf ("test3: raising a cancel in a TRY block\n"); EXCEPTION_INIT(e1); TRY { TRY { printf (" in inner try block. Cancelling myself. \n"); pthread_cancel(pthread_self()); printf("\t... called pthread_cancel(). calling testcancel\n"); pthread_testcancel(); } CATCH(e1) { printf("\t... in handler for e1. \n"); } CATCH(pthread_cancel_e) { printf ("\t... in pthread_cancel_e inner handler\n"); printf ("exception report: \n"); exc_report(_exc_cur); RERAISE; } ENDTRY } CATCH(e1) { printf("\t... in outer handler for e1."); } CATCH(pthread_cancel_e) { printf("\t... in outer handler for pthread_cancel_e\n"); printf ("exception report: \n"); exc_report(_exc_cur); } ENDTRY; printf("normal exiting. \n"); return 0; }
/* * I N I T _ O N C E * * Initialize the exception package. This function is run through pthread_once(). * Create the key for the thread specific exception state. */ static void init_once() { EXCEPTION_INIT(exc_uninitexc_e); EXCEPTION_INIT(exc_exquota_e); EXCEPTION_INIT(exc_insfmem_e); EXCEPTION_INIT(exc_nopriv_e); EXCEPTION_INIT(exc_illaddr_e); EXCEPTION_INIT(exc_illinstr_e); EXCEPTION_INIT(exc_resaddr_e); EXCEPTION_INIT(exc_privinst_e); EXCEPTION_INIT(exc_resoper_e); EXCEPTION_INIT(exc_aritherr_e); EXCEPTION_INIT(exc_intovf_e); EXCEPTION_INIT(exc_intdiv_e); EXCEPTION_INIT(exc_fltovf_e); EXCEPTION_INIT(exc_fltdiv_e); EXCEPTION_INIT(exc_fltund_e); EXCEPTION_INIT(exc_decovf_e); EXCEPTION_INIT(exc_subrng_e); EXCEPTION_INIT(exc_excpu_e); EXCEPTION_INIT(exc_exfilsiz_e); EXCEPTION_INIT(exc_SIGTRAP_e); EXCEPTION_INIT(exc_SIGIOT_e); #if defined(SIGEMT) EXCEPTION_INIT(exc_SIGEMT_e); #endif #if defined(SIGSYS) EXCEPTION_INIT(exc_SIGSYS_e); #endif EXCEPTION_INIT(exc_SIGPIPE_e); EXCEPTION_INIT(exc_unksyncsig_e); EXCEPTION_INIT(pthread_cancel_e); EXCEPTION_INIT(pthread_badparam_e); EXCEPTION_INIT(pthread_existence_e); EXCEPTION_INIT(pthread_in_use_e); EXCEPTION_INIT(pthread_use_error_e); EXCEPTION_INIT(pthread_nostackmem_e); EXCEPTION_INIT(pthread_exit_thread_e); EXCEPTION_INIT(pthread_unimp_e); EXCEPTION_INIT(exc_unhandled_exc); if (pthd4_key_create(&_exc_key, destroy_exc) != 0) { exc_library_fatal_error(EXC_INT_FAIL_KEYCREATE, "init_once", 0); } }
static int rpc_netshareenum(struct smb_ctx *ctx, int *entriesp, int *totalp, struct share_info **entries_listp) { char ctx_string[2+16+1]; /* enough for 64-bit pointer, in hex */ unsigned_char_p_t binding; unsigned32 binding_status; rpc_binding_handle_t binding_h; int error, i, entries; char *addrstr, *srvnamestr; unsigned short *usrvnamestr; unsigned32 level; SHARE_ENUM_STRUCT share_info; SHARE_INFO_1_CONTAINER share_info_1_container; SHARE_INFO_1 *shares, *share; unsigned32 total_entries; unsigned32 status, free_status; struct share_info *entry_list, *elp; static EXCEPTION rpc_x_connect_rejected; static int exceptions_initialized; sprintf(ctx_string, "%p", ctx); rpc_string_binding_compose(NULL, "ncacn_np", ctx_string, "srvsvc", NULL, &binding, &binding_status); if (binding_status != rpc_s_ok) { smb_error(dgettext(TEXT_DOMAIN, "rpc_string_binding_compose failed with %d"), 0, binding_status); return (EINVAL); } rpc_binding_from_string_binding(binding, &binding_h, &status); rpc_string_free(&binding, (unsigned32 *)&free_status); if (binding_status != rpc_s_ok) { smb_error(dgettext(TEXT_DOMAIN, "rpc_binding_from_string_binding failed with %d"), 0, binding_status); return (EINVAL); } level = 1; share_info.share_union.level = 1; share_info.share_union.tagged_union.share1 = &share_info_1_container; share_info_1_container.share_count = 0; share_info_1_container.shares = NULL; /* * Convert the server IP address to a string, and send that as * the "server name" - that's what Windows appears to do, and * that avoids problems with NetBIOS names containing * non-ASCII characters. */ addrstr = inet_ntoa(ctx->ct_srvinaddr.sin_addr); srvnamestr = malloc(strlen(addrstr) + 3); if (srvnamestr == NULL) { status = errno; smb_error(dgettext(TEXT_DOMAIN, "can't allocate string for server address"), status); rpc_binding_free(&binding_h, &free_status); return (status); } strcpy(srvnamestr, "\\\\"); strcat(srvnamestr, addrstr); usrvnamestr = convert_utf8_to_leunicode(srvnamestr); if (usrvnamestr == NULL) { smb_error(dgettext(TEXT_DOMAIN, "can't convert string for server address to Unicode"), 0); rpc_binding_free(&binding_h, &free_status); free(srvnamestr); return (EINVAL); } if (!exceptions_initialized) { EXCEPTION_INIT(rpc_x_connect_rejected); exc_set_status(&rpc_x_connect_rejected, rpc_s_connect_rejected); exceptions_initialized = 1; } /* printf("Calling NetrShareEnum.."); XXX */ TRY status = NetrShareEnum(binding_h, usrvnamestr, &level, &share_info, 4294967295U, &total_entries, NULL); if (status != 0) smb_error(dgettext(TEXT_DOMAIN, "error from NetrShareEnum call: status = 0x%08x"), 0, status); /*CSTYLED*/ CATCH (rpc_x_connect_rejected) /* * This is what we get if we can't open the pipe. * That's a normal occurrence when we're talking * to a system that (presumably) doesn't support * DCE RPC on the server side, such as Windows 95/98/Me, * so we don't log an error. */ /*CSTYLED*/ status = ENOTSUP; CATCH_ALL /* * XXX - should we handle some exceptions differently, * returning different errors, and try RAP only for * ENOTSUP? */ smb_error(dgettext(TEXT_DOMAIN, "error from NetrShareEnum call: exception = %u"), 0, THIS_CATCH->match.value); status = ENOTSUP; ENDTRY rpc_binding_free(&binding_h, &free_status); free(srvnamestr); free(usrvnamestr); if (status != 0) return (ENOTSUP); /* * XXX - if the IDL is correct, it's not clear whether the * unmarshalling code will properly handle the case where * a packet where "share_count" and the max count for the * array of shares don't match; a valid DCE RPC implementation * won't marshal something like that, but there's no guarantee * that the server we're talking to has a valid implementation * (which could be a *malicious* implementation!). */ entries = share_info.share_union.tagged_union.share1->share_count; shares = share_info.share_union.tagged_union.share1->shares; entry_list = calloc(entries, sizeof (struct share_info)); if (entry_list == NULL) { error = errno; goto cleanup_and_return; } for (share = shares, elp = entry_list, i = 0; i < entries; i++, share++) { elp->type = share->shi1_type; elp->netname = convert_unicode_to_utf8(share->shi1_share); if (elp->netname == NULL) goto fail; elp->remark = convert_unicode_to_utf8(share->shi1_remark); if (elp->remark == NULL) goto fail; elp++; } *entriesp = entries; *totalp = total_entries; *entries_listp = entry_list; error = 0; goto cleanup_and_return; fail: error = errno; for (elp = entry_list, i = 0; i < entries; i++, elp++) { /* * elp->netname is set before elp->remark, so if * elp->netname is null, elp->remark is also null. * If either of them is null, we haven't done anything * to any entries after this one. */ if (elp->netname == NULL) break; free(elp->netname); if (elp->remark == NULL) break; free(elp->remark); } free(entry_list); cleanup_and_return: for (share = shares, i = 0; i < entries; i++, share++) { free(share->shi1_share); free(share->shi1_remark); } free(shares); /* * XXX - "share1" should be a unique pointer, but we haven't * changed the marshalling code to support non-full pointers * in unions, so we leave it as a full pointer. * * That means that this might, or might not, be changed from * pointing to "share_info_1_container" to pointing to a * mallocated structure, according to the DCE RPC 1.1 IDL spec; * we free it only if it's changed. */ if (share_info.share_union.tagged_union.share1 != &share_info_1_container) free(share_info.share_union.tagged_union.share1); return (error); }