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;
}
