/* * Dump RNG output into a string. */ void RngDump(NaClSrpcRpc *rpc, NaClSrpcArg **in_args, NaClSrpcArg **out_args, NaClSrpcClosure *done) { struct StringBuffer sb; NaClSrpcError rpc_result; int status; int rng; StringBufferCtor(&sb); rpc_result = NaClSrpcInvokeBySignature(&ns_channel, NACL_NAME_SERVICE_LOOKUP, "SecureRandom", O_RDONLY, &status, &rng); assert(NACL_SRPC_RESULT_OK == rpc_result); printf("rpc status %d\n", status); assert(NACL_NAME_SERVICE_SUCCESS == status); printf("rng descriptor %d\n", rng); dump_output(&sb, rng, RNG_OUTPUT_BYTES); out_args[0]->arrays.str = strdup(sb.buffer); rpc->result = NACL_SRPC_RESULT_OK; done->Run(done); close(rng); StringBufferDtor(&sb); }
unsigned long get_good_seed(void) { int ns; int connected_socket; NaClSrpcChannel ns_channel; NaClSrpcError rpc_result; int status; int rng; unsigned long seed; ns = -1; if (-1 == nacl_nameservice(&ns)) { fprintf(stderr, "nacl_nameservice failed\n"); abort(); } connected_socket = imc_connect(ns); assert(-1 != connected_socket); if (!NaClSrpcClientCtor(&ns_channel, connected_socket)) { fprintf(stderr, "SRPC client channel ctor failed\n"); abort(); } (void) close(ns); rpc_result = NaClSrpcInvokeBySignature(&ns_channel, NACL_NAME_SERVICE_LOOKUP, "SecureRandom", O_RDONLY, &status, &rng); assert(NACL_SRPC_RESULT_OK == rpc_result); assert(NACL_NAME_SERVICE_SUCCESS == status); assert(sizeof seed == read(rng, &seed, sizeof seed)); close(rng); NaClSrpcDtor(&ns_channel); return seed; }
int NaClReverseHostInterfaceReportExitStatus( struct NaClRuntimeHostInterface *vself, int exit_status) { struct NaClReverseHostInterface *self = (struct NaClReverseHostInterface *) vself; NaClSrpcError rpc_result; int status = 0; NaClLog(3, "NaClReverseHostInterfaceReportExitStatus:" " self 0x%08"NACL_PRIxPTR", exit_status 0x%x)\n", (uintptr_t) self, exit_status); NaClXMutexLock(&self->server->mu); if (NACL_REVERSE_CHANNEL_INITIALIZED == self->server->reverse_channel_initialization_state) { rpc_result = NaClSrpcInvokeBySignature(&self->server->reverse_channel, NACL_REVERSE_CONTROL_REPORT_STATUS, exit_status); if (NACL_SRPC_RESULT_OK != rpc_result) { NaClLog(LOG_FATAL, "NaClReverseHostInterfaceReportExitStatus:" " RPC failed, result %d\n", rpc_result); } } else { NaClLog(4, "NaClReverseHostInterfaceReportExitStatus: no reverse channel" ", no plugin to talk to.\n"); status = -NACL_ABI_ENODEV; } NaClXMutexUnlock(&self->server->mu); return status; }
/* * Returns file descriptor or error code. */ static int irt_open_resource(const char *file, int *fd) { int status; struct NaClSrpcChannel *manifest_channel; if (g_is_main_thread) { return EDEADLK; } status = get_manifest_channel(&manifest_channel); if (0 != status) { return status; } char* path = malloc(strlen(file) + 1 + kFilesLen); strcpy(path, kFiles); if ('/' == file[0]) { strcat(path, file + 1); } else { strcat(path, file); } pthread_mutex_lock(&manifest_service_mutex); if (NACL_SRPC_RESULT_OK == NaClSrpcInvokeBySignature( manifest_channel, NACL_NAME_SERVICE_LOOKUP, path, O_RDONLY, &status, fd)) { status = 0; } pthread_mutex_unlock(&manifest_service_mutex); free(path); if (-1 == *fd) { return ENOENT; } return status; }
int NaClReverseHostInterfaceStartupInitializationComplete( struct NaClRuntimeHostInterface *vself) { struct NaClReverseHostInterface *self = (struct NaClReverseHostInterface *) vself; NaClSrpcError rpc_result; int status = 0; NaClLog(3, ("NaClReverseHostInterfaceStartupInitializationComplete(0x%08" NACL_PRIxPTR")\n"), (uintptr_t) self); NaClXMutexLock(&self->server->mu); if (NACL_REVERSE_CHANNEL_INITIALIZED == self->server->reverse_channel_initialization_state) { rpc_result = NaClSrpcInvokeBySignature(&self->server->reverse_channel, NACL_REVERSE_CONTROL_INIT_DONE); if (NACL_SRPC_RESULT_OK != rpc_result) { NaClLog(LOG_FATAL, "NaClReverseHostInterfaceStartupInitializationComplete:" " RPC failed, result %d\n", rpc_result); } } else { NaClLog(4, "NaClReverseHostInterfaceStartupInitializationComplete:" " no reverse channel, no plugin to talk to.\n"); status = -NACL_ABI_ENODEV; } NaClXMutexUnlock(&self->server->mu); return status; }
static int nacl_video_bridge_update(const void *data) { if (NULL != nacl_multimedia.video_data) { memcpy(&nacl_multimedia.video_data->video_pixels[0], data, nacl_multimedia.video_data->u.h.video_size); if (NACL_SRPC_RESULT_OK != NaClSrpcInvokeBySignature(nacl_multimedia.channel, "upcall::")) { Fatal("nacl_video_bridge_update() failed upcall\n"); return -EIO; } sched_yield(); return 0; } return -EIO; }
void ManifestTest(NaClSrpcRpc *rpc, NaClSrpcArg **in_args, NaClSrpcArg **out_args, NaClSrpcClosure *done) { struct StringBuffer sb; NaClSrpcError rpc_result; int status; int manifest; int manifest_conn; struct NaClSrpcChannel manifest_channel; /* just get the descriptor for now */ StringBufferCtor(&sb); if (NACL_SRPC_RESULT_OK != (rpc_result = NaClSrpcInvokeBySignature(&ns_channel, NACL_NAME_SERVICE_LOOKUP, "ManifestNameService", O_RDWR, &status, &manifest))) { StringBufferPrintf(&sb, "nameservice lookup RPC failed (%d)\n", rpc_result); goto done; } StringBufferPrintf(&sb, "Got manifest descriptor %d\n", manifest); if (-1 == manifest) { fprintf(stderr, "nameservice lookup failed, status %d\n", status); goto done; } /* connect to manifest name server */ manifest_conn = imc_connect(manifest); StringBufferPrintf(&sb, "got manifest connection %d\n", manifest_conn); if (-1 == manifest_conn) { StringBufferPrintf(&sb, "could not connect\n"); goto done; } close(manifest); if (!NaClSrpcClientCtor(&manifest_channel, manifest_conn)) { StringBufferPrintf(&sb, "could not build srpc client\n"); goto done; } StringBufferDiscardOutput(&sb); StringBufferPrintf(&sb, "ManifestTest: basic connectivity ok\n"); done: out_args[0]->arrays.str = strdup(sb.buffer); rpc->result = NACL_SRPC_RESULT_OK; done->Run(done); StringBufferDtor(&sb); }
static ssize_t NaClDescPostMessageWrite(struct NaClDesc *vself, void const *buf, size_t len) { struct NaClDescPostMessage *self = (struct NaClDescPostMessage *) vself; NaClSrpcError rpc_result; int num_written = 0; ssize_t rv = -NACL_ABI_EIO; NaClLog(4, "Entered NaClDescPostMessageWrite(..., %"NACL_PRIuS")\n", len); if (0 != self->error) { return self->error; } NaClXMutexLock(&self->nap->mu); if (NACL_REVERSE_CHANNEL_INITIALIZED != self->nap->reverse_channel_initialization_state) { NaClLog(LOG_FATAL, "NaClDescPostMessageWrite: Reverse channel not initialized\n"); } if (len > NACL_ABI_SIZE_T_MAX) { len = NACL_ABI_SIZE_T_MAX; /* fits in an int32_t */ } rpc_result = NaClSrpcInvokeBySignature(&self->nap->reverse_channel, NACL_REVERSE_CONTROL_POST_MESSAGE, len, buf, &num_written); if (NACL_SRPC_RESULT_OK != rpc_result || num_written > (int) len) { /* * A conforming interface implementation could return an errno, * but should never return a larger value. */ rv = -NACL_ABI_EIO; /* * make this error permanent; other negative errno returns are * considered transient. */ self->error = rv; } else { rv = (ssize_t) num_written; } NaClXMutexUnlock(&self->nap->mu); NaClLog(4, "Leaving NaClDescPostMessageWrite (%"NACL_PRIuS")\n", rv); return rv; }
int main(void) { int ns; NaClSrpcChannel channel; int connected_socket; int status; int rng; if (!NaClSrpcModuleInit()) { fprintf(stderr, "srpc module init failed\n"); return 1; } printf("Hello world\n"); ns = -1; nacl_nameservice(&ns); printf("ns = %d\n", ns); assert(-1 != ns); connected_socket = imc_connect(ns); assert(-1 != connected_socket); if (!NaClSrpcClientCtor(&channel, connected_socket)) { fprintf(stderr, "Srpc client channel ctor failed\n"); return 1; } printf("NaClSrpcClientCtor succeeded\n"); if (!EnumerateNames(&channel)) { fprintf(stderr, "Could not enumerate names\n"); return 1; } printf("EnumerateNames succeeded\n"); if (NACL_SRPC_RESULT_OK != NaClSrpcInvokeBySignature(&channel, NACL_NAME_SERVICE_LOOKUP, "SecureRandom", O_RDONLY, &status, &rng)) { fprintf(stderr, "nameservice lookup failed, status %d\n", status); return 1; } printf("rpc status %d\n", status); assert(NACL_NAME_SERVICE_SUCCESS == status); printf("rng descriptor %d\n", rng); dump_output(rng, RNG_OUTPUT_BYTES); return 0; }
int EnumerateNames(struct StringBuffer *sb, NaClSrpcChannel *nschan) { char buffer[1024]; uint32_t nbytes = sizeof buffer; char *p; size_t name_len; if (NACL_SRPC_RESULT_OK != NaClSrpcInvokeBySignature(nschan, NACL_NAME_SERVICE_LIST, &nbytes, buffer)) { return 0; } StringBufferPrintf(sb, "nbytes = %zu\n", (size_t) nbytes); if (nbytes == sizeof buffer) { fprintf(stderr, "Insufficent space for namespace enumeration\n"); return 0; } for (p = buffer; p - buffer < nbytes; p += name_len) { name_len = strlen(p) + 1; StringBufferPrintf(sb, "%s\n", p); } return 1; }
int NaClReverseHostInterfaceCreateProcess( struct NaClRuntimeHostInterface *vself, struct NaClDesc **out_sock_addr, struct NaClDesc **out_app_addr) { struct NaClReverseHostInterface *self = (struct NaClReverseHostInterface *) vself; NaClSrpcError rpc_result; int pid = 0; NaClLog(3, ("NaClReverseHostInterfaceCreateProcess(0x%08"NACL_PRIxPTR ", 0x%08"NACL_PRIxPTR", 0x%08"NACL_PRIxPTR")\n"), (uintptr_t) self, (uintptr_t) out_sock_addr, (uintptr_t) out_app_addr); NaClXMutexLock(&self->server->mu); if (NACL_REVERSE_CHANNEL_INITIALIZED == self->server->reverse_channel_initialization_state) { rpc_result = NaClSrpcInvokeBySignature( &self->server->reverse_channel, NACL_REVERSE_CONTROL_CREATE_PROCESS_INTERLOCKED, out_sock_addr, out_app_addr, &pid); if (NACL_SRPC_RESULT_OK != rpc_result) { NaClLog(LOG_FATAL, "NaClReverseHostInterfaceCreateProcess: RPC failed, result %d\n", rpc_result); } } else { NaClLog(4, "NaClReverseHostInterfaceCreateProcess: no reverse channel" ", no plugin to talk to.\n"); pid = -NACL_ABI_ENODEV; } NaClXMutexUnlock(&self->server->mu); return pid; }
ssize_t NaClReverseHostInterfacePostMessage( struct NaClRuntimeHostInterface *vself, char const *message, size_t message_bytes) { struct NaClReverseHostInterface *self = (struct NaClReverseHostInterface *) vself; NaClSrpcError rpc_result; ssize_t num_written; NaClLog(3, ("NaClReverseHostInterfacePostMessage(0x%08"NACL_PRIxPTR", %s" ", %08"NACL_PRIdS")\n"), (uintptr_t) self, message, message_bytes); NaClXMutexLock(&self->server->mu); if (message_bytes > NACL_ABI_SIZE_T_MAX) { message_bytes = NACL_ABI_SIZE_T_MAX; } if (NACL_REVERSE_CHANNEL_INITIALIZED == self->server->reverse_channel_initialization_state) { rpc_result = NaClSrpcInvokeBySignature(&self->server->reverse_channel, NACL_REVERSE_CONTROL_POST_MESSAGE, message_bytes, message, &num_written); if (NACL_SRPC_RESULT_OK != rpc_result) { NaClLog(LOG_FATAL, "NaClReverseHostInterfacePostMessage: RPC failed, result %d\n", rpc_result); } } else { NaClLog(4, "NaClReverseHostInterfacePostMessage: no reverse channel" ", no plugin to talk to.\n"); num_written = -NACL_ABI_ENODEV; } NaClXMutexUnlock(&self->server->mu); return num_written; }
int NaClReportExitStatus(struct NaClApp *nap, int exit_status) { int rv = 0; NaClSrpcError rpc_result; NaClXMutexLock(&nap->mu); /* * If several threads are exiting/reporting signals at once, we should * let only one thread to pass through. This way we can use exit code * without synchronization once we know that running==0. */ if (!nap->running) { NaClXMutexUnlock(&nap->mu); return 0; } if (NACL_REVERSE_CHANNEL_INITIALIZED == nap->reverse_channel_initialization_state) { /* TODO(halyavin) update NaCl plugin to accept full exit_status value */ if (NACL_ABI_WIFEXITED(exit_status)) { rpc_result = NaClSrpcInvokeBySignature(&nap->reverse_channel, NACL_REVERSE_CONTROL_REPORT_STATUS, NACL_ABI_WEXITSTATUS(exit_status)); rv = NACL_SRPC_RESULT_OK == rpc_result; } /* * Due to cross-repository checkins, the Cr-side might not yet * implement this RPC. We return whether shutdown was reported. */ } nap->exit_status = exit_status; nap->running = 0; NaClXCondVarSignal(&nap->cv); NaClXMutexUnlock(&nap->mu); return rv; }
void NaClPluginLowLevelInitializationCompleteInternal(void) { int nameservice_conn_desc; int kernel_service_conn_cap_desc = -1; int kernel_service_desc; struct NaClSrpcChannel srpc_channel; int status; NaClLog(4, "Entered NaClPluginLowLevelInitializationComplete\n"); if (-1 != gNaClNameServiceConnCapDesc) { NaClLog(LOG_ERROR, "Double call to NaClPluginLowLevelInitializationComplete?\n"); return; } /* * The existence of the bootstrap nameservice is independent of * whether NaCl is running as a standalone application or running as * a untrusted Pepper plugin, browser extension environment. */ if (-1 == nacl_nameservice(&gNaClNameServiceConnCapDesc)) { NaClLog(LOG_FATAL, "NaClPluginLowLevelInitializationComplete: no name service?!?\n"); } nameservice_conn_desc = imc_connect(gNaClNameServiceConnCapDesc); if (-1 == nameservice_conn_desc) { NaClLog(LOG_FATAL, "Could not connect to bootstrap name service\n"); } if (!NaClSrpcClientCtor(&srpc_channel, nameservice_conn_desc)) { (void) close(nameservice_conn_desc); NaClLog(LOG_FATAL, "SRPC channel ctor to name service failed\n"); } if (NACL_SRPC_RESULT_OK != NaClSrpcInvokeBySignature( &srpc_channel, NACL_NAME_SERVICE_LOOKUP, "KernelService", O_RDWR, &status, &kernel_service_conn_cap_desc)) { NaClSrpcDtor(&srpc_channel); NaClLog(LOG_FATAL, "Name service lookup RPC for KernelService failed\n"); } NaClSrpcDtor(&srpc_channel); if (-1 == kernel_service_conn_cap_desc) { NaClLog(LOG_FATAL, "Name service lookup for KernelService failed, %d\n", status); } if (-1 == (kernel_service_desc = imc_connect(kernel_service_conn_cap_desc))) { (void) close(kernel_service_conn_cap_desc); NaClLog(LOG_FATAL, "Connect to KernelService failed\n"); } (void) close(kernel_service_conn_cap_desc); if (!NaClSrpcClientCtor(&srpc_channel, kernel_service_desc)) { (void) close(kernel_service_desc); NaClLog(LOG_FATAL, "SRPC channel ctor to KernelService failed\n"); } if (NACL_SRPC_RESULT_OK != NaClSrpcInvokeBySignature( &srpc_channel, NACL_KERNEL_SERVICE_INITIALIZATION_COMPLETE)) { NaClLog(LOG_FATAL, "KernelService init_done RPC failed!\n"); } NaClSrpcDtor(&srpc_channel); }
int main(int argc, char* argv[]) { int result; NaClHandle pair[2]; #ifdef __native_client__ int imc_desc[2]; #else struct NaClDescImcDesc* imc_desc[2]; #endif struct NaClThread thr; NaClSrpcChannel channel; NaClSrpcError error; struct ServiceThreadArgs* threadArg; UNREFERENCED_PARAMETER(argc); UNREFERENCED_PARAMETER(argv); NaClSrpcModuleInit(); if (0 != NaClSocketPair(pair)) { failWithErrno("SocketPair"); } #ifdef __native_client__ imc_desc[0] = pair[0]; imc_desc[1] = pair[1]; #else NaClNrdAllModulesInit(); imc_desc[0] = (struct NaClDescImcDesc*) calloc(1, sizeof(*imc_desc[0])); if (0 == imc_desc[0]) { failWithErrno("calloc"); } imc_desc[1] = (struct NaClDescImcDesc*) calloc(1, sizeof(*imc_desc[1])); if (0 == imc_desc[1]) { failWithErrno("calloc"); } if (!NaClDescImcDescCtor(imc_desc[0], pair[0])) { failWithErrno("NaClDescImcDescCtor"); } if (!NaClDescImcDescCtor(imc_desc[1], pair[1])) { failWithErrno("NaClDescImcDescCtor"); } #endif threadArg = (struct ServiceThreadArgs*) calloc(1, sizeof(*threadArg)); if (NULL == threadArg) { failWithErrno("calloc for threadArg"); } threadArg->desc = (NaClSrpcImcDescType)imc_desc[0]; if (!NaClThreadCreateJoinable(&thr, serviceThread, threadArg, 128*1024)) { failWithErrno("NaClThreadCtor"); } if (!NaClSrpcClientCtor(&channel, (NaClSrpcImcDescType) imc_desc[1])) { failWithErrno("NaClSrpcClientCtor"); } error = NaClSrpcInvokeBySignature(&channel, "getNum::i", &result); if (NACL_SRPC_RESULT_OK != error) { fprintf(stderr, "SRPC call to getNum::i failed: %s\n", NaClSrpcErrorString(error)); exit(EXIT_FAILURE); } if (TEST_NUM != result) { fprintf(stderr, "expected: %d, got: %d\n", TEST_NUM, result); exit(EXIT_FAILURE); } NaClSrpcDtor(&channel); #ifdef __native_client__ close(imc_desc[1]); #else NaClDescUnref((NaClSrpcImcDescType)imc_desc[1]); #endif NaClThreadJoin(&thr); NaClSrpcModuleFini(); return 0; }
int NaClManifestProxyConnectionFactory( struct NaClSimpleService *vself, struct NaClDesc *conn, struct NaClSimpleServiceConnection **out) { struct NaClManifestProxy *self = (struct NaClManifestProxy *) vself; struct NaClManifestProxyConnection *mconn; NaClSrpcError rpc_result; int bool_status; NaClLog(4, ("Entered NaClManifestProxyConnectionFactory, self 0x%"NACL_PRIxPTR "\n"), (uintptr_t) self); mconn = (struct NaClManifestProxyConnection *) malloc(sizeof *mconn); if (NULL == mconn) { NaClLog(4, "NaClManifestProxyConnectionFactory: no memory\n"); return -NACL_ABI_ENOMEM; } NaClLog(4, "NaClManifestProxyConnectionFactory: creating connection obj\n"); if (!NaClManifestProxyConnectionCtor(mconn, self, conn)) { free(mconn); return -NACL_ABI_EIO; } /* * Construct via NaClSecureReverseClientCtor with a callback to * process the new reverse connection -- which should be stored in * the mconn object. * * Make reverse RPC to obtain a new reverse RPC connection. */ NaClLog(4, "NaClManifestProxyConnectionFactory: locking reverse channel\n"); NaClLog(4, "NaClManifestProxyConnectionFactory: client 0x%"NACL_PRIxPTR"\n", (uintptr_t) self->server); NaClXMutexLock(&self->server->mu); if (NACL_REVERSE_CHANNEL_INITIALIZED != self->server->reverse_channel_initialization_state) { NaClLog(LOG_FATAL, "NaClManifestProxyConnectionFactory invoked w/o reverse channel\n"); } NaClLog(4, "NaClManifestProxyConnectionFactory: inserting handler\n"); if (!(*NACL_VTBL(NaClSecureReverseClient, self->server->reverse_client)-> InsertHandler)(self->server->reverse_client, NaClManifestReverseClientCallback, (void *) mconn)) { NaClLog(LOG_FATAL, ("NaClManifestProxyConnectionFactory:" " NaClSecureReverseClientInsertHandler failed\n")); } /* * NaClSrpcInvokeBySignature(""); tell plugin to connect and create * a reverse channel */ NaClLog(4, ("NaClManifestProxyConnectionFactory: making RPC" " to set up connection\n")); rpc_result = NaClSrpcInvokeBySignature(&self->server->reverse_channel, NACL_REVERSE_CONTROL_ADD_CHANNEL, &bool_status); if (NACL_SRPC_RESULT_OK != rpc_result) { NaClLog(LOG_FATAL, "NaClManifestProxyConnectionFactory: add channel RPC failed: %d", rpc_result); } NaClLog(4, "NaClManifestProxyConnectionFactory: Start status %d\n", bool_status); NaClXMutexUnlock(&self->server->mu); *out = (struct NaClSimpleServiceConnection *) mconn; return 0; }
int main(int argc, char* argv[]) { nacl_abi_size_t char_array_count; char* char_array_carr; NaClHandle pair[2]; #ifdef __native_client__ int imc_desc[2]; #else struct NaClDescImcDesc* imc_desc[2]; #endif struct NaClThread thr; NaClSrpcChannel channel; NaClSrpcError error; struct ServiceThreadArgs* threadArg; UNREFERENCED_PARAMETER(argc); UNREFERENCED_PARAMETER(argv); NaClSrpcModuleInit(); if (0 != NaClSocketPair(pair)) { failWithErrno("SocketPair"); } #ifdef __native_client__ imc_desc[0] = pair[0]; imc_desc[1] = pair[1]; #else NaClNrdAllModulesInit(); imc_desc[0] = (struct NaClDescImcDesc*) calloc(1, sizeof(*imc_desc[0])); if (0 == imc_desc[0]) { failWithErrno("calloc"); } imc_desc[1] = (struct NaClDescImcDesc*) calloc(1, sizeof(*imc_desc[1])); if (0 == imc_desc[1]) { failWithErrno("calloc"); } if (!NaClDescImcDescCtor(imc_desc[0], pair[0])) { failWithErrno("NaClDescImcDescCtor"); } if (!NaClDescImcDescCtor(imc_desc[1], pair[1])) { failWithErrno("NaClDescImcDescCtor"); } #endif threadArg = (struct ServiceThreadArgs*) calloc(1, sizeof(*threadArg)); if (NULL == threadArg) { failWithErrno("calloc for threadArg"); } threadArg->desc = (NaClSrpcImcDescType)imc_desc[0]; if (!NaClThreadCreateJoinable(&thr, serviceThread, threadArg, 128*1024)) { failWithErrno("NaClThreadCtor"); } if (!NaClSrpcClientCtor(&channel, (NaClSrpcImcDescType) imc_desc[1])) { failWithErrno("NaClSrpcClientCtor"); } char_array_count = TEST_ARRAY_LENGTH; char_array_carr = (char*) calloc(TEST_ARRAY_LENGTH, sizeof(char)); if (!char_array_carr) { failWithErrno("calloc for char_array"); } memset(char_array_carr, TEST_NUM, TEST_ARRAY_LENGTH); error = NaClSrpcInvokeBySignature(&channel, "putArr:C:", char_array_count, char_array_carr); if (NACL_SRPC_RESULT_OK != error) { fprintf(stderr, "SRPC call to putArr:C: failed: %s\n", NaClSrpcErrorString(error)); exit(EXIT_FAILURE); } free(char_array_carr); NaClSrpcDtor(&channel); #ifdef __native_client__ close(imc_desc[1]); #else NaClDescUnref((NaClSrpcImcDescType)imc_desc[1]); #endif NaClThreadJoin(&thr); NaClSrpcModuleFini(); return 0; }
static void NaClManifestNameServiceLookupRpc( struct NaClSrpcRpc *rpc, struct NaClSrpcArg **in_args, struct NaClSrpcArg **out_args, struct NaClSrpcClosure *done_cls) { struct NaClManifestProxyConnection *proxy_conn = (struct NaClManifestProxyConnection *) rpc->channel->server_instance_data; char *name = in_args[0]->arrays.str; int flags = in_args[1]->u.ival; char cookie[20]; uint32_t cookie_size = sizeof cookie; int status; struct NaClDesc *desc; struct NaClFileToken file_token; NaClSrpcError srpc_error; NaClLog(4, "NaClManifestNameServiceLookupRpc\n"); NaClManifestWaitForChannel_yield_mu(proxy_conn); NaClLog(4, "NaClManifestNameServiceLookupRpc: name %s, flags %d\n", name, flags); NaClLog(4, "NaClManifestNameServiceLookupRpc: invoking %s\n", NACL_MANIFEST_LOOKUP); if (NACL_SRPC_RESULT_OK != (srpc_error = NaClSrpcInvokeBySignature(&proxy_conn->client_channel, NACL_MANIFEST_LOOKUP, name, flags, &status, &desc, &file_token.lo, &file_token.hi, &cookie_size, cookie))) { NaClLog(LOG_ERROR, ("Manifest lookup via channel 0x%"NACL_PRIxPTR" with RPC " NACL_MANIFEST_LOOKUP" failed: %d\n"), (uintptr_t) &proxy_conn->client_channel, srpc_error); rpc->result = srpc_error; } else { struct NaClManifestProxy *proxy = (struct NaClManifestProxy *) proxy_conn->base.server; struct NaClValidationCache *validation_cache = proxy->server->nap->validation_cache; struct NaClDesc *replacement_desc; /* * The cookie is used to release renderer-side pepper file handle. * For now, we leak. We need on-close callbacks on NaClDesc * objects to do this properly, but even that is insufficient * since the manifest NaClDesc could, in principle, be transferred * to another process -- we would need distributed garbage * protection. If Pepper could take advantage of host-OS-side * reference counting that is already done, this wouldn't be a * problem. */ NaClLog(4, "NaClManifestNameServiceLookupRpc: got cookie %.*s\n", cookie_size, cookie); replacement_desc = NaClExchangeFileTokenForMappableDesc(&file_token, validation_cache); if (NULL != replacement_desc) { NaClDescUnref(desc); desc = replacement_desc; } out_args[0]->u.ival = status; out_args[1]->u.hval = desc; rpc->result = NACL_SRPC_RESULT_OK; } (*done_cls->Run)(done_cls); NaClDescUnref(desc); NaClManifestReleaseChannel_release_mu(proxy_conn); }