int main(void) {
int ns;
int connected_socket;
if (!NaClSrpcModuleInit()) {
return 1;
}
ns = -1;
nacl_nameservice(&ns);
assert(-1 != ns);
connected_socket = imc_connect(ns);
assert(-1 != connected_socket);
if (!NaClSrpcClientCtor(&ns_channel, connected_socket)) {
fprintf(stderr, "Srpc client channel ctor failed\n");
return 1;
}
close(ns);
if (!NaClSrpcAcceptClientConnection(srpc_methods)) {
return 1;
}
NaClSrpcModuleFini();
return 0;
}
static int get_manifest_channel_locked(struct NaClSrpcChannel **result) {
int status;
int manifest;
int manifest_conn;
if (manifest_channel_initialized) {
*result = &manifest_channel;
return 0;
}
*result = NULL;
status = irt_nameservice_lookup("ManifestNameService", O_RDWR, &manifest);
if (NACL_NAME_SERVICE_SUCCESS != status) {
print_error("ManifestNameService lookup failed\n");
return EIO;
}
if (-1 == manifest) {
print_error("Manifest descriptor is invalid\n");
return EIO;
}
manifest_conn = imc_connect(manifest);
close(manifest);
if (-1 == manifest_conn) {
print_error("Can't connect to manifest service\n");
return EIO;
}
if (!NaClSrpcClientCtor(&manifest_channel, manifest_conn)) {
print_error("Can't create manifest srpc channel\n");
return EIO;
}
*result = &manifest_channel;
manifest_channel_initialized = 1;
return 0;
}
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;
}
void test_imc_connect_with_no_acceptor(void) {
int bound_pair[2];
int rc;
rc = imc_makeboundsock(bound_pair);
assert(rc == 0);
printf("Test imc_connect() when BoundSocket has been dropped...\n");
checked_close(bound_pair[0]);
rc = imc_connect(bound_pair[1]);
assert(rc == -1);
assert(errno == EIO);
checked_close(bound_pair[1]);
}
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);
}
void connect_and_accept(int boundsock_fd, int sockaddr_fd,
int *result_fd1, int *result_fd2) {
struct accept_thread_args args = { -1, -1 };
pthread_t tid;
/* TODO(mseaborn): Use of a thread here is necessary on Windows, but
not on Linux or Mac OS X. See
http://code.google.com/p/nativeclient/issues/detail?id=692 */
args.boundsock_fd = boundsock_fd;
pthread_create(&tid, NULL, accept_thread, &args);
*result_fd1 = imc_connect(sockaddr_fd);
assert(*result_fd1 >= 0);
pthread_join(tid, NULL);
*result_fd2 = args.result_fd;
assert(*result_fd2 >= 0);
}
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 main(int ac, char **av) {
int opt;
char const *message = NULL;
char const *message2 = NULL;
int server = 0;
int client_desc = -1;
int channel;
int sockaddrd; /* socket address descriptor */
int subchannel;
int rv;
char data_buffer[4096];
int desc_buffer[NACL_ABI_IMC_USER_DESC_MAX];
size_t i;
unsigned long loop_iter = 1;
unsigned int sleep_seconds = 0;
while (EOF != (opt = getopt(ac, av, "c:l:m:M:sS:t:v"))) {
switch (opt) {
case 'c':
client_desc = strtol(optarg, (char **) 0, 0);
/* descriptor holds a connection capability for the server */
break;
case 'l':
loop_iter = strtoul(optarg, (char **) 0, 0);
break;
case 'm':
message = optarg;
break;
case 'M':
message2 = optarg;
break;
case 's':
server = 1;
break;
case 'S':
sleep_seconds = strtoul(optarg, (char **) 0, 0);
break;
default:
fprintf(stderr,
("Usage: sel_ldr [sel_ldr_args] -- " /* no newline */
"nrd_xfer_test2.nexe [-c server-addr-desc] [-s]\n"
" [-l loop_count] [-S server-sleep-sec]\n"
"\n"
"Typically, server is run using a command such as\n"
"\n"
" sel_ldr -X -1 -D 1 -f nrd_xfer_test2.nexe -- -s\n"
"\n"
"so the socket address is printed to standard output,\n"
"and then the client is run with a command such as\n"
"\n"
" sel_ldr -X -1 -a 6:<addr-from-server> " /* no \n */
"-- nrd_xfer_test_nacl.nexe -c 6\n"
"\n"
"to have descriptor 6 be used to represent the socket\n"
"address for connecting to the server\n"));
return 1;
}
}
for (i = 0; i < sizeof desc_buffer / sizeof desc_buffer[0]; ++i) {
desc_buffer[i] = -1;
}
if (server) {
message = (NULL != message) ? message
: "\"Hello world!\", from server\n";
message2 = (NULL != message2) ? message2
: "SERVER MSG2";
} else {
message = (NULL != message) ? message
: "Client connect request\n";
message2 = (NULL != message2) ? message2
:"\"Goodbye cruel world!\", from client\n";
}
if (server) {
int pair[2];
pthread_t thr;
int err;
printf("Accepting a client connection...\n");
channel = imc_accept(3);
printf("...got channel descriptor %d\n", channel);
do {
rv = recv_imc_msg(channel, data_buffer, sizeof data_buffer, NULL);
printf("Receive returned %d\n", rv);
if (-1 == rv) {
fprintf(stderr, "imc_recvmsg failed\n");
return 1;
}
printf("Data bytes: %.*s\n", rv, data_buffer);
/* send a reply */
if (-1 == imc_makeboundsock(pair)) {
fprintf(stderr, "imc_socketpair failed, errno %d\n", errno);
return 2;
}
/*
* send pair[1], the addr, to peer as reply.
*/
send_imc_msg(channel, "sockaddr", pair[1]);
err = pthread_create(&thr, NULL, worker_thread, (void *) pair[0]);
if (0 != err) {
fprintf(stderr, "pthread_create failed, returned %d\n", err);
return 4;
}
pthread_detach(thr);
if (-1 == close(pair[1])) {
fprintf(stderr, "close of socketpair half failed\n");
}
if (0 != sleep_seconds) {
printf("sleeping for %d seconds...\n", sleep_seconds);
sleep(sleep_seconds);
}
} while (--loop_iter > 0);
if (-1 == close(channel)) {
fprintf(stderr, "close of channel %d failed\n", channel);
}
} else {
if (-1 == client_desc) {
fprintf(stderr,
"Client needs server socket address to which to connect\n");
return 100;
}
channel = imc_connect(client_desc);
printf("Connect returned %d\n", channel);
if (-1 == channel) {
fprintf(stderr, "Client could not connect, errno %d\n", errno);
return 101;
}
do {
send_imc_msg(channel, message, -1);
rv = recv_imc_msg(channel, data_buffer, sizeof data_buffer, &sockaddrd);
printf("start RPC reply returned socket addr desc %d\n", sockaddrd);
if (-1 == sockaddrd) {
fprintf(stderr, "connect failed, errno %d\n", errno);
return 106;
}
subchannel = imc_connect(sockaddrd);
if (-1 == subchannel) {
printf("Connect for client-specific socket failed: errno %d\n", errno);
return 107;
}
if (-1 == close(sockaddrd)) {
fprintf(stderr, "close of %d sockaddr failed, errno %d\n",
sockaddrd, errno);
}
send_imc_msg(subchannel, message2, -1);
if (-1 == (rv = recv_imc_msg(subchannel, data_buffer, sizeof data_buffer,
NULL))) {
fprintf(stderr, "receive from worker thread failed, errno %d\n",
errno);
return 108;
}
/* let's not trust server to NUL terminate */
data_buffer[sizeof data_buffer - 1] = '\0';
printf("reply: %s\n", data_buffer);
if (-1 == close(subchannel)) {
fprintf(stderr, "close of subchannel %d failed\n", subchannel);
}
} while (--loop_iter > 0);
if (-1 == close(channel)) {
fprintf(stderr, "close of %d (channel) failed\n", channel);
}
}
return 0;
}
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);
}
