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