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; }
void nacl_irt_init(uint32_t *info) { void (*fini)(void) = nacl_startup_fini(info); char **envp = nacl_startup_envp(info); environ = envp; /* * We are the true entry point, never called by a dynamic linker. * So the finalizer function pointer is always NULL. * We don't bother registering anything with atexit anyway, * since we do not expect our own exit function ever to be called. * Any cleanup we might need done must happen in nacl_irt_exit (irt_basic.c). */ assert(fini == NULL); __pthread_initialize(); __libc_init_array(); /* * SRPC is initialized for use by irt_nameservice.c, which is used * by irt_random.c, and (in Chromium) by irt_manifest.c. */ if (!NaClSrpcModuleInit()) { static const char fatal_msg[] = "NaClSrpcModuleInit() failed\n"; write(2, fatal_msg, sizeof(fatal_msg) - 1); _exit(-1); } NaClLogModuleInit(); /* Enable NaClLog'ing used by CHECK(). */ }
int main(void) { if (!NaClSrpcModuleInit()) { return 1; } if (!NaClSrpcAcceptClientConnection(srpc_methods)) { return 1; } NaClSrpcModuleFini(); return 0; }
static int IrtInit(void) { static int initialized = 0; if (initialized) { return 0; } if (!NaClSrpcModuleInit()) { return 1; } NaClLogModuleInit(); /* Enable NaClLog'ing used by CHECK(). */ initialized = 1; return 0; }
int main(void) { int d; NaClSrpcModuleInit(); while ((d = imc_accept(3)) != -1) { pthread_t thr; if (0 != pthread_create(&thr, (pthread_attr_t *) NULL, RpcHandler, (void *) d)) { perror("pthread_create for RpcHandler"); abort(); } } NaClSrpcModuleFini(); return 0; }
int main(void) { int rv; if (__nacl_register_thread_creator) { if (!NaClSrpcModuleInit()) { return 1; } } rv = PpapiPluginMain(); if (__nacl_register_thread_creator) { NaClSrpcModuleFini(); } 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 main(int argc, char* argv[]) { int retval; struct work_item *item; if (!NaClSrpcModuleInit()) { return 1; } if (!NaClSrpcAcceptClientOnThread(srpc_methods)) { return 1; } /* Initialize the graphics subsystem. */ retval = nacl_multimedia_init(NACL_SUBSYSTEM_VIDEO | NACL_SUBSYSTEM_EMBED); if (0 != retval) { return 1; } retval = nacl_video_init(BASEWIDTH, BASEHEIGHT); if (0 != retval) { return 1; } /* Process requests from the UI. */ while (NULL != (item = work_get())) { switch (item->kind) { #define D(k,m) case k: m(item); break D(WORK_SETUP, do_SetupGlobals); D(WORK_SHUTDOWN, do_ShutdownSharedMemory); D(WORK_SET_REGION, do_SetRegion); D(WORK_DISPLAY, do_MandelDisplay); D(WORK_SHIFT_COLOR, do_ShiftColors); } work_mark_done(item); } /* Shutdown and return. */ nacl_video_shutdown(); nacl_multimedia_shutdown(); NaClSrpcModuleFini(); return 0; }
int main(int ac, char **av) { int opt; unsigned long seed = 0; int seed_provided = 0; uint32_t max_num_pages = k_max_num_pages; uint32_t max_mmaps_per_cycle = k_max_mmaps_per_cycle; uint32_t num_test_cycles = k_num_test_cycles; double bad_size_probability = k_bad_size_probability; double release_probability = k_release_probability; size_t max_memory_carried_forward = k_max_memory_carried_forward; unsigned num_failures = 0; struct TestState tstate; while (-1 != (opt = getopt(ac, av, "c:m:M:n:p:r:s:v"))) { switch (opt) { case 'c': max_memory_carried_forward = strtoull(optarg, (char **) NULL, 0); break; case 'm': max_num_pages = strtoul(optarg, (char **) NULL, 0); break; case 'M': max_mmaps_per_cycle = strtoul(optarg, (char **) NULL, 0); break; case 'n': num_test_cycles = strtoul(optarg, (char **) NULL, 0); break; case 'p': bad_size_probability = strtod(optarg, (char **) NULL); break; case 'r': release_probability = strtod(optarg, (char **) NULL); break; case 's': seed_provided = 1; seed = strtoul(optarg, (char **) NULL, 0); break; case 'v': ++g_verbosity; break; default: fprintf(stderr, "Usage: pagesize_test [-v] [-m max_pages_per_allocation]\n" " [-M mmaps_per_test_cycle] [-n num_test_cycles]\n" " [-p bad_size_probability] [-r release_probability]\n" " [-s seed]\n"); } } if (!NaClSrpcModuleInit()) { fprintf(stderr, "SRPC module init failed\n"); return 1; } if (!seed_provided) { seed = get_good_seed(); } printf("seed = %lu (0x%lx)\n", seed, seed); if (!TestStateCtor(&tstate, num_test_cycles, max_mmaps_per_cycle, max_num_pages, bad_size_probability, release_probability, max_memory_carried_forward, seed)) { fprintf(stderr, "Test State ctor failure\n"); return 1; } if (g_verbosity > 0) { printf("TestStateCtor succeeded, starting tests\n"); } num_failures = RunTest(&tstate); printf("Tests finished; %u errors\n", num_failures); if (0 == num_failures) { printf("PASSED\n"); } else { printf("FAILED\n"); } NaClSrpcModuleFini(); return num_failures; }
static void serve_link_request(int (*func)(int nexe_fd, const int *obj_file_fds, int obj_file_fd_count)) { const char *inputs_str = getenv(kInputsVar); const char *output_filename = getenv(kOutputVar); if (output_filename == NULL) { /* * TODO(mseaborn): After the PNaCl toolchain revision has been updated, * this SRPC case will no longer be used and can be removed. */ g_func = func; if (!NaClSrpcModuleInit()) { NaClLog(LOG_FATAL, "NaClSrpcModuleInit() failed\n"); } if (!NaClSrpcAcceptClientConnection(srpc_methods)) { NaClLog(LOG_FATAL, "NaClSrpcAcceptClientConnection() failed\n"); } return; } if (output_filename == NULL) NaClLog(LOG_FATAL, "serve_link_request: Env var %s not set\n", kOutputVar); /* Open output file. */ int nexe_fd = open(output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); if (nexe_fd < 0) { NaClLog(LOG_FATAL, "serve_link_request: Failed to open output file \"%s\": %s\n", output_filename, strerror(errno)); } if (inputs_str != NULL) { /* * Open input files. Parse colon-separated list. This is the old * case, which can't handle colons in filenames and so doesn't work * when using Windows' absolute filenames. * * TODO(mseaborn): After the PNaCl toolchain revision has been updated, * this case will no longer be used and can be removed. */ if (*inputs_str == '\0') NaClLog(LOG_FATAL, "serve_link_request: List of inputs is empty\n"); char *inputs_copy = strdup(inputs_str); size_t inputs_count = 1 + count_colon_separators(inputs_copy); int input_fds[inputs_count]; char *pos = inputs_copy; size_t i = 0; while (pos != NULL) { char *input_filename = pos; strsep(&pos, ":"); int input_fd = open(input_filename, O_RDONLY); if (input_fd < 0) { NaClLog(LOG_FATAL, "serve_link_request: Failed to open input file \"%s\": %s\n", input_filename, strerror(errno)); } assert(i < inputs_count); input_fds[i++] = input_fd; } assert(i == inputs_count); free(inputs_copy); func(nexe_fd, input_fds, inputs_count); return; } /* Open input files. */ size_t inputs_count = 0; char **env; for (env = environ; *env != NULL; env++) { if (env_var_prefix_match(*env, kInputVar) != NULL) ++inputs_count; } int input_fds[inputs_count]; size_t i = 0; for (env = environ; *env != NULL; env++) { char *input_filename = env_var_prefix_match(*env, kInputVar); if (input_filename != NULL) { int input_fd = open(input_filename, O_RDONLY); if (input_fd < 0) { NaClLog(LOG_FATAL, "serve_link_request: Failed to open input file \"%s\": %s\n", input_filename, strerror(errno)); } assert(i < inputs_count); input_fds[i++] = input_fd; } } assert(i == inputs_count); func(nexe_fd, input_fds, inputs_count); }
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 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; }