/*
* 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);
}
