int main() { PRFileDesc *prstderr = PR_GetSpecialFD(PR_StandardError); PRBool failed = PR_FALSE; PRProtoEnt proto; char buf[2048]; PRStatus rv; PR_STDIO_INIT(); rv = PR_GetProtoByName("tcp", buf, sizeof(buf), &proto); if (PR_FAILURE == rv) { failed = PR_TRUE; PL_FPrintError(prstderr, "PR_GetProtoByName failed"); } else if (6 != proto.p_num) { PR_fprintf( prstderr,"tcp is usually 6, but is %d on this machine\n", proto.p_num); } else PR_fprintf(prstderr, "tcp is protocol number %d\n", proto.p_num); rv = PR_GetProtoByName("udp", buf, sizeof(buf), &proto); if (PR_FAILURE == rv) { failed = PR_TRUE; PL_FPrintError(prstderr, "PR_GetProtoByName failed"); } else if (17 != proto.p_num) { PR_fprintf( prstderr, "udp is usually 17, but is %d on this machine\n", proto.p_num); } else PR_fprintf(prstderr, "udp is protocol number %d\n", proto.p_num); rv = PR_GetProtoByNumber(6, buf, sizeof(buf), &proto); if (PR_FAILURE == rv) { failed = PR_TRUE; PL_FPrintError(prstderr, "PR_GetProtoByNumber failed"); } else if (PL_strcmp("tcp", proto.p_name)) { PR_fprintf( prstderr, "Protocol number 6 is usually tcp, but is %s" " on this platform\n", proto.p_name); } else PR_fprintf(prstderr, "Protocol number 6 is %s\n", proto.p_name); rv = PR_GetProtoByNumber(17, buf, sizeof(buf), &proto); if (PR_FAILURE == rv) { failed = PR_TRUE; PL_FPrintError(prstderr, "PR_GetProtoByNumber failed"); } else if (PL_strcmp("udp", proto.p_name)) { PR_fprintf( prstderr, "Protocol number 17 is usually udp, but is %s" " on this platform\n", proto.p_name); } else PR_fprintf(prstderr, "Protocol number 17 is %s\n", proto.p_name); PR_fprintf(prstderr, (failed) ? "FAILED\n" : "PASSED\n"); return (failed) ? 1 : 0; }
static void Help(void) { PRFileDesc *err = PR_GetSpecialFD(PR_StandardError); PR_fprintf(err, "Usage: /.strod [-c n] [-l n] [-h]\n"); PR_fprintf(err, "\t-n n Number to translate (default: 1234567890123456789)\n"); PR_fprintf(err, "\t-l n Times to loop the test (default: 1)\n"); PR_fprintf(err, "\t-h This message and nothing else\n"); } /* Help */
static PRIntn PR_CALLBACK stdio(PRIntn argc, char **argv) { PRInt32 rv; PRFileDesc *out = PR_GetSpecialFD(PR_StandardOutput); PRFileDesc *err = PR_GetSpecialFD(PR_StandardError); rv = PR_Write( out, "This to standard out\n", strlen("This to standard out\n")); PR_ASSERT((PRInt32)strlen("This to standard out\n") == rv); rv = PR_Write( err, "This to standard err\n", strlen("This to standard err\n")); PR_ASSERT((PRInt32)strlen("This to standard err\n") == rv); return 0; } /* stdio */
static void Help(void) { PRFileDesc *err = PR_GetSpecialFD(PR_StandardError); PR_fprintf(err, "Cleanup usage: [-g] [-s n] [-t n] [-c n] [-h]\n"); PR_fprintf(err, "\t-c Call cleanup before exiting (default: false)\n"); PR_fprintf(err, "\t-G Use global threads only (default: local)\n"); PR_fprintf(err, "\t-t n Number of threads involved (default: 1)\n"); PR_fprintf(err, "\t-s n Seconds thread(s) should dally (defaut: 10)\n"); PR_fprintf(err, "\t-S n Seconds main() should dally (defaut: 5)\n"); PR_fprintf(err, "\t-C n Value to set concurrency (default 1)\n"); PR_fprintf(err, "\t-h This message and nothing else\n"); } /* Help */
static PRIntn PR_CALLBACK RealMain(PRIntn argc, char **argv) { Overlay_i si; Overlay_u ui; PLOptStatus os; PRBool bsi = PR_FALSE, bui = PR_FALSE; PLOptState *opt = PL_CreateOptState(argc, argv, "hi:u:"); err = PR_GetSpecialFD(PR_StandardError); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'i': /* signed integer */ si.i = (PRInt32)atoi(opt->value); bsi = PR_TRUE; break; case 'u': /* unsigned */ ui.i = (PRUint32)atoi(opt->value); bui = PR_TRUE; break; case 'h': /* user wants some guidance */ default: Help(); /* so give him an earful */ return 2; /* but not a lot else */ } } PL_DestroyOptState(opt); #if defined(HAVE_LONG_LONG) PR_fprintf(err, "We have long long\n"); #else PR_fprintf(err, "We don't have long long\n"); #endif if (bsi) { PR_fprintf(err, "Converting %ld: ", si.i); LL_I2L(si.l, si.i); PR_fprintf(err, "%lld\n", si.l); } if (bui) { PR_fprintf(err, "Converting %lu: ", ui.i); LL_I2L(ui.l, ui.i); PR_fprintf(err, "%llu\n", ui.l); } return 0; } /* main */
static void usage (const char *program_name) { PRFileDesc *debug_out = PR_GetSpecialFD(PR_StandardError); PR_fprintf (debug_out, "type %s -H for more detail information.\n", program_name); PR_fprintf (debug_out, "Usage: %s [-v] [-V] [-o outfile] [-d dbdir] [-f pwfile]\n" " [-F] [-p pwd] -[P dbprefix ] " "-i shared_library_name\n", program_name); exit(1); }
PRIntn main(PRIntn argc, char **argv) { PRInt32 rv, test, result = 0; PRFileDesc *output = PR_GetSpecialFD(PR_StandardOutput); test = -2; rv = PR_AtomicIncrement(&test); result = result | ((rv < 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicIncrement(%d) == %d: %s\n", test, rv, (rv < 0) ? "PASSED" : "FAILED"); rv = PR_AtomicIncrement(&test); result = result | ((rv == 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicIncrement(%d) == %d: %s\n", test, rv, (rv == 0) ? "PASSED" : "FAILED"); rv = PR_AtomicIncrement(&test); result = result | ((rv > 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicIncrement(%d) == %d: %s\n", test, rv, (rv > 0) ? "PASSED" : "FAILED"); test = 2; rv = PR_AtomicDecrement(&test); result = result | ((rv > 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicDecrement(%d) == %d: %s\n", test, rv, (rv > 0) ? "PASSED" : "FAILED"); rv = PR_AtomicDecrement(&test); result = result | ((rv == 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicDecrement(%d) == %d: %s\n", test, rv, (rv == 0) ? "PASSED" : "FAILED"); rv = PR_AtomicDecrement(&test); result = result | ((rv < 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicDecrement(%d) == %d: %s\n", test, rv, (rv < 0) ? "PASSED" : "FAILED"); test = -2; rv = PR_AtomicSet(&test, 2); result = result | (((rv == -2) && (test == 2)) ? 0 : 1); PR_fprintf( output, "PR_AtomicSet(%d) == %d: %s\n", test, rv, ((rv == -2) && (test == 2)) ? "PASSED" : "FAILED"); PR_fprintf( output, "Atomic operations test %s\n", (result == 0) ? "PASSED" : "FAILED"); return result; } /* main */
static PRIntn PR_CALLBACK RealMain( PRIntn argc, char **argv ) { PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "dhlmc"); PRBool locks = PR_FALSE, monitors = PR_FALSE, cmonitors = PR_FALSE; err = PR_GetSpecialFD(PR_StandardError); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode (noop) */ break; case 'l': /* locks */ locks = PR_TRUE; break; case 'm': /* monitors */ monitors = PR_TRUE; break; case 'c': /* cached monitors */ cmonitors = PR_TRUE; break; case 'h': /* needs guidance */ default: Help(); return 2; } } PL_DestroyOptState(opt); ml = PR_NewLock(); if (locks) T1Lock(); if (monitors) T1Mon(); if (cmonitors) T1CMon(); PR_DestroyLock(ml); PR_fprintf(err, "Done!\n"); return 0; } /* main */
static PRIntn PR_CALLBACK RealMain(PRIntn argc, char **argv) { PLOptStatus os; PRIntn loops = 1; PRFloat64 answer; const char *number = "1234567890123456789"; PRFileDesc *err = PR_GetSpecialFD(PR_StandardError); PLOptState *opt = PL_CreateOptState(argc, argv, "hc:l:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'n': /* number to translate */ number = opt->value; break; case 'l': /* number of times to run the tests */ loops = atoi(opt->value); break; case 'h': /* user wants some guidance */ Help(); /* so give him an earful */ return 2; /* but not a lot else */ break; default: break; } } PL_DestroyOptState(opt); PR_fprintf(err, "Settings\n"); PR_fprintf(err, "\tNumber to translate %s\n", number); PR_fprintf(err, "\tLoops to run test: %d\n", loops); while (loops--) { answer = PR_strtod(number, NULL); PR_fprintf(err, "Translation = %20.0f\n", answer); } return 2; }
RCIO *RCFileIO::GetSpecialFile(RCFileIO::SpecialFile special) { PRFileDesc* fd; PRSpecialFD which; RCFileIO* spec = NULL; switch (special) { case RCFileIO::input: which = PR_StandardInput; break; case RCFileIO::output: which = PR_StandardOutput; break; case RCFileIO::error: which = PR_StandardError; break; default: which = (PRSpecialFD)-1; } fd = PR_GetSpecialFD(which); if (NULL != fd) { spec = new RCFileIO(); if (NULL != spec) spec->fd = fd; } return spec; } /* RCFileIO::GetSpecialFile */
PRIntn main(PRIntn argc, char **argv) { PRStatus rv; PRSysInfo cmd; PRFileDesc *output = PR_GetSpecialFD(PR_StandardOutput); char *info = (char*)PR_Calloc(SYS_INFO_BUFFER_LENGTH, 1); for (cmd = PR_SI_HOSTNAME; cmd <= PR_SI_ARCHITECTURE; Incr(&cmd)) { rv = PR_GetSystemInfo(cmd, info, SYS_INFO_BUFFER_LENGTH); if (PR_SUCCESS == rv) PR_fprintf(output, "%s: %s\n", tag[cmd], info); else PL_FPrintError(output, tag[cmd]); } PR_DELETE(info); PR_fprintf(output, "Host page size is %d\n", PR_GetPageSize()); PR_fprintf(output, "Page shift is %d\n", PR_GetPageShift()); PR_fprintf(output, "Number of processors is: %d\n", PR_GetNumberOfProcessors()); return 0; } /* main */
static void long_usage(const char *program_name) { PRFileDesc *debug_out = PR_GetSpecialFD(PR_StandardError); PR_fprintf(debug_out, "%s test program usage:\n", program_name); PR_fprintf(debug_out, "\t-i <infile> shared_library_name to process\n"); PR_fprintf(debug_out, "\t-o <outfile> checksum outfile\n"); PR_fprintf(debug_out, "\t-d <path> database path location\n"); PR_fprintf(debug_out, "\t-P <prefix> database prefix\n"); PR_fprintf(debug_out, "\t-f <file> password File : echo pw > file \n"); PR_fprintf(debug_out, "\t-F FIPS mode\n"); PR_fprintf(debug_out, "\t-p <pwd> password\n"); PR_fprintf(debug_out, "\t-v verbose output\n"); PR_fprintf(debug_out, "\t-V perform Verify operations\n"); PR_fprintf(debug_out, "\t-? short help message\n"); PR_fprintf(debug_out, "\t-h short help message\n"); PR_fprintf(debug_out, "\t-H this help message\n"); PR_fprintf(debug_out, "\n\n\tNote: Use of FIPS mode requires your "); PR_fprintf(debug_out, "library path is using \n"); PR_fprintf(debug_out, "\t pre-existing libraries with generated "); PR_fprintf(debug_out, "checksum files\n"); PR_fprintf(debug_out, "\t and database in FIPS mode \n"); exit(1); }
int main(int argc, char **argv) { PRStatus rv; PRFileDesc *udp = PR_NewUDPSocket(); PRFileDesc *tcp = PR_NewTCPSocket(); const char *tag[] = { "PR_SockOpt_Nonblocking", /* nonblocking io */ "PR_SockOpt_Linger", /* linger on close if data present */ "PR_SockOpt_Reuseaddr", /* allow local address reuse */ "PR_SockOpt_Keepalive", /* keep connections alive */ "PR_SockOpt_RecvBufferSize", /* send buffer size */ "PR_SockOpt_SendBufferSize", /* receive buffer size */ "PR_SockOpt_IpTimeToLive", /* time to live */ "PR_SockOpt_IpTypeOfService", /* type of service and precedence */ "PR_SockOpt_AddMember", /* add an IP group membership */ "PR_SockOpt_DropMember", /* drop an IP group membership */ "PR_SockOpt_McastInterface", /* multicast interface address */ "PR_SockOpt_McastTimeToLive", /* multicast timetolive */ "PR_SockOpt_McastLoopback", /* multicast loopback */ "PR_SockOpt_NoDelay", /* don't delay send to coalesce packets */ "PR_SockOpt_MaxSegment", /* maximum segment size */ "PR_SockOpt_Broadcast", /* Enable broadcast */ "PR_SockOpt_Last" }; err = PR_GetSpecialFD(PR_StandardError); PR_STDIO_INIT(); if (NULL == udp) Failed("PR_NewUDPSocket()", NULL); else if (NULL == tcp) Failed("PR_NewTCPSocket()", NULL); else { PRSockOption option; PRUint32 segment = 1024; PRNetAddr addr; rv = PR_InitializeNetAddr(PR_IpAddrAny, 0, &addr); if (PR_FAILURE == rv) Failed("PR_InitializeNetAddr()", NULL); rv = PR_Bind(udp, &addr); if (PR_FAILURE == rv) Failed("PR_Bind()", NULL); for(option = PR_SockOpt_Linger; option < PR_SockOpt_Last; Incr(&option)) { PRSocketOptionData data; PRFileDesc *fd = tcp; data.option = option; switch (option) { case PR_SockOpt_Nonblocking: data.value.non_blocking = PR_TRUE; break; #ifndef SYMBIAN case PR_SockOpt_Linger: data.value.linger.polarity = PR_TRUE; data.value.linger.linger = PR_SecondsToInterval(2); break; #endif case PR_SockOpt_Reuseaddr: data.value.reuse_addr = PR_TRUE; break; case PR_SockOpt_Keepalive: data.value.keep_alive = PR_TRUE; break; case PR_SockOpt_RecvBufferSize: data.value.recv_buffer_size = segment; break; case PR_SockOpt_SendBufferSize: data.value.send_buffer_size = segment; break; #ifndef SYMBIAN case PR_SockOpt_IpTimeToLive: data.value.ip_ttl = 64; break; case PR_SockOpt_IpTypeOfService: data.value.tos = 0; break; case PR_SockOpt_McastTimeToLive: fd = udp; data.value.mcast_ttl = 4; break; case PR_SockOpt_McastLoopback: fd = udp; data.value.mcast_loopback = PR_TRUE; break; #endif case PR_SockOpt_NoDelay: data.value.no_delay = PR_TRUE; break; #ifndef WIN32 case PR_SockOpt_MaxSegment: data.value.max_segment = segment; break; #endif #ifndef SYMBIAN case PR_SockOpt_Broadcast: fd = udp; data.value.broadcast = PR_TRUE; break; #endif default: continue; } /* * TCP_MAXSEG can only be read, not set */ if (option != PR_SockOpt_MaxSegment) { #ifdef WIN32 if (option != PR_SockOpt_McastLoopback) #endif { rv = PR_SetSocketOption(fd, &data); if (PR_FAILURE == rv) Failed("PR_SetSocketOption()", tag[option]); } } rv = PR_GetSocketOption(fd, &data); if (PR_FAILURE == rv) Failed("PR_GetSocketOption()", tag[option]); } PR_Close(udp); PR_Close(tcp); } PR_fprintf(err, "%s\n", (failed) ? "FAILED" : "PASSED"); return (failed) ? 1 : 0; } /* main */
static PRIntn PR_CALLBACK RealMain(int argc, char** argv) { PRUint32 vcpu, cpus = 0, loops = 1000; /* The command line argument: -d is used to determine if the test is being run in debug mode. The regress tool requires only one line output:PASS or FAIL. All of the printfs associated with this test has been handled with a if (debug_mode) test. Usage: test_name -d */ /* main test */ PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "dl:c:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode */ debug_mode = 1; break; case 'c': /* concurrency counter */ cpus = atoi(opt->value); break; case 'l': /* loop counter */ loops = atoi(opt->value); break; default: break; } } PL_DestroyOptState(opt); output = PR_GetSpecialFD(PR_StandardOutput); PR_fprintf(output, "inrval: Examine stdout to determine results.\n"); if (cpus == 0) cpus = 8; if (loops == 0) loops = 1000; if (debug_mode > 0) { PR_fprintf(output, "Inrval: Using %d loops\n", loops); PR_fprintf(output, "Inrval: Using 1 and %d cpu(s)\n", cpus); } for (vcpu = 1; vcpu <= cpus; vcpu += cpus - 1) { if (debug_mode) PR_fprintf(output, "\nInrval: Using %d CPU(s)\n\n", vcpu); PR_SetConcurrency(vcpu); TestNowOverhead(); TestIntervalOverhead(); TestConversions(); TestIntervals(); } return 0; }
PRIntn main(PRIntn argc, char **argv) { PRStatus rv; PRIntn mits; PLOptStatus os; PRFileDesc *client, *service; PRFileDesc *client_stack, *service_stack; PRNetAddr any_address; const char *server_name = NULL; const PRIOMethods *stubMethods; PRThread *client_thread, *server_thread; PRThreadScope thread_scope = PR_LOCAL_THREAD; PLOptState *opt = PL_CreateOptState(argc, argv, "dqGC:c:p:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: server_name = opt->value; break; case 'd': /* debug mode */ if (verbosity < noisy) verbosity = ChangeVerbosity(verbosity, 1); break; case 'q': /* debug mode */ if (verbosity > silent) verbosity = ChangeVerbosity(verbosity, -1); break; case 'G': /* use global threads */ thread_scope = PR_GLOBAL_THREAD; break; case 'C': /* number of threads waiting */ major_iterations = atoi(opt->value); break; case 'c': /* number of client threads */ minor_iterations = atoi(opt->value); break; case 'p': /* default port */ default_port = atoi(opt->value); break; default: break; } } PL_DestroyOptState(opt); PR_STDIO_INIT(); logFile = PR_GetSpecialFD(PR_StandardError); identity = PR_GetUniqueIdentity("Dummy"); stubMethods = PR_GetDefaultIOMethods(); /* ** The protocol we're going to implement is one where in order to initiate ** a send, the sender must first solicit permission. Therefore, every ** send is really a send - receive - send sequence. */ myMethods = *stubMethods; /* first get the entire batch */ myMethods.recv = MyRecv; /* then override the ones we care about */ myMethods.send = MySend; /* then override the ones we care about */ if (NULL == server_name) rv = PR_InitializeNetAddr( PR_IpAddrLoopback, default_port, &server_address); else { rv = PR_StringToNetAddr(server_name, &server_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_InitializeNetAddr( PR_IpAddrNull, default_port, &server_address); } PR_ASSERT(PR_SUCCESS == rv); /* one type w/o layering */ mits = minor_iterations; while (major_iterations-- > 0) { if (verbosity > silent) PR_fprintf(logFile, "Beginning non-layered test\n"); client = PR_NewTCPSocket(); PR_ASSERT(NULL != client); service = PR_NewTCPSocket(); PR_ASSERT(NULL != service); rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv); minor_iterations = mits; server_thread = PR_CreateThread( PR_USER_THREAD, Server, service, PR_PRIORITY_HIGH, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != server_thread); client_thread = PR_CreateThread( PR_USER_THREAD, Client, client, PR_PRIORITY_NORMAL, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != client_thread); rv = PR_JoinThread(client_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_JoinThread(server_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(client); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(service); PR_ASSERT(PR_SUCCESS == rv); if (verbosity > silent) PR_fprintf(logFile, "Ending non-layered test\n"); /* with layering */ if (verbosity > silent) PR_fprintf(logFile, "Beginning layered test\n"); client = PR_NewTCPSocket(); PR_ASSERT(NULL != client); PushLayer(client); service = PR_NewTCPSocket(); PR_ASSERT(NULL != service); PushLayer(service); rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv); minor_iterations = mits; server_thread = PR_CreateThread( PR_USER_THREAD, Server, service, PR_PRIORITY_HIGH, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != server_thread); client_thread = PR_CreateThread( PR_USER_THREAD, Client, client, PR_PRIORITY_NORMAL, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != client_thread); rv = PR_JoinThread(client_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_JoinThread(server_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(client); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(service); PR_ASSERT(PR_SUCCESS == rv); /* with layering, using new style stack */ if (verbosity > silent) PR_fprintf(logFile, "Beginning layered test with new style stack\n"); client = PR_NewTCPSocket(); PR_ASSERT(NULL != client); client_stack = PR_CreateIOLayer(client); PushNewLayers(client_stack); service = PR_NewTCPSocket(); PR_ASSERT(NULL != service); service_stack = PR_CreateIOLayer(service); PushNewLayers(service_stack); rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv); minor_iterations = mits; server_thread = PR_CreateThread( PR_USER_THREAD, Server, service_stack, PR_PRIORITY_HIGH, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != server_thread); client_thread = PR_CreateThread( PR_USER_THREAD, Client, client_stack, PR_PRIORITY_NORMAL, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != client_thread); rv = PR_JoinThread(client_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_JoinThread(server_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(client_stack); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(service_stack); PR_ASSERT(PR_SUCCESS == rv); if (verbosity > silent) PR_fprintf(logFile, "Ending layered test\n"); } return 0; } /* main */
NS_IMETHOD Flush(void) { PR_Sync(PR_GetSpecialFD(PR_StandardOutput)); return NS_OK; }
int main(int argc, char **argv) { PRInt32 rv, oldval, test, result = 0; PRFileDesc *output = PR_GetSpecialFD(PR_StandardOutput); /***********************/ /* Test the functions. */ /***********************/ oldval = test = -2; rv = PR_AtomicIncrement(&test); result = result | ((rv == -1) ? 0 : 1); PR_fprintf( output, "PR_AtomicIncrement(%d) == %d: %s\n", oldval, rv, (rv == -1) ? "PASSED" : "FAILED"); oldval = test; rv = PR_AtomicIncrement(&test); result = result | ((rv == 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicIncrement(%d) == %d: %s\n", oldval, rv, (rv == 0) ? "PASSED" : "FAILED"); oldval = test; rv = PR_AtomicIncrement(&test); result = result | ((rv == 1) ? 0 : 1); PR_fprintf( output, "PR_AtomicIncrement(%d) == %d: %s\n", oldval, rv, (rv == 1) ? "PASSED" : "FAILED"); oldval = test = -2; rv = PR_AtomicAdd(&test,1); result = result | ((rv == -1) ? 0 : 1); PR_fprintf( output, "PR_AtomicAdd(%d,%d) == %d: %s\n", oldval, 1, rv, (rv == -1) ? "PASSED" : "FAILED"); oldval = test; rv = PR_AtomicAdd(&test, 4); result = result | ((rv == 3) ? 0 : 1); PR_fprintf( output, "PR_AtomicAdd(%d,%d) == %d: %s\n", oldval, 4, rv, (rv == 3) ? "PASSED" : "FAILED"); oldval = test; rv = PR_AtomicAdd(&test, -6); result = result | ((rv == -3) ? 0 : 1); PR_fprintf( output, "PR_AtomicAdd(%d,%d) == %d: %s\n", oldval, -6, rv, (rv == -3) ? "PASSED" : "FAILED"); oldval = test = 2; rv = PR_AtomicDecrement(&test); result = result | ((rv == 1) ? 0 : 1); PR_fprintf( output, "PR_AtomicDecrement(%d) == %d: %s\n", oldval, rv, (rv == 1) ? "PASSED" : "FAILED"); oldval = test; rv = PR_AtomicDecrement(&test); result = result | ((rv == 0) ? 0 : 1); PR_fprintf( output, "PR_AtomicDecrement(%d) == %d: %s\n", oldval, rv, (rv == 0) ? "PASSED" : "FAILED"); oldval = test; rv = PR_AtomicDecrement(&test); result = result | ((rv == -1) ? 0 : 1); PR_fprintf( output, "PR_AtomicDecrement(%d) == %d: %s\n", oldval, rv, (rv == -1) ? "PASSED" : "FAILED"); /* set to a different value */ oldval = test = -2; rv = PR_AtomicSet(&test, 2); result = result | (((rv == -2) && (test == 2)) ? 0 : 1); PR_fprintf( output, "PR_AtomicSet(%d, %d) == %d: %s\n", oldval, 2, rv, ((rv == -2) && (test == 2)) ? "PASSED" : "FAILED"); /* set to the same value */ oldval = test = -2; rv = PR_AtomicSet(&test, -2); result = result | (((rv == -2) && (test == -2)) ? 0 : 1); PR_fprintf( output, "PR_AtomicSet(%d, %d) == %d: %s\n", oldval, -2, rv, ((rv == -2) && (test == -2)) ? "PASSED" : "FAILED"); /***********************/ /* Test the macros. */ /***********************/ oldval = test = -2; rv = PR_ATOMIC_INCREMENT(&test); result = result | ((rv == -1) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_INCREMENT(%d) == %d: %s\n", oldval, rv, (rv == -1) ? "PASSED" : "FAILED"); oldval = test; rv = PR_ATOMIC_INCREMENT(&test); result = result | ((rv == 0) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_INCREMENT(%d) == %d: %s\n", oldval, rv, (rv == 0) ? "PASSED" : "FAILED"); oldval = test; rv = PR_ATOMIC_INCREMENT(&test); result = result | ((rv == 1) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_INCREMENT(%d) == %d: %s\n", oldval, rv, (rv == 1) ? "PASSED" : "FAILED"); oldval = test = -2; rv = PR_ATOMIC_ADD(&test,1); result = result | ((rv == -1) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_ADD(%d,%d) == %d: %s\n", oldval, 1, rv, (rv == -1) ? "PASSED" : "FAILED"); oldval = test; rv = PR_ATOMIC_ADD(&test, 4); result = result | ((rv == 3) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_ADD(%d,%d) == %d: %s\n", oldval, 4, rv, (rv == 3) ? "PASSED" : "FAILED"); oldval = test; rv = PR_ATOMIC_ADD(&test, -6); result = result | ((rv == -3) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_ADD(%d,%d) == %d: %s\n", oldval, -6, rv, (rv == -3) ? "PASSED" : "FAILED"); oldval = test = 2; rv = PR_ATOMIC_DECREMENT(&test); result = result | ((rv == 1) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_DECREMENT(%d) == %d: %s\n", oldval, rv, (rv == 1) ? "PASSED" : "FAILED"); oldval = test; rv = PR_ATOMIC_DECREMENT(&test); result = result | ((rv == 0) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_DECREMENT(%d) == %d: %s\n", oldval, rv, (rv == 0) ? "PASSED" : "FAILED"); oldval = test; rv = PR_ATOMIC_DECREMENT(&test); result = result | ((rv == -1) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_DECREMENT(%d) == %d: %s\n", oldval, rv, (rv == -1) ? "PASSED" : "FAILED"); /* set to a different value */ oldval = test = -2; rv = PR_ATOMIC_SET(&test, 2); result = result | (((rv == -2) && (test == 2)) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_SET(%d, %d) == %d: %s\n", oldval, 2, rv, ((rv == -2) && (test == 2)) ? "PASSED" : "FAILED"); /* set to the same value */ oldval = test = -2; rv = PR_ATOMIC_SET(&test, -2); result = result | (((rv == -2) && (test == -2)) ? 0 : 1); PR_fprintf( output, "PR_ATOMIC_SET(%d, %d) == %d: %s\n", oldval, -2, rv, ((rv == -2) && (test == -2)) ? "PASSED" : "FAILED"); PR_fprintf( output, "Atomic operations test %s\n", (result == 0) ? "PASSED" : "FAILED"); return result; } /* main */
int main(int argc, char **argv) { #if !(defined(SYMBIAN) && defined(__WINS__)) PRInt32 rv, cnt, sum; DataRecord *Item; PRStack *list1, *list2; PRStackElem *node; PRStatus rc; PRInt32 thread_cnt = DEFAULT_THREAD_CNT; PRInt32 data_cnt = DEFAULT_DATA_CNT; PRInt32 loops = DEFAULT_LOOP_CNT; PRThread **threads; stack_data *thread_args; PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "dt:c:l:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode */ _debug_on = 1; break; case 't': /* thread count */ thread_cnt = atoi(opt->value); break; case 'c': /* data count */ data_cnt = atoi(opt->value); break; case 'l': /* loop count */ loops = atoi(opt->value); break; default: break; } } PL_DestroyOptState(opt); PR_SetConcurrency(4); output = PR_GetSpecialFD(PR_StandardOutput); errhandle = PR_GetSpecialFD(PR_StandardError); list1 = PR_CreateStack("Stack_1"); if (list1 == NULL) { PR_fprintf(errhandle, "PR_CreateStack failed - error %d\n", PR_GetError()); return 1; } list2 = PR_CreateStack("Stack_2"); if (list2 == NULL) { PR_fprintf(errhandle, "PR_CreateStack failed - error %d\n", PR_GetError()); return 1; } threads = (PRThread**) PR_CALLOC(sizeof(PRThread*) * thread_cnt); thread_args = (stack_data *) PR_CALLOC(sizeof(stack_data) * thread_cnt); if (_debug_on) PR_fprintf(output,"%s: thread_cnt = %d data_cnt = %d\n", argv[0], thread_cnt, data_cnt); for(cnt = 0; cnt < thread_cnt; cnt++) { PRThreadScope scope; thread_args[cnt].list1 = list1; thread_args[cnt].list2 = list2; thread_args[cnt].loops = loops; thread_args[cnt].data_cnt = data_cnt; thread_args[cnt].initial_data_value = 1 + cnt * data_cnt; if (cnt & 1) scope = PR_GLOBAL_THREAD; else scope = PR_LOCAL_THREAD; threads[cnt] = PR_CreateThread(PR_USER_THREAD, stackop, &thread_args[cnt], PR_PRIORITY_NORMAL, scope, PR_JOINABLE_THREAD, 0); if (threads[cnt] == NULL) { PR_fprintf(errhandle, "PR_CreateThread failed - error %d\n", PR_GetError()); PR_ProcessExit(2); } if (_debug_on) PR_fprintf(output,"%s: created thread = 0x%x\n", argv[0], threads[cnt]); } for(cnt = 0; cnt < thread_cnt; cnt++) { rc = PR_JoinThread(threads[cnt]); PR_ASSERT(rc == PR_SUCCESS); } node = PR_StackPop(list1); /* * list1 should be empty */ if (node != NULL) { PR_fprintf(errhandle, "Error - Stack 1 not empty\n"); PR_ASSERT(node == NULL); PR_ProcessExit(4); } cnt = data_cnt * thread_cnt; sum = 0; while (cnt-- > 0) { node = PR_StackPop(list2); /* * There should be at least 'cnt' number of records */ if (node == NULL) { PR_fprintf(errhandle, "Error - PR_StackPop returned NULL\n"); PR_ProcessExit(3); } Item = RECORD_LINK_PTR(node); sum += Item->data; } node = PR_StackPop(list2); /* * there should be exactly 'cnt' number of records */ if (node != NULL) { PR_fprintf(errhandle, "Error - Stack 2 not empty\n"); PR_ASSERT(node == NULL); PR_ProcessExit(4); } PR_DELETE(threads); PR_DELETE(thread_args); PR_DestroyStack(list1); PR_DestroyStack(list2); if (sum == SUM_OF_NUMBERS(data_cnt * thread_cnt)) { PR_fprintf(output, "%s successful\n", argv[0]); PR_fprintf(output, "\t\tsum = 0x%x, expected = 0x%x\n", sum, SUM_OF_NUMBERS(thread_cnt * data_cnt)); return 0; } else { PR_fprintf(output, "%s failed: sum = 0x%x, expected = 0x%x\n", argv[0], sum, SUM_OF_NUMBERS(data_cnt * thread_cnt)); return 2; } #endif }
int main(int argc, char** argv) { PRUintn index; PRBool boolean; CSClient_t *client; PRStatus rv, joinStatus; CSServer_t *server = NULL; PRUintn backlog = DEFAULT_BACKLOG; PRUintn clients = DEFAULT_CLIENTS; const char *serverName = DEFAULT_SERVER; PRBool serverIsLocal = PR_TRUE; PRUintn accepting = ALLOWED_IN_ACCEPT; PRUintn workersMin = DEFAULT_WORKERS_MIN; PRUintn workersMax = DEFAULT_WORKERS_MAX; PRIntn execution = DEFAULT_EXECUTION_TIME; PRIntn low = DEFAULT_LOW, high = DEFAULT_HIGH; /* * -G use global threads * -a <n> threads allowed in accept * -b <n> backlock for listen * -c <threads> number of clients to create * -f <low> low water mark for caching FDs * -F <high> high water mark for caching FDs * -w <threads> minimal number of server threads * -W <threads> maximum number of server threads * -e <seconds> duration of the test in seconds * -s <string> dsn name of server (implies no server here) * -v verbosity */ PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "GX6b:a:c:f:F:w:W:e:s:vdhp"); debug_out = PR_GetSpecialFD(PR_StandardError); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'G': /* use global threads */ thread_scope = PR_GLOBAL_THREAD; break; case 'X': /* use XTP as transport */ protocol = 36; break; case '6': /* Use IPv6 */ domain = PR_AF_INET6; break; case 'a': /* the value for accepting */ accepting = atoi(opt->value); break; case 'b': /* the value for backlock */ backlog = atoi(opt->value); break; case 'c': /* number of client threads */ clients = atoi(opt->value); break; case 'f': /* low water fd cache */ low = atoi(opt->value); break; case 'F': /* low water fd cache */ high = atoi(opt->value); break; case 'w': /* minimum server worker threads */ workersMin = atoi(opt->value); break; case 'W': /* maximum server worker threads */ workersMax = atoi(opt->value); break; case 'e': /* program execution time in seconds */ execution = atoi(opt->value); break; case 's': /* server's address */ serverName = opt->value; break; case 'v': /* verbosity */ verbosity = IncrementVerbosity(); break; case 'd': /* debug mode */ debug_mode = PR_TRUE; break; case 'p': /* pthread mode */ pthread_stats = PR_TRUE; break; case 'h': default: Help(); return 2; } } PL_DestroyOptState(opt); if (0 != PL_strcmp(serverName, DEFAULT_SERVER)) serverIsLocal = PR_FALSE; if (0 == execution) execution = DEFAULT_EXECUTION_TIME; if (0 == workersMax) workersMax = DEFAULT_WORKERS_MAX; if (0 == workersMin) workersMin = DEFAULT_WORKERS_MIN; if (0 == accepting) accepting = ALLOWED_IN_ACCEPT; if (0 == backlog) backlog = DEFAULT_BACKLOG; if (workersMin > accepting) accepting = workersMin; PR_STDIO_INIT(); TimeOfDayMessage("Client/Server started at", PR_GetCurrentThread()); cltsrv_log_file = PR_NewLogModule("cltsrv_log"); MY_ASSERT(NULL != cltsrv_log_file); boolean = PR_SetLogFile("cltsrv.log"); MY_ASSERT(boolean); rv = PR_SetFDCacheSize(low, high); PR_ASSERT(PR_SUCCESS == rv); if (serverIsLocal) { /* Establish the server */ TEST_LOG( cltsrv_log_file, TEST_LOG_INFO, ("main(0x%p): starting server\n", PR_GetCurrentThread())); server = PR_NEWZAP(CSServer_t); PR_INIT_CLIST(&server->list); server->state = cs_init; server->ml = PR_NewLock(); server->backlog = backlog; server->port = DEFAULT_PORT; server->workers.minimum = workersMin; server->workers.maximum = workersMax; server->workers.accepting = accepting; server->stateChange = PR_NewCondVar(server->ml); server->pool.exiting = PR_NewCondVar(server->ml); server->pool.acceptComplete = PR_NewCondVar(server->ml); TEST_LOG( cltsrv_log_file, TEST_LOG_NOTICE, ("main(0x%p): creating server thread\n", PR_GetCurrentThread())); server->thread = PR_CreateThread( PR_USER_THREAD, Server, server, PR_PRIORITY_HIGH, thread_scope, PR_JOINABLE_THREAD, 0); TEST_ASSERT(NULL != server->thread); TEST_LOG( cltsrv_log_file, TEST_LOG_VERBOSE, ("main(0x%p): waiting for server init\n", PR_GetCurrentThread())); PR_Lock(server->ml); while (server->state == cs_init) PR_WaitCondVar(server->stateChange, PR_INTERVAL_NO_TIMEOUT); PR_Unlock(server->ml); TEST_LOG( cltsrv_log_file, TEST_LOG_VERBOSE, ("main(0x%p): server init complete (port #%d)\n", PR_GetCurrentThread(), server->port)); } if (clients != 0) { /* Create all of the clients */ PRHostEnt host; char buffer[BUFFER_SIZE]; client = (CSClient_t*)PR_CALLOC(clients * sizeof(CSClient_t)); TEST_LOG( cltsrv_log_file, TEST_LOG_VERBOSE, ("main(0x%p): creating %d client threads\n", PR_GetCurrentThread(), clients)); if (!serverIsLocal) { rv = PR_GetHostByName(serverName, buffer, BUFFER_SIZE, &host); if (PR_SUCCESS != rv) { PL_FPrintError(PR_STDERR, "PR_GetHostByName"); return 2; } } for (index = 0; index < clients; ++index) { client[index].state = cs_init; client[index].ml = PR_NewLock(); if (serverIsLocal) { if (PR_AF_INET6 != domain) (void)PR_InitializeNetAddr( PR_IpAddrLoopback, DEFAULT_PORT, &client[index].serverAddress); else rv = PR_SetNetAddr(PR_IpAddrLoopback, PR_AF_INET6, DEFAULT_PORT, &client[index].serverAddress); } else { (void)PR_EnumerateHostEnt( 0, &host, DEFAULT_PORT, &client[index].serverAddress); } client[index].stateChange = PR_NewCondVar(client[index].ml); TEST_LOG( cltsrv_log_file, TEST_LOG_INFO, ("main(0x%p): creating client threads\n", PR_GetCurrentThread())); client[index].thread = PR_CreateThread( PR_USER_THREAD, Client, &client[index], PR_PRIORITY_NORMAL, thread_scope, PR_JOINABLE_THREAD, 0); TEST_ASSERT(NULL != client[index].thread); PR_Lock(client[index].ml); while (cs_init == client[index].state) PR_WaitCondVar(client[index].stateChange, PR_INTERVAL_NO_TIMEOUT); PR_Unlock(client[index].ml); } } /* Then just let them go at it for a bit */ TEST_LOG( cltsrv_log_file, TEST_LOG_ALWAYS, ("main(0x%p): waiting for execution interval (%d seconds)\n", PR_GetCurrentThread(), execution)); WaitForCompletion(execution); TimeOfDayMessage("Shutting down", PR_GetCurrentThread()); if (clients != 0) { for (index = 0; index < clients; ++index) { TEST_LOG(cltsrv_log_file, TEST_LOG_STATUS, ("main(0x%p): notifying client(0x%p) to stop\n", PR_GetCurrentThread(), client[index].thread)); PR_Lock(client[index].ml); if (cs_run == client[index].state) { client[index].state = cs_stop; PR_Interrupt(client[index].thread); while (cs_stop == client[index].state) PR_WaitCondVar( client[index].stateChange, PR_INTERVAL_NO_TIMEOUT); } PR_Unlock(client[index].ml); TEST_LOG(cltsrv_log_file, TEST_LOG_VERBOSE, ("main(0x%p): joining client(0x%p)\n", PR_GetCurrentThread(), client[index].thread)); joinStatus = PR_JoinThread(client[index].thread); TEST_ASSERT(PR_SUCCESS == joinStatus); PR_DestroyCondVar(client[index].stateChange); PR_DestroyLock(client[index].ml); } PR_DELETE(client); } if (NULL != server) { /* All clients joined - retrieve the server */ TEST_LOG( cltsrv_log_file, TEST_LOG_NOTICE, ("main(0x%p): notifying server(0x%p) to stop\n", PR_GetCurrentThread(), server->thread)); PR_Lock(server->ml); server->state = cs_stop; PR_Interrupt(server->thread); while (cs_exit != server->state) PR_WaitCondVar(server->stateChange, PR_INTERVAL_NO_TIMEOUT); PR_Unlock(server->ml); TEST_LOG( cltsrv_log_file, TEST_LOG_NOTICE, ("main(0x%p): joining server(0x%p)\n", PR_GetCurrentThread(), server->thread)); joinStatus = PR_JoinThread(server->thread); TEST_ASSERT(PR_SUCCESS == joinStatus); PR_DestroyCondVar(server->stateChange); PR_DestroyCondVar(server->pool.exiting); PR_DestroyCondVar(server->pool.acceptComplete); PR_DestroyLock(server->ml); PR_DELETE(server); } TEST_LOG( cltsrv_log_file, TEST_LOG_ALWAYS, ("main(0x%p): test complete\n", PR_GetCurrentThread())); PT_FPrintStats(debug_out, "\nPThread Statistics\n"); TimeOfDayMessage("Test exiting at", PR_GetCurrentThread()); PR_Cleanup(); return 0; } /* main */
int main(int argc, char ** argv) { SECStatus rv; PRFileDesc *in; PRFileDesc *out; PRPollDesc pd; PRIntervalTime timeout = PR_INTERVAL_NO_TIMEOUT; char buf[1024]; PRInt32 nBytes; char * command; char * tokenName; char * tokenpw; int fipsmode = 0; int semid = 0; union semun semarg; if (argc < 4 || argc > 5) { fprintf(stderr, "Usage: nss_pcache <semid> <fips on/off> <directory> [prefix]\n"); exit(1); } signal(SIGHUP, SIG_IGN); semid = strtol(argv[1], NULL, 10); if (!strcasecmp(argv[2], "on")) fipsmode = 1; /* Initialize NSPR */ PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 256); /* Set the PKCS #11 strings for the internal token. */ PK11_ConfigurePKCS11(NULL,NULL,NULL, INTERNAL_TOKEN_NAME, NULL, NULL,NULL,NULL,8,1); /* Initialize NSS and open the certificate database read-only. */ rv = NSS_Initialize(argv[3], argc == 5 ? argv[4] : NULL, argc == 5 ? argv[4] : NULL, "secmod.db", NSS_INIT_READONLY); if (rv != SECSuccess) { fprintf(stderr, "Unable to initialize NSS database: %d\n", rv); exit(1); } if (fipsmode) { if (!PK11_IsFIPS()) { char * internal_name = PR_smprintf("%s", SECMOD_GetInternalModule()->commonName); if ((SECMOD_DeleteInternalModule(internal_name) != SECSuccess) || !PK11_IsFIPS()) { NSS_Shutdown(); fprintf(stderr, "Unable to enable FIPS mode"); exit(1); } PR_smprintf_free(internal_name); } } in = PR_GetSpecialFD(PR_StandardInput); out = PR_GetSpecialFD(PR_StandardOutput); if (in == NULL || out == NULL) { fprintf(stderr, "PR_GetInheritedFD failed\n"); exit(1); } pd.fd = in; pd.in_flags = PR_POLL_READ | PR_POLL_EXCEPT; while (1) { rv = PR_Poll(&pd, 1, timeout); if (rv == -1) { /* PR_Poll failed */ break; } if (pd.out_flags & (PR_POLL_HUP | PR_POLL_ERR | PR_POLL_NVAL | PR_POLL_EXCEPT)) { break; } if (pd.out_flags & PR_POLL_READ) { memset(buf, 0, sizeof(buf)); nBytes = PR_Read(in, buf, sizeof(buf)); if (nBytes == -1 || nBytes == 0) { break; } command = getstr(buf, 0); tokenName = getstr(buf, 1); tokenpw = getstr(buf, 2); if (command && !strcmp(command, "QUIT")) { break; } else if (command && !strcmp(command, "STOR")) { PRInt32 err = PIN_SUCCESS; Node *node = NULL; if (tokenName && tokenpw) { node = (Node*)malloc(sizeof (Node)); if (!node) { err = PIN_NOMEMORY; } node->tokenName = strdup(tokenName); node->store = 0; node->next = 0; if (err == PIN_SUCCESS) err = CreatePk11PinStore(&node->store, tokenName, tokenpw); memset(tokenpw, 0, strlen(tokenpw)); } else err = PIN_SYSTEMERROR; sprintf(buf, "%d", err); PR_Write(out, buf, 1); if (err == PIN_SUCCESS) { if (pinList) node->next = pinList; pinList = node; } /* Now clean things up */ if (command) free(command); if (tokenName) free(tokenName); if (tokenpw) free(tokenpw); } else if (command && !strcmp(command, "RETR")) { Node *node; char *pin = 0; PRBool found = PR_FALSE; for (node = pinList; node != NULL; node = node->next) { if (!strcmp(node->tokenName, tokenName)) { if (Pk11StoreGetPin(&pin, node->store) == SECSuccess) { if (strlen(pin) == 0) PR_Write(out, "", 1); else PR_Write(out, pin, strlen(pin)); memset(pin, 0, strlen(pin)); free(pin); found = PR_TRUE; break; } } } if (found != PR_TRUE) PR_Write(out, "", 1); free(command); free(tokenName); } else { ; /* ack, unknown command */ } } } freeList(pinList); PR_Close(in); /* Remove the semaphore used for locking here. This is because this * program only goes away when Apache shuts down so we don't have to * worry about reloads. */ semctl(semid, 0, IPC_RMID, semarg); return 0; }
PRIntn main(PRIntn argc, char **argv) { PRStatus rv; PLOptStatus os; PRHostEnt host; PRProtoEnt proto; PRBool ipv6 = PR_FALSE; const char *name = NULL; PRBool failed = PR_FALSE; PLOptState *opt = PL_CreateOptState(argc, argv, "h6"); err = PR_GetSpecialFD(PR_StandardError); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: /* Name of host to lookup */ name = opt->value; break; case '6': /* Turn on IPv6 mode */ ipv6 = PR_TRUE; break; case 'h': /* user wants some guidance */ default: Help(); /* so give him an earful */ return 2; /* but not a lot else */ } } PL_DestroyOptState(opt); if (ipv6) { rv = PR_SetIPv6Enable(ipv6); if (PR_FAILURE == rv) { failed = PR_TRUE; PL_FPrintError(err, "PR_SetIPv6Enable"); } } { if (NULL == name) { char *me = (char*)PR_MALLOC(DNS_BUFFER); rv = PR_GetSystemInfo(PR_SI_HOSTNAME, me, DNS_BUFFER); if (PR_FAILURE == rv) { failed = PR_TRUE; PL_FPrintError(err, "PR_GetHostName"); return 2; } name = me; /* just leak the storage */ } } { char buffer[HOST_BUFFER]; PR_fprintf(err, "Translating the name %s ...", name); rv = PR_GetHostByName(name, buffer, sizeof(buffer), &host); if (PR_FAILURE == rv) { failed = PR_TRUE; PL_FPrintError(err, "PR_GetHostByName"); } else { PRIntn index = 0; PRNetAddr address; PR_fprintf(err, "success .. enumerating results\n"); do { index = PR_EnumerateHostEnt(index, &host, 0, &address); if (index > 0) PrintAddress(&address); else if (-1 == index) { failed = PR_TRUE; PL_FPrintError(err, "PR_EnumerateHostEnt"); } } while (index > 0); } } { char buffer[PROTO_BUFFER]; /* ** Get Proto by name/number */ rv = PR_GetProtoByName("tcp", &buffer[1], sizeof(buffer) - 1, &proto); rv = PR_GetProtoByNumber(6, &buffer[3], sizeof(buffer) - 3, &proto); } return (failed) ? 1 : 0; }
int main(int argc, char **argv) { PRIntn rv = 1; PLOptStatus os; PRIntn verbosity = 0; PRLibrary *runtime = NULL; const char *library_name = NULL; const PRVersionDescription *version_info; char buffer[100]; PRExplodedTime exploded; PLOptState *opt = PL_CreateOptState(argc, argv, "d"); PRFileDesc *err = PR_GetSpecialFD(PR_StandardError); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: /* fully qualified library name */ library_name = opt->value; break; case 'd': /* verbodity */ verbosity += 1; break; default: PR_fprintf(err, "Usage: version [-d] {fully qualified library name}\n"); return 2; /* but not a lot else */ } } PL_DestroyOptState(opt); if (NULL != library_name) { runtime = PR_LoadLibrary(library_name); if (NULL == runtime) { PL_FPrintError(err, "PR_LoadLibrary"); return 3; } else { versionEntryPointType versionPoint = (versionEntryPointType) PR_FindSymbol(runtime, "libVersionPoint"); if (NULL == versionPoint) { PL_FPrintError(err, "PR_FindSymbol"); return 4; } version_info = versionPoint(); } } else version_info = libVersionPoint(); /* NSPR's version info */ (void)PR_fprintf(err, "Runtime library version information\n"); PR_ExplodeTime( version_info->buildTime, PR_GMTParameters, &exploded); (void)PR_FormatTime( buffer, sizeof(buffer), "%d %b %Y %H:%M:%S", &exploded); (void)PR_fprintf(err, " Build time: %s GMT\n", buffer); (void)PR_fprintf( err, " Build time: %s\n", version_info->buildTimeString); (void)PR_fprintf( err, " %s V%u.%u.%u (%s%s%s)\n", version_info->description, version_info->vMajor, version_info->vMinor, version_info->vPatch, (version_info->beta ? " beta " : ""), (version_info->debug ? " debug " : ""), (version_info->special ? " special" : "")); (void)PR_fprintf(err, " filename: %s\n", version_info->filename); (void)PR_fprintf(err, " security: %s\n", version_info->security); (void)PR_fprintf(err, " copyright: %s\n", version_info->copyright); (void)PR_fprintf(err, " comment: %s\n", version_info->comment); rv = 0; return rv; }
int main(int argc, char **argv) { PRStatus rv; PLOptStatus os; PRUint8 *buffer; PRFileDesc *file = NULL; const char *filename = "sync.dat"; PRUint32 index, loops, iterations = 10, filesize = 10; PRIntn flags = PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE; PLOptState *opt = PL_CreateOptState(argc, argv, "hSK:c:"); PRIntervalTime time, total = 0, shortest = 0x7fffffff, longest = 0; err = PR_GetSpecialFD(PR_StandardError); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: /* Name of file to create */ filename = opt->value; break; case 'S': /* Use sych option on file */ flags |= PR_SYNC; break; case 'K': /* Size of file to write */ filesize = atoi(opt->value); break; case 'c': /* Number of iterations */ iterations = atoi(opt->value); break; case 'h': /* user wants some guidance */ default: /* user needs some guidance */ Help(); /* so give him an earful */ return 2; /* but not a lot else */ } } PL_DestroyOptState(opt); file = PR_Open(filename, flags, 0666); if (NULL == file) { PL_FPrintError(err, "Failed to open file"); return 1; } buffer = (PRUint8*)PR_CALLOC(1024); if (NULL == buffer) { PL_FPrintError(err, "Cannot allocate buffer"); return 1; } for (index = 0; index < sizeof(buffer); ++index) buffer[index] = (PRUint8)index; for (loops = 0; loops < iterations; ++loops) { time = PR_IntervalNow(); for (index = 0; index < filesize; ++index) { PR_Write(file, buffer, 1024); } time = (PR_IntervalNow() - time); total += time; if (time < shortest) shortest = time; else if (time > longest) longest = time; if (0 != PR_Seek(file, 0, PR_SEEK_SET)) { PL_FPrintError(err, "Rewinding file"); return 1; } } total = total / iterations; PR_fprintf( err, "%u iterations over a %u kbyte %sfile: %u [%u] %u\n", iterations, filesize, ((flags & PR_SYNC) ? "SYNCH'd " : ""), PR_IntervalToMicroseconds(shortest), PR_IntervalToMicroseconds(total), PR_IntervalToMicroseconds(longest)); PR_DELETE(buffer); rv = PR_Close(file); if (PR_SUCCESS != rv) { PL_FPrintError(err, "Closing file failed"); return 1; } rv = PR_Delete(filename); if (PR_SUCCESS != rv) { PL_FPrintError(err, "Deleting file failed"); return 1; } return 0; }
/*********************************************************************** ** PRIVATE FUNCTION: main ** DESCRIPTION: ** Hammer on the file I/O system ** INPUTS: The usual argc and argv ** argv[0] - program name (not used) ** argv[1] - the number of virtual_procs to execute the major loop ** argv[2] - the number of threads to toss into the batch ** argv[3] - the clipping number applied to randoms ** default values: max_virtual_procs = 2, threads = 10, limit = 57 ** OUTPUTS: None ** RETURN: None ** SIDE EFFECTS: ** Creates, accesses and deletes lots of files ** RESTRICTIONS: ** (Currently) must have file create permission in "/usr/tmp". ** MEMORY: NA ** ALGORITHM: ** 1) Fork a "Thread()" ** 2) Wait for 'interleave' seconds ** 3) For [0..'threads') repeat [1..2] ** 4) Mark all objects to stop ** 5) Collect the threads, accumulating the results ** 6) For [0..'max_virtual_procs') repeat [1..5] ** 7) Print accumulated results and exit ** ** Characteristic output (from IRIX) ** Random File: Using max_virtual_procs = 2, threads = 10, limit = 57 ** Random File: [min [avg] max] writes/sec average ***********************************************************************/ PRIntn main (PRIntn argc, char *argv[]) { RCLock ml; PLOptStatus os; RCCondition cv(&ml); PRUint32 writesMax = 0, durationTot = 0; RCThread::Scope thread_scope = RCThread::local; PRUint32 writes, writesMin = 0x7fffffff, writesTot = 0; PRIntn active, poll, limit = 0, max_virtual_procs = 0, threads = 0, virtual_procs; RCInterval interleave(RCInterval::FromMilliseconds(10000)), duration(0); const char *where[] = {"okay", "open", "close", "delete", "write", "seek"}; PLOptState *opt = PL_CreateOptState(argc, argv, "Gdl:t:i:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: baseName = opt->value; break; case 'G': /* global threads */ thread_scope = RCThread::global; break; case 'd': /* debug mode */ debug_mode = 1; break; case 'l': /* limiting number */ limit = atoi(opt->value); break; case 't': /* number of threads */ threads = atoi(opt->value); break; case 'i': /* iteration counter */ max_virtual_procs = atoi(opt->value); break; default: break; } } PL_DestroyOptState(opt); output = PR_GetSpecialFD(PR_StandardOutput); /* main test */ cv.SetTimeout(interleave); if (max_virtual_procs == 0) max_virtual_procs = 2; if (limit == 0) limit = 57; if (threads == 0) threads = 10; if (debug_mode) PR_fprintf(output, "%s: Using %d virtual processors, %d threads, limit = %d and %s threads\n", programName, max_virtual_procs, threads, limit, (thread_scope == RCThread::local) ? "LOCAL" : "GLOBAL"); for (virtual_procs = 0; virtual_procs < max_virtual_procs; ++virtual_procs) { if (debug_mode) PR_fprintf(output, "%s: Setting number of virtual processors to %d\n", programName, virtual_procs + 1); RCPrimordialThread::SetVirtualProcessors(virtual_procs + 1); for (active = 0; active < threads; active++) { hammer[active] = new Hammer(thread_scope, &ml, &cv, limit); hammer[active]->Start(); /* then make it roll */ RCThread::Sleep(interleave); /* start them slowly */ } /* * The last thread started has had the opportunity to run for * 'interleave' seconds. Now gather them all back in. */ { RCEnter scope(&ml); for (poll = 0; poll < threads; poll++) { if (hammer[poll]->action == HammerData::sg_go) /* don't overwrite done */ hammer[poll]->action = HammerData::sg_stop; /* ask him to stop */ } } while (active > 0) { for (poll = 0; poll < threads; poll++) { ml.Acquire(); while (hammer[poll]->action < HammerData::sg_done) cv.Wait(); ml.Release(); if (hammer[poll]->problem == HammerData::sg_okay) { duration = RCInterval(RCInterval::now) - hammer[poll]->timein; writes = hammer[poll]->writes * 1000 / duration; if (writes < writesMin) writesMin = writes; if (writes > writesMax) writesMax = writes; writesTot += hammer[poll]->writes; durationTot += duration; } else { if (debug_mode) PR_fprintf(output, "%s: test failed %s after %ld seconds\n", programName, where[hammer[poll]->problem], duration); else failed_already=1; } active -= 1; /* this is another one down */ (void)hammer[poll]->Join(); hammer[poll] = NULL; } } if (debug_mode) PR_fprintf(output, "%s: [%ld [%ld] %ld] writes/sec average\n", programName, writesMin, writesTot * 1000 / durationTot, writesMax); } failed_already |= (PR_FAILURE == RCPrimordialThread::Cleanup()); PR_fprintf(output, "%s\n", (failed_already) ? "FAIL\n" : "PASS\n"); return failed_already; } /* main */
int main(int argc, char **argv) { PLOptStatus os; const char *server_name = NULL; PLOptState *opt = PL_CreateOptState(argc, argv, "hGX6C:b:s:B:"); err = PR_GetSpecialFD(PR_StandardError); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: /* Name of server */ server_name = opt->value; break; case 'G': /* Globular threads */ thread_scope = PR_GLOBAL_THREAD; break; case 'X': /* Use XTP as the transport */ protocol = 36; break; case '6': /* Use IPv6 */ domain = PR_AF_INET6; break; case 's': /* initial_streams */ initial_streams = atoi(opt->value); break; case 'C': /* concurrency */ concurrency = atoi(opt->value); break; case 'b': /* buffer size */ buffer_size = 1024 * atoi(opt->value); break; case 'B': /* buffer size */ xport_buffer = 1024 * atoi(opt->value); break; case 'h': /* user wants some guidance */ default: Help(); /* so give him an earful */ return 2; /* but not a lot else */ } } PL_DestroyOptState(opt); shared = PR_NEWZAP(Shared); shared->ml = PR_NewLock(); PR_fprintf(err, "This machine is %s\n", (NULL == server_name) ? "the SERVER" : "a CLIENT"); PR_fprintf(err, "Transport being used is %s\n", (6 == protocol) ? "TCP" : "XTP"); if (PR_GLOBAL_THREAD == thread_scope) { if (1 != concurrency) { PR_fprintf(err, " **Concurrency > 1 and GLOBAL threads!?!?\n"); PR_fprintf(err, " **Ignoring concurrency\n"); concurrency = 1; } } if (1 != concurrency) { PR_SetConcurrency(concurrency); PR_fprintf(err, "Concurrency set to %u\n", concurrency); } PR_fprintf(err, "All threads will be %s\n", (PR_GLOBAL_THREAD == thread_scope) ? "GLOBAL" : "LOCAL"); PR_fprintf(err, "Client buffer size will be %u\n", buffer_size); if (-1 != xport_buffer) PR_fprintf( err, "Transport send & receive buffer size will be %u\n", xport_buffer); if (NULL == server_name) Server(); else Client(server_name); return 0; } /* main */
PR_IMPLEMENT(void) PL_PrintError(const char *msg) { static PRFileDesc *fd = NULL; if (NULL == fd) fd = PR_GetSpecialFD(PR_StandardError); PL_FPrintError(fd, msg); } /* PL_PrintError */
NS_IMETHOD Write(const char* aBuf, uint32_t aCount, uint32_t *aWriteCount) { PR_Write(PR_GetSpecialFD(PR_StandardOutput), aBuf, aCount); *aWriteCount = aCount; return NS_OK; }
int main(int argc, char **argv) { PLOptStatus os; PRBool cleanup = PR_FALSE; PRThreadScope type = PR_LOCAL_THREAD; PRFileDesc *err = PR_GetSpecialFD(PR_StandardError); PLOptState *opt = PL_CreateOptState(argc, argv, "Ghs:S:t:cC:"); PRIntn concurrency = 1, child_sleep = 10, main_sleep = 5, threads = 1; PR_STDIO_INIT(); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'c': /* call PR_Cleanup() before exiting */ cleanup = PR_TRUE; break; case 'G': /* local vs global threads */ type = PR_GLOBAL_THREAD; break; case 's': /* time to sleep */ child_sleep = atoi(opt->value); break; case 'S': /* time to sleep */ main_sleep = atoi(opt->value); break; case 'C': /* number of cpus to create */ concurrency = atoi(opt->value); break; case 't': /* number of threads to create */ threads = atoi(opt->value); break; case 'h': /* user wants some guidance */ Help(); /* so give him an earful */ return 2; /* but not a lot else */ break; default: break; } } PL_DestroyOptState(opt); PR_fprintf(err, "Cleanup settings\n"); PR_fprintf(err, "\tThread type: %s\n", (PR_LOCAL_THREAD == type) ? "LOCAL" : "GLOBAL"); PR_fprintf(err, "\tConcurrency: %d\n", concurrency); PR_fprintf(err, "\tNumber of threads: %d\n", threads); PR_fprintf(err, "\tThread sleep: %d\n", child_sleep); PR_fprintf(err, "\tMain sleep: %d\n", main_sleep); PR_fprintf(err, "\tCleanup will %sbe called\n\n", (cleanup) ? "" : "NOT "); PR_SetConcurrency(concurrency); while (threads-- > 0) (void)PR_CreateThread( PR_USER_THREAD, Thread, (void*)child_sleep, PR_PRIORITY_NORMAL, type, PR_UNJOINABLE_THREAD, 0); PR_Sleep(PR_SecondsToInterval(main_sleep)); if (cleanup) PR_Cleanup(); PR_fprintf(err, "main() exiting\n"); return 0; } /* main */
int main(int argc, char **argv) #endif { const char *hostName = DEFAULT_HOST_NAME; PRHostEnt he, reversehe; char buf[PR_NETDB_BUF_SIZE]; char reversebuf[PR_NETDB_BUF_SIZE]; PRIntn idx; PRNetAddr addr; PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "h"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: /* naked */ hostName = opt->value; break; case 'h': /* Help message */ default: Help(); return 2; } } PL_DestroyOptState(opt); PR_STDIO_INIT(); outFile = PR_GetSpecialFD(PR_StandardError); if (PR_GetHostByName(hostName, buf, sizeof(buf), &he) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetHostByName failed\n"); exit(1); } PrintHostent(&he); idx = 0; while (1) { idx = PR_EnumerateHostEnt(idx, &he, 0, &addr); if (idx == -1) { PR_fprintf(outFile, "PR_EnumerateHostEnt failed\n"); exit(1); } if (idx == 0) break; /* normal loop termination */ PR_fprintf(outFile, "reverse lookup\n"); if (PR_GetHostByAddr(&addr, reversebuf, sizeof(reversebuf), &reversehe) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetHostByAddr failed\n"); exit(1); } PrintHostent(&reversehe); } PR_fprintf(outFile, "PR_GetIPNodeByName with PR_AF_INET\n"); if (PR_GetIPNodeByName(hostName, PR_AF_INET, PR_AI_DEFAULT, buf, sizeof(buf), &he) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetIPNodeByName failed\n"); exit(1); } PrintHostent(&he); PR_fprintf(outFile, "PR_GetIPNodeByName with PR_AF_INET6\n"); if (PR_GetIPNodeByName(hostName, PR_AF_INET6, PR_AI_DEFAULT, buf, sizeof(buf), &he) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetIPNodeByName failed\n"); exit(1); } PrintHostent(&he); idx = 0; PR_fprintf(outFile, "PR_GetHostByAddr with PR_AF_INET6\n"); while (1) { idx = PR_EnumerateHostEnt(idx, &he, 0, &addr); if (idx == -1) { PR_fprintf(outFile, "PR_EnumerateHostEnt failed\n"); exit(1); } if (idx == 0) break; /* normal loop termination */ PR_fprintf(outFile, "reverse lookup\n"); if (PR_GetHostByAddr(&addr, reversebuf, sizeof(reversebuf), &reversehe) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetHostByAddr failed\n"); exit(1); } PrintHostent(&reversehe); } PR_fprintf(outFile, "PR_GetHostByAddr with PR_AF_INET6 done\n"); PR_StringToNetAddr("::1", &addr); if (PR_IsNetAddrType(&addr, PR_IpAddrV4Mapped) == PR_TRUE) { PR_fprintf(outFile, "addr should not be ipv4 mapped address\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } PR_StringToNetAddr("127.0.0.1", &addr); if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } PR_StringToNetAddr("::FFFF:127.0.0.1", &addr); if (PR_IsNetAddrType(&addr, PR_IpAddrV4Mapped) == PR_FALSE) { PR_fprintf(outFile, "addr should be ipv4 mapped address\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } if (PR_InitializeNetAddr(PR_IpAddrAny, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_InitializeNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } if (PR_InitializeNetAddr(PR_IpAddrLoopback, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_InitializeNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } if (PR_SetNetAddr(PR_IpAddrAny, PR_AF_INET, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } if (PR_SetNetAddr(PR_IpAddrLoopback, PR_AF_INET, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } addr.inet.family = PR_AF_INET; addr.inet.port = 0; addr.inet.ip = PR_htonl(PR_INADDR_ANY); if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv4 INADDRANY: %s\n", buf); } addr.inet.family = PR_AF_INET; addr.inet.port = 0; addr.inet.ip = PR_htonl(PR_INADDR_LOOPBACK); if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv4 LOOPBACK: %s\n", buf); } if (PR_SetNetAddr(PR_IpAddrAny, PR_AF_INET6, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv6 INADDRANY: %s\n", buf); } if (PR_SetNetAddr(PR_IpAddrLoopback, PR_AF_INET6, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv6 LOOPBACK: %s\n", buf); } { PRIPv6Addr v6addr; char tmp_buf[256]; PR_SetNetAddr(PR_IpAddrLoopback, PR_AF_INET, 0, &addr); PR_ConvertIPv4AddrToIPv6(addr.inet.ip, &v6addr); PR_SetNetAddr(PR_IpAddrAny, PR_AF_INET6, 0, &addr); addr.ipv6.ip = v6addr; PR_NetAddrToString(&addr, tmp_buf, 256); PR_fprintf(outFile, "IPv4-mapped IPv6 LOOPBACK: %s\n", tmp_buf); } PR_fprintf(outFile, "PASS\n"); return 0; }