static enum okay
nss_init(void)
{
static int initialized;
char *cp;
verbose = value("verbose") != NULL;
if (initialized == 0) {
if ((cp = value("nss-config-dir")) == NULL) {
fputs("Missing \"nss-config-dir\" variable.\n", stderr);
return STOP;
}
cp = expand(cp);
PR_Init(0, 0, 0);
PK11_SetPasswordFunc(password_cb);
if (NSS_Init(cp) == SECSuccess) {
NSS_SetDomesticPolicy();
initialized = 1;
return OKAY;
}
nss_gen_err("Error initializing NSS");
return STOP;
}
return OKAY;
}
gboolean
crypto_init (GError **error)
{
SECStatus ret;
if (initialized)
return TRUE;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 1);
ret = NSS_NoDB_Init (NULL);
if (ret != SECSuccess) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERROR_FAILED,
_("Failed to initialize the crypto engine: %d."),
PR_GetError ());
PR_Cleanup ();
return FALSE;
}
SEC_PKCS12EnableCipher(PKCS12_RC4_40, 1);
SEC_PKCS12EnableCipher(PKCS12_RC4_128, 1);
SEC_PKCS12EnableCipher(PKCS12_RC2_CBC_40, 1);
SEC_PKCS12EnableCipher(PKCS12_RC2_CBC_128, 1);
SEC_PKCS12EnableCipher(PKCS12_DES_56, 1);
SEC_PKCS12EnableCipher(PKCS12_DES_EDE3_168, 1);
SEC_PKCS12SetPreferredCipher(PKCS12_DES_EDE3_168, 1);
initialized = TRUE;
return TRUE;
}
int main(int argc, char **argv)
{
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
if (argc > 1) {
count = atoi(argv[1]);
} else {
count = 5;
}
printf("\n\n%20s%30s\n\n"," ","Suspend_Resume Test");
CreateThreadsUU();
CreateThreadsUK();
CreateThreadsKU();
CreateThreadsKK();
PR_SetConcurrency(2);
printf("\n%20s%30s\n\n"," ","Added 2nd CPU\n");
CreateThreadsUK();
CreateThreadsKK();
CreateThreadsUU();
CreateThreadsKU();
PR_Cleanup();
return 0;
}
static void
init_qf (void)
{
Sys_Init ();
Cvar_Get ("developer", va ("%d", options.developer), 0, 0, 0);
Memory_Init (malloc (1024 * 1024), 1024 * 1024);
Cvar_Get ("pr_debug", "2", 0, 0, 0);
Cvar_Get ("pr_boundscheck", "2", 0, 0, 0);
pr.edicts = &edicts;
pr.num_edicts = &num_edicts;
pr.reserved_edicts = &reserved_edicts;
pr.load_file = load_file;
pr.allocate_progs_mem = allocate_progs_mem;
pr.free_progs_mem = free_progs_mem;
pr.no_exec_limit = 0; // absolutely want a limit!
pr.pr_trace = options.trace;
PR_Init_Cvars ();
PR_Init ();
RUA_Init (&pr, 0);
PR_Cmds_Init(&pr);
BI_Init (&pr);
}
int main(int argc, char **argv) {
int rv;
debug_mode = 1;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_SetThreadGCAble();
#ifdef XP_MAC
SetupMacPrintfLog("thrashgc.log");
debug_mode = 1;
#endif
PR_InitGC(0, 0, 0, PR_GLOBAL_THREAD);
PR_STDIO_INIT();
stderrLock = PR_NewLock();
tix1 = PR_RegisterType(&type1);
tix2 = PR_RegisterType(&type2);
tix3 = PR_RegisterType(&type3);
gcInfo = PR_GetGCInfo();
rv = padMain(argc, argv);
printf("PASS\n");
PR_Cleanup();
return rv;
}
int
main(int argc, char **argv)
{
PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 256);
threadmain("TestFile");
PRThread *thr1 = PR_CreateThread(PR_SYSTEM_THREAD,
threadmain,
(void *)"TestFile1",
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD,
STACKSIZE);
PRThread *thr2 = PR_CreateThread(PR_SYSTEM_THREAD,
threadmain,
(void *)"TestFile2",
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD,
STACKSIZE);
PRThread *thr3 = PR_CreateThread(PR_SYSTEM_THREAD,
threadmain,
(void *)"TestFile3",
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD,
STACKSIZE);
PR_JoinThread(thr1);
PR_JoinThread(thr2);
PR_JoinThread(thr3);
return 0;
}
static
int runCmd(mainTestFn fnPointer,
int argc,
char **argv,
char *dbPath)
{
int retStat = 0;
/* Initialize NSPR and NSS. */
PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
/* if using databases, use NSS_Init and not NSS_NoDB_Init */
if (dbPath && PORT_Strlen(dbPath) != 0) {
if (NSS_Init(dbPath) != SECSuccess)
return SECFailure;
} else {
if (NSS_NoDB_Init(NULL) != 0)
return SECFailure;
}
retStat = fnPointer(argc, argv);
if (NSS_Shutdown() != SECSuccess) {
exit(1);
}
PR_Cleanup();
return retStat;
}
int
main(int argc, char **argv)
{
char * progName = NULL;
SECStatus secStatus;
PLOptState *optstate;
PLOptStatus status;
/* Call the NSPR initialization routines */
PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
progName = PL_strdup(argv[0]);
hostName = NULL;
optstate = PL_CreateOptState(argc, argv, "d:h:i:o:p:t:");
while ((status = PL_GetNextOpt(optstate)) == PL_OPT_OK)
{
switch(optstate->option)
{
case 'd' : certDir = PL_strdup(optstate->value); break;
case 'h' : hostName = PL_strdup(optstate->value); break;
case 'i' : infileName = PL_strdup(optstate->value); break;
case 'o' : outfileName = PL_strdup(optstate->value); break;
case 'p' : port = PORT_Atoi(optstate->value); break;
case 't' : trustNewServer_p = PL_strdup(optstate->value); break;
case '?' :
default : Usage(progName);
}
}
if (port == 0 || hostName == NULL || infileName == NULL || outfileName == NULL || certDir == NULL)
Usage(progName);
#if 0 /* no client authentication */
/* Set our password function callback. */
PK11_SetPasswordFunc(myPasswd);
#endif
/* Initialize the NSS libraries. */
secStatus = NSS_InitReadWrite(certDir);
if (secStatus != SECSuccess)
{
/* Try it again, readonly. */
secStatus = NSS_Init(certDir);
if (secStatus != SECSuccess)
exitErr("Error initializing NSS", GENERAL_ERROR);
}
/* All cipher suites except RSA_NULL_MD5 are enabled by Domestic Policy. */
NSS_SetDomesticPolicy();
client_main(port);
NSS_Shutdown();
PR_Cleanup();
return 0;
}
static void
ssl_nss_init_nss(void)
{
#if NSS_VMAJOR > 3 || ( NSS_VMAJOR == 3 && NSS_VMINOR >= 14 )
SSLVersionRange supported, enabled;
#endif /* NSS >= 3.14 */
PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
NSS_NoDB_Init(".");
NSS_SetDomesticPolicy();
SSL_CipherPrefSetDefault(TLS_DHE_RSA_WITH_AES_256_CBC_SHA, 1);
SSL_CipherPrefSetDefault(TLS_DHE_DSS_WITH_AES_256_CBC_SHA, 1);
SSL_CipherPrefSetDefault(TLS_RSA_WITH_AES_256_CBC_SHA, 1);
SSL_CipherPrefSetDefault(TLS_DHE_DSS_WITH_RC4_128_SHA, 1);
SSL_CipherPrefSetDefault(TLS_DHE_RSA_WITH_AES_128_CBC_SHA, 1);
SSL_CipherPrefSetDefault(TLS_DHE_DSS_WITH_AES_128_CBC_SHA, 1);
SSL_CipherPrefSetDefault(SSL_RSA_WITH_RC4_128_SHA, 1);
SSL_CipherPrefSetDefault(TLS_RSA_WITH_AES_128_CBC_SHA, 1);
SSL_CipherPrefSetDefault(SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA, 1);
SSL_CipherPrefSetDefault(SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA, 1);
SSL_CipherPrefSetDefault(SSL_DHE_RSA_WITH_DES_CBC_SHA, 1);
SSL_CipherPrefSetDefault(SSL_DHE_DSS_WITH_DES_CBC_SHA, 1);
#if NSS_VMAJOR > 3 || ( NSS_VMAJOR == 3 && NSS_VMINOR >= 14 )
/* Get the ranges of supported and enabled SSL versions */
if ((SSL_VersionRangeGetSupported(ssl_variant_stream, &supported) == SECSuccess) &&
(SSL_VersionRangeGetDefault(ssl_variant_stream, &enabled) == SECSuccess)) {
purple_debug_info("nss", "TLS supported versions: "
"0x%04hx through 0x%04hx\n", supported.min, supported.max);
purple_debug_info("nss", "TLS versions allowed by default: "
"0x%04hx through 0x%04hx\n", enabled.min, enabled.max);
/* Make sure SSL 3.0 is disabled (it's old and everyone should be
using at least TLS 1.0 by now), and make sure all versions of TLS
supported by the local library are enabled (for some reason NSS
doesn't enable newer versions of TLS by default -- more context in
ticket #15909). */
if (enabled.min != SSL_LIBRARY_VERSION_TLS_1_0 || supported.max > enabled.max) {
enabled.max = supported.max;
if (SSL_VersionRangeSetDefault(ssl_variant_stream, &enabled) == SECSuccess) {
purple_debug_info("nss", "Changed allowed TLS versions to "
"0x%04hx through 0x%04hx\n", enabled.min, enabled.max);
} else {
purple_debug_error("nss", "Error setting allowed TLS versions to "
"0x%04hx through 0x%04hx\n", enabled.min, enabled.max);
}
}
}
#endif /* NSS >= 3.14 */
/** Disable OCSP Checking until we can make that use our HTTP & Proxy stuff */
CERT_EnableOCSPChecking(PR_FALSE);
_identity = PR_GetUniqueIdentity("Purple");
_nss_methods = PR_GetDefaultIOMethods();
}
/**
* Global SSL init
*
* @retval 0 error initializing SSL
* @retval 1 SSL initialized successfully
*/
int Curl_nss_init(void)
{
if(!initialized)
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 256);
/* We will actually initialize NSS later */
return 1;
}
int main(int argc, char **argv)
{
PRThread *r, *w;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
emptyBufs = PR_NewSem(2); /* two empty buffers */
fullBufs = PR_NewSem(0); /* zero full buffers */
/* Create initial temp file setup */
InitialSetup();
/* create the reader thread */
r = PR_CreateThread(PR_USER_THREAD,
reader, t1,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
0);
w = PR_CreateThread(PR_USER_THREAD,
writer, t2,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
0);
/* Do the joining for both threads */
(void) PR_JoinThread(r);
(void) PR_JoinThread(w);
/* Do the verification and clean up */
VerifyAndCleanup();
PR_DestroySem(emptyBufs);
PR_DestroySem(fullBufs);
PR_Cleanup();
if(failed_already)
{
printf("Fail\n");
return 1;
}
else
{
printf("PASS\n");
return 0;
}
}
int main(int argc, char **argv)
{
PRInt32 initial_threads = DEFAULT_INITIAL_THREADS;
PRInt32 max_threads = DEFAULT_MAX_THREADS;
PRInt32 stacksize = DEFAULT_STACKSIZE;
PRThreadPool *tp = NULL;
PRStatus rv;
PRJob *jobp;
/*
* -d debug mode
*/
PLOptStatus os;
PLOptState *opt;
program_name = argv[0];
opt = PL_CreateOptState(argc, argv, "d");
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;
default:
break;
}
}
PL_DestroyOptState(opt);
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
PR_SetConcurrency(4);
tp = PR_CreateThreadPool(initial_threads, max_threads, stacksize);
if (NULL == tp) {
printf("PR_CreateThreadPool failed\n");
failed_already=1;
goto done;
}
jobp = PR_QueueJob(tp, TCP_Server, tp, PR_TRUE);
rv = PR_JoinJob(jobp);
PR_ASSERT(PR_SUCCESS == rv);
DPRINTF(("%s: calling PR_JoinThreadPool\n", program_name));
rv = PR_JoinThreadPool(tp);
PR_ASSERT(PR_SUCCESS == rv);
DPRINTF(("%s: returning from PR_JoinThreadPool\n", program_name));
done:
PR_Cleanup();
if (failed_already) return 1;
else return 0;
}
/*
====================
Host_Init
====================
*/
void Host_Init (quakeparms_t *parms)
{
if (standard_quake)
minimum_memory = MINIMUM_MEMORY;
else
minimum_memory = MINIMUM_MEMORY_LEVELPAK;
if (COM_CheckParm ("-minmemory"))
parms->memsize = minimum_memory;
host_parms = *parms;
if (parms->memsize < minimum_memory)
Sys_Error ("Only %4.1f megs of memory available, can't execute game", parms->memsize / (float)0x100000);
com_argc = parms->argc;
com_argv = parms->argv;
// JPG 3.00 - moved this here
#ifdef _WIN32
srand(time(NULL) ^ _getpid());
#else
srand(time(NULL) ^ getpid());
#endif
Memory_Init (parms->membase, parms->memsize);
Cbuf_Init ();
Cmd_Init ();
Cvar_Init ();
COM_Init (parms->basedir);
Host_InitLocal ();
W_LoadWadFile ("gfx.wad");
Con_Init ();
PR_Init ();
Mod_Init ();
Security_Init (); // JPG 3.20 - cheat free
NET_Init ();
SV_Init ();
IPLog_Init (); // JPG 1.05 - ip address logging
BANLog_Init ();
Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
Con_Printf ("%4.1f megabyte heap\n",parms->memsize/ (1024*1024.0));
R_InitTextures (); // needed even for dedicated servers
Cbuf_InsertText ("exec autoexec.cfg;exec server.cfg;stuffcmds;startdemos\n");
Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark ();
host_initialized = true;
Sys_Printf ("========Quake Initialized========\n");
}
/*
====================
SV_Init
====================
*/
void SV_Init (void)
{
PR_Init ();
SV_InitLocal ();
if (dedicated)
NET_ServerConfig (true);
svs.last_heartbeat = -99999; // send immediately
}
void ssl_init(void)
{
PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
// https://www.mozilla.org/projects/security/pki/nss/ref/ssl/sslfnc.html#1234224
// This NSS function is not intended for use with SSL, which
// requires that the certificate and key database files be
// opened. Relates to whole non-verification of servers for now.
NSS_NoDB_Init(NULL);
NSS_SetDomesticPolicy();
initialized = TRUE;
}
/**
* Global SSL init
*
* @retval 0 error initializing SSL
* @retval 1 SSL initialized successfully
*/
int Curl_nss_init(void)
{
/* curl_global_init() is not thread-safe so this test is ok */
if (nss_initlock == NULL) {
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 256);
nss_initlock = PR_NewLock();
}
/* We will actually initialize NSS later */
return 1;
}
PRIntn main ()
{
PRUint32 elapsed;
PRThread *thread;
struct timeval timein, timeout;
PRInt32 onePercent = 3000000UL / 100UL;
fprintf (stderr, "First sleep will sleep 3 seconds.\n");
fprintf (stderr, " sleep 1 begin\n");
(void)GTOD(&timein);
sleep (3);
(void)GTOD(&timeout);
fprintf (stderr, " sleep 1 end\n");
elapsed = 1000000UL * (timeout.tv_sec - timein.tv_sec);
elapsed += (timeout.tv_usec - timein.tv_usec);
fprintf(stderr, "elapsed %u usecs\n", elapsed);
if (labs(elapsed - 3000000UL) > onePercent) rv = 1;
PR_Init (PR_USER_THREAD, PR_PRIORITY_NORMAL, 100);
PR_STDIO_INIT();
fprintf (stderr, "Second sleep should do the same (does it?).\n");
fprintf (stderr, " sleep 2 begin\n");
(void)GTOD(&timein);
sleep (3);
(void)GTOD(&timeout);
fprintf (stderr, " sleep 2 end\n");
elapsed = 1000000UL * (timeout.tv_sec - timein.tv_sec);
elapsed += (timeout.tv_usec - timein.tv_usec);
fprintf(stderr, "elapsed %u usecs\n", elapsed);
if (labs(elapsed - 3000000UL) > onePercent) rv = 1;
fprintf (stderr, "What happens to other threads?\n");
fprintf (stderr, "You should see dots every quarter second.\n");
fprintf (stderr, "If you don't, you're probably running on classic NSPR.\n");
thread = PR_CreateThread(
PR_USER_THREAD, Other, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
fprintf (stderr, " sleep 2 begin\n");
(void)GTOD(&timein);
sleep (3);
(void)GTOD(&timeout);
fprintf (stderr, " sleep 2 end\n");
PR_Interrupt(thread);
PR_JoinThread(thread);
elapsed = 1000000UL * (timeout.tv_sec - timein.tv_sec);
elapsed += (timeout.tv_usec - timein.tv_usec);
fprintf(stderr, "elapsed %u usecs\n", elapsed);
if (labs(elapsed - 3000000UL) > onePercent) rv = 1;
fprintf(stderr, "%s\n", (0 == rv) ? "PASSED" : "FAILED");
return rv;
}
static void
load_nss (GsdSmartcardManager *self)
{
GsdSmartcardManagerPrivate *priv = self->priv;
NSSInitContext *context = NULL;
/* The first field in the NSSInitParameters structure
* is the size of the structure. NSS requires this, so
* that it can change the size of the structure in future
* versions of NSS in a detectable way
*/
NSSInitParameters parameters = { sizeof (parameters), };
static const guint32 flags = NSS_INIT_READONLY
| NSS_INIT_FORCEOPEN
| NSS_INIT_NOROOTINIT
| NSS_INIT_OPTIMIZESPACE
| NSS_INIT_PK11RELOAD;
g_debug ("attempting to load NSS database '%s'",
GSD_SMARTCARD_MANAGER_NSS_DB);
PR_Init (PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
context = NSS_InitContext (GSD_SMARTCARD_MANAGER_NSS_DB,
"", "", SECMOD_DB, ¶meters, flags);
if (context == NULL) {
gsize error_message_size;
char *error_message;
error_message_size = PR_GetErrorTextLength ();
if (error_message_size == 0) {
g_debug ("NSS security system could not be initialized");
} else {
error_message = g_alloca (error_message_size);
PR_GetErrorText (error_message);
g_debug ("NSS security system could not be initialized - %s",
error_message);
}
priv->nss_context = NULL;
return;
}
g_debug ("NSS database '%s' loaded", GSD_SMARTCARD_MANAGER_NSS_DB);
priv->nss_context = context;
}
static PRIntn PR_CALLBACK RealMain( PRIntn argc, char **argv )
{
/* 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
*/
PLOptStatus os;
PLOptState *opt = PL_CreateOptState(argc, argv, "d:");
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;
default:
break;
}
}
PL_DestroyOptState(opt);
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
#ifdef XP_MAC
SetupMacPrintfLog("joinuk.log");
#endif
/* main test */
if (debug_mode) printf("User-Kernel test\n");
runTest(PR_LOCAL_THREAD, PR_GLOBAL_THREAD);
if(failed_already)
{
printf("FAIL\n");
return 1;
} else
{
printf("PASS\n");
return 0;
}
}
int
main
(
int argc,
char *argv[]
)
{
int rv = 0;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 14);
rv = rmain(argc, argv);
PR_Cleanup();
return rv;
}
int main(int argc, char **argv)
{
/* 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
*/
PLOptStatus os;
PLOptState *opt = PL_CreateOptState(argc, argv, "d:");
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;
default:
break;
}
}
PL_DestroyOptState(opt);
/* main test */
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
if (argc > 2) {
count = atoi(argv[2]);
} else {
count = DEFAULT_COUNT;
}
#if defined(XP_UNIX)
Measure(NativeSelectTest, "time to call 1 element select()");
#endif
Measure(EmptyPRSelect, "time to call Empty PR_select()");
Measure(EmptyNativeSelect, "time to call Empty select()");
Measure(PRSelectTest, "time to call 1 element PR_select()");
if (!debug_mode) Test_Result (NOSTATUS);
PR_Cleanup();
}
void main(int argc, char **argv)
{
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
if (argc > 1) {
count = atoi(argv[1]);
} else {
count = DEFAULT_COUNT;
}
Measure(statPRStat, "time to call PR_GetFileInfo()");
Measure(statStat, "time to call stat()");
PR_Cleanup();
}
int main(int argc, char **argv)
{
PRInt32 num_threads;
/* 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
*/
PLOptStatus os;
PLOptState *opt = PL_CreateOptState(argc, argv, "d:");
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;
default:
break;
}
}
PL_DestroyOptState(opt);
/* main test */
if (argc > 2)
num_threads = atoi(argv[2]);
else
num_threads = NUM_THREADS;
PR_Init(PR_USER_THREAD, PR_PRIORITY_LOW, 0);
PR_STDIO_INIT();
if (debug_mode) printf("kernel level test\n");
thread_test(PR_GLOBAL_THREAD, num_threads);
PR_Cleanup();
if(failed_already)
return 1;
else
return 0;
}
void * tls_init(const struct tls_config *conf) {
char *dir;
tls_nss_ref_count++;
if (tls_nss_ref_count > 1)
return (void *) 1;
PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
nss_layer_id = PR_GetUniqueIdentity("wpa_supplicant");
PK11_SetPasswordFunc(nss_password_cb);
dir = getenv("SSL_DIR");
if (dir) {
if (NSS_Init(dir) != SECSuccess) {
wpa_printf(MSG_ERROR, "NSS: NSS_Init(cert_dir=%s) "
"failed", dir);
return NULL;
}
} else {
if (NSS_NoDB_Init(NULL) != SECSuccess) {
wpa_printf(MSG_ERROR, "NSS: NSS_NoDB_Init(NULL) "
"failed");
return NULL;
}
}
if (SSL_OptionSetDefault(SSL_V2_COMPATIBLE_HELLO, PR_FALSE) !=
SECSuccess ||
SSL_OptionSetDefault(SSL_ENABLE_SSL3, PR_FALSE) != SECSuccess ||
SSL_OptionSetDefault(SSL_ENABLE_SSL2, PR_FALSE) != SECSuccess ||
SSL_OptionSetDefault(SSL_ENABLE_TLS, PR_TRUE) != SECSuccess) {
wpa_printf(MSG_ERROR, "NSS: SSL_OptionSetDefault failed");
return NULL;
}
if (NSS_SetDomesticPolicy() != SECSuccess) {
wpa_printf(MSG_ERROR, "NSS: NSS_SetDomesticPolicy() failed");
return NULL;
}
return (void *) 1;
}
int main(PRIntn argc, const char **argv)
{
PRThread *thread;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
#ifndef XP_MAC
if (argc > 1)
{
if (!PR_SetLogFile(argv[1]))
{
Error("Access: Cannot create log file");
goto exit;
}
}
#else
SetupMacPrintfLog("logger.log");
#endif
/* Start logging something here */
PR_LogPrint("%s logging into %s\n", argv[0], argv[1]);
PR_LogPrint("%s creating new thread\n", argv[0]);
/*
** Now change buffering.
*/
PR_SetLogBuffering( 65500 );
thread = PR_CreateThread(
PR_USER_THREAD, forked, (void*)argv[0], PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_LogPrint("%s joining thread\n", argv[0]);
UserLogStuff();
PR_JoinThread(thread);
PR_LogFlush();
return 0;
exit:
return -1;
}
int main(int argc, char **argv)
{
/* 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
*/
PLOptStatus os;
PLOptState *opt = PL_CreateOptState(argc, argv, "d:");
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;
default:
break;
}
}
PL_DestroyOptState(opt);
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
if (argc > 1) {
count = atoi(argv[1]);
} else {
count = DEFAULT_COUNT;
}
ftime_init();
Measure(timeTime, "time to get time with time()");
Measure(timeGethrtime, "time to get time with gethrtime()");
Measure(timeGettimeofday, "time to get time with gettimeofday()");
Measure(timePRTime32, "time to get time with PR_Time() (32bit)");
Measure(timePRTime64, "time to get time with PR_Time() (64bit)");
PR_Cleanup();
return 0;
}
void MozillaRenderer::initialize(void)
{
// Initialize NSPR and NSS
PR_Init (PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 10);
if (NSS_InitReadWrite(NULL) == SECFailure)
{
if (NSS_NoDB_Init(NULL) == SECFailure)
{
#ifdef DEBUG
cout << "MozillaRenderer::ctor: couldn't initialize NSS" << endl;
#endif
}
}
NSS_SetDomesticPolicy();
SSL_OptionSetDefault(SSL_ENABLE_SSL2, PR_TRUE);
SSL_OptionSetDefault(SSL_ENABLE_SSL3, PR_TRUE);
SSL_OptionSetDefault(SSL_ENABLE_TLS, PR_TRUE);
SSL_OptionSetDefault(SSL_V2_COMPATIBLE_HELLO, PR_TRUE);
}
int main()
{
int i= 0;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
printf("The parent sproc has pid %d.\n", getpid());
printf("The parent sproc won't stop on its own.\n");
fflush(stdout);
/* create the child sproc */
PR_CreateThread(PR_USER_THREAD, NeverStops, NULL,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD, 0);
while (1) {
i++;
}
return 0;
}
/*
====================
SV_Init
====================
*/
void SV_Init (void)
{
Sys_Printf ("Host_Init\n");
Memory_Init (host_parms->membase, host_parms->memsize);
Cbuf_Init ();
Cmd_Init ();
COM_Init ();
FS_Init ();
PR_Init ();
Mod_Init ();
SV_InitNet ();
SV_InitLocal ();
Pmove_Init ();
Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark ();
Cbuf_InsertText ("exec server.cfg\n");
Cbuf_Execute ();
// unlock the early-set cvars after init
Cvar_UnlockAll ();
host_initialized = true;
Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
Con_Printf ("%4.1f megabyte heap\n", host_parms->memsize/(1024*1024.0));
Con_Printf ("======== HexenWorld Initialized ========\n");
// process command line arguments
Cmd_StuffCmds_f ();
Cbuf_Execute ();
// if a map wasn't specified on the command line, spawn demo1.map
if (sv.state == ss_dead)
Cmd_ExecuteString ("map demo1", src_command);
if (sv.state == ss_dead)
SV_Error ("Couldn't spawn a server");
}
static void
load_nss (GsdSmartcardManager *self)
{
GsdSmartcardManagerPrivate *priv = self->priv;
SECStatus status = SECSuccess;
static const guint32 flags = NSS_INIT_READONLY
| NSS_INIT_FORCEOPEN
| NSS_INIT_NOROOTINIT
| NSS_INIT_OPTIMIZESPACE
| NSS_INIT_PK11RELOAD;
g_debug ("attempting to load NSS database '%s'",
GSD_SMARTCARD_MANAGER_NSS_DB);
PR_Init (PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
status = NSS_Initialize (GSD_SMARTCARD_MANAGER_NSS_DB,
"", "", SECMOD_DB, flags);
if (status != SECSuccess) {
gsize error_message_size;
char *error_message;
error_message_size = PR_GetErrorTextLength ();
if (error_message_size == 0) {
g_debug ("NSS security system could not be initialized");
} else {
error_message = g_alloca (error_message_size);
PR_GetErrorText (error_message);
g_debug ("NSS security system could not be initialized - %s",
error_message);
}
priv->nss_is_loaded = FALSE;
return;
}
g_debug ("NSS database '%s' loaded", GSD_SMARTCARD_MANAGER_NSS_DB);
priv->nss_is_loaded = TRUE;
}
