static void Client(const char *server_name) { PRStatus rv; PRHostEnt host; char buffer[PR_NETDB_BUF_SIZE]; PRIntervalTime dally = PR_SecondsToInterval(60); PR_fprintf(err, "Translating the name %s\n", server_name); rv = PR_GetHostByName(server_name, buffer, sizeof(buffer), &host); if (PR_FAILURE == rv) PL_FPrintError(err, "PR_GetHostByName"); else { if (PR_EnumerateHostEnt( 0, &host, PORT_NUMBER, &shared->server_address) < 0) PL_FPrintError(err, "PR_EnumerateHostEnt"); else { do { shared->threads += 1; (void)PR_CreateThread( PR_USER_THREAD, Clientel, shared, PR_PRIORITY_NORMAL, thread_scope, PR_UNJOINABLE_THREAD, 8 * 1024); if (shared->threads == initial_streams) { PR_Sleep(dally); initial_streams += 1; } } while (PR_TRUE); } } }
static void client_main(unsigned short port) { SECStatus secStatus; PRStatus prStatus; PRInt32 rv; PRNetAddr addr; PRHostEnt hostEntry; PRErrorCode errorNumber; char buffer[PR_NETDB_BUF_SIZE]; int attempt; int errCode = GENERAL_ERROR; /* Setup network connection. */ prStatus = PR_GetHostByName(hostName, buffer, sizeof (buffer), &hostEntry); if (prStatus != PR_SUCCESS) exitErr("Unable to resolve server host name", GENERAL_ERROR); rv = PR_EnumerateHostEnt(0, &hostEntry, port, &addr); if (rv < 0) exitErr("Unable to resolve server host address", GENERAL_ERROR); /* Some errors (see below) represent a situation in which trying again should succeed. However, don't try forever. */ for (attempt = 0; attempt < 5; ++attempt) { secStatus = do_connect (&addr); if (secStatus == SECSuccess) return; errorNumber = PR_GetError (); switch (errorNumber) { case PR_CONNECT_RESET_ERROR: /* Server was not ready. */ sleep (1); break; /* Try again */ case SEC_ERROR_EXPIRED_CERTIFICATE: /* The server's certificate has expired. It should generate a new certificate. Give the server a chance to recover and try again. */ sleep (2); break; /* Try again */ case SEC_ERROR_CA_CERT_INVALID: /* The server's certificate is not trusted. The exit code must reflect this. */ errCode = CA_CERT_INVALID_ERROR; goto failed; /* break switch and loop */ default: /* This error is fatal. */ goto failed; /* break switch and loop */ } } failed: /* Unrecoverable error */ exitErr("Unable to connect to server", errCode); }
/** * Throws NSPRException upon NSPR error */ Connection::Connection(const ServerInfo& server, const std::string &certDBPasswd, const std::string &certNickName, bool alwaysTrustServerCert) : socket(NULL), certdbpasswd(NULL), certnickname(NULL) { char buffer[PR_NETDB_BUF_SIZE]; PRNetAddr address; PRHostEnt hostEntry; PRIntn hostIndex; PRStatus prStatus; SECStatus secStatus; prStatus = PR_GetHostByName(server.getHost().c_str(), buffer, sizeof(buffer), &hostEntry); if (PR_SUCCESS != prStatus) { throw NSPRException("Connection::Connection", "PR_GetHostByName"); } hostIndex = PR_EnumerateHostEnt(0, &hostEntry, server.getPort(), &address); if (hostIndex < 0) { throw NSPRException("Connection::Connection", "PR_EnumerateHostEnt"); } socket = createSocket(address, server.useSSL(), certDBPasswd, certNickName, alwaysTrustServerCert); if (server.useSSL()) { secStatus = SSL_SetURL(socket, server.getHost().c_str()); if (SECSuccess != secStatus) { PRErrorCode error = PR_GetError(); PR_Shutdown(socket, PR_SHUTDOWN_BOTH); PR_Close(socket); Log::log(Log::ALL_MODULES, Log::LOG_ERROR, "SSL_SetURL() returned error: %s", PR_ErrorToString(error, PR_LANGUAGE_I_DEFAULT)); throw NSPRException("Connection::Connection", "SSL_SetURL", error); } } prStatus = PR_Connect(socket, &address, connect_timeout); if (prStatus != PR_SUCCESS) { PRErrorCode error = PR_GetError(); PR_Shutdown(socket, PR_SHUTDOWN_BOTH); PR_Close(socket); throw NSPRException("Connection::Connection PR_Connect", "PR_Connect", error); } }
PRStatus RCHostLookup::ByAddress(const RCNetAddr& host_addr) { PRStatus rv; PRNetAddr addr; PRHostEnt hostentry; PRIntn index = 0, max; RCNetAddr* vector = NULL; RCNetAddr* old_vector = NULL; char *buffer = (char*)PR_Malloc(PR_NETDB_BUF_SIZE); if (NULL == buffer) return PR_FAILURE; rv = PR_GetHostByAddr(host_addr, buffer, PR_NETDB_BUF_SIZE, &hostentry); if (PR_SUCCESS == rv) { for (max = 0, index = 0;; ++max) { index = PR_EnumerateHostEnt(index, &hostentry, 0, &addr); if (0 == index) break; } if (max > 0) { vector = new RCNetAddr[max]; while (--max > 0) { index = PR_EnumerateHostEnt(index, &hostentry, 0, &addr); if (0 == index) break; vector[index] = &addr; } { RCEnter entry(&ml); old_vector = address; address = vector; max_index = max; } if (NULL != old_vector) delete [] old_vector; } } if (NULL != buffer) PR_DELETE(buffer); return PR_SUCCESS; } /* RCHostLookup::ByAddress */
void client_main(unsigned short port, int connections, const char * hostName) { int i; SECStatus secStatus; PRStatus prStatus; PRInt32 rv; PRNetAddr addr; PRHostEnt hostEntry; char buffer[PR_NETDB_BUF_SIZE]; /* Setup network connection. */ prStatus = PR_GetHostByName(hostName, buffer, sizeof(buffer), &hostEntry); if (prStatus != PR_SUCCESS) { exitErr("PR_GetHostByName"); } rv = PR_EnumerateHostEnt(0, &hostEntry, port, &addr); if (rv < 0) { exitErr("PR_EnumerateHostEnt"); } secStatus = launch_thread(&threadMGR, do_connects, &addr, 1); if (secStatus != SECSuccess) { exitErr("launch_thread"); } if (connections > 1) { /* wait for the first connection to terminate, then launch the rest. */ reap_threads(&threadMGR); /* Start up the connections */ for (i = 2; i <= connections; ++i) { secStatus = launch_thread(&threadMGR, do_connects, &addr, i); if (secStatus != SECSuccess) { errWarn("launch_thread"); } } } reap_threads(&threadMGR); destroy_thread_data(&threadMGR); }
void SslSocket::connect(const std::string& host, uint16_t port) const { std::stringstream namestream; namestream << host << ":" << port; connectname = namestream.str(); void* arg = SslOptions::global.certName.empty() ? 0 : const_cast<char*>(SslOptions::global.certName.c_str()); NSS_CHECK(SSL_GetClientAuthDataHook(socket, NSS_GetClientAuthData, arg)); NSS_CHECK(SSL_SetURL(socket, host.data())); char hostBuffer[PR_NETDB_BUF_SIZE]; PRHostEnt hostEntry; PR_CHECK(PR_GetHostByName(host.data(), hostBuffer, PR_NETDB_BUF_SIZE, &hostEntry)); PRNetAddr address; int value = PR_EnumerateHostEnt(0, &hostEntry, port, &address); if (value < 0) { throw Exception(QPID_MSG("Error getting address for host: " << ErrorString())); } else if (value == 0) { throw Exception(QPID_MSG("Could not resolve address for host.")); } PR_CHECK(PR_Connect(socket, &address, PR_INTERVAL_NO_TIMEOUT)); }
PRStatus getNetAddr(const char *host, PRNetAddr *addr) { PRStatus rv = PR_SUCCESS; memset(addr, 0, sizeof(*addr)); // Extract the port number int port = 0; char *h = PL_strdup(host); char * p = host_port_suffix(h); // uds name if(!p) { #ifndef XP_WIN32 addr->local.family = PR_AF_LOCAL; strcpy(addr->local.path, h); #else addr = NULL; return PR_SUCCESS; #endif // XP_WIN32 } else { if (p) { *p = '\0'; p++; // validate the port number if(*p == '\0') { // port is empty PL_strcpy(errorMsg, "port is missing in the bind-path"); return PR_FAILURE; } // check if port has only digits PRBool invalidPort = PR_FALSE; char *startP = p; while(p && *p) { if(!isdigit(*p)) { invalidPort = PR_TRUE; break; } p++; } if(invalidPort) { PR_snprintf(errorMsg, 256, "invalid port %s specified in the bind-path", startP); return PR_FAILURE; } port = atoi(startP); if(port < 1 || port > 65535) { PR_snprintf(errorMsg, 256, "port %s specified in the bind-path is out of range", startP); return PR_FAILURE; } } // try to resolve the hostname PRHostEnt he; char buffer[PR_NETDB_BUF_SIZE]; if(h && *h != '\0') { // Format a PRNetAddr rv = PR_GetHostByName(h, buffer, sizeof(buffer), &he); } else { // no host specified, consider it as localhost rv = PR_GetHostByName("localhost", buffer, sizeof(buffer), &he); } if (rv == PR_SUCCESS) { if (PR_EnumerateHostEnt(0, &he, port, addr) < 0) { rv = PR_FAILURE; PR_snprintf(errorMsg, 256, "invalid host %s specified in the bind-path", h); printf("invalid host is specified in the bind-path\n"); } } } PL_strfree(h); return rv; }
/* one copy of this function is launched in a separate thread for each ** connection to be made. */ SECStatus do_connects(void *a, int connection) { PRNetAddr *addr = (PRNetAddr *)a; PRFileDesc *sslSocket; PRHostEnt hostEntry; char buffer[PR_NETDB_BUF_SIZE]; PRStatus prStatus; PRIntn hostenum; PRInt32 ip; SECStatus secStatus; /* Set up SSL secure socket. */ sslSocket = setupSSLSocket(addr); if (sslSocket == NULL) { errWarn("setupSSLSocket"); return SECFailure; } secStatus = SSL_SetPKCS11PinArg(sslSocket, &pwdata); if (secStatus != SECSuccess) { errWarn("SSL_SetPKCS11PinArg"); return secStatus; } secStatus = SSL_SetURL(sslSocket, hostName); if (secStatus != SECSuccess) { errWarn("SSL_SetURL"); return secStatus; } /* Prepare and setup network connection. */ prStatus = PR_GetHostByName(hostName, buffer, sizeof(buffer), &hostEntry); if (prStatus != PR_SUCCESS) { errWarn("PR_GetHostByName"); return SECFailure; } hostenum = PR_EnumerateHostEnt(0, &hostEntry, port, addr); if (hostenum == -1) { errWarn("PR_EnumerateHostEnt"); return SECFailure; } ip = PR_ntohl(addr->inet.ip); fprintf(stderr, "Connecting to host %s (addr %d.%d.%d.%d) on port %d\n", hostName, BYTE(3,ip), BYTE(2,ip), BYTE(1,ip), BYTE(0,ip), PR_ntohs(addr->inet.port)); prStatus = PR_Connect(sslSocket, addr, PR_INTERVAL_NO_TIMEOUT); if (prStatus != PR_SUCCESS) { errWarn("PR_Connect"); return SECFailure; } /* Established SSL connection, ready to send data. */ #if 0 secStatus = SSL_ForceHandshake(sslSocket); if (secStatus != SECSuccess) { errWarn("SSL_ForceHandshake"); return secStatus; } #endif secStatus = SSL_ResetHandshake(sslSocket, /* asServer */ PR_FALSE); if (secStatus != SECSuccess) { errWarn("SSL_ResetHandshake"); prStatus = PR_Close(sslSocket); if (prStatus != PR_SUCCESS) { errWarn("PR_Close"); } return secStatus; } secStatus = handle_connection(sslSocket, connection); if (secStatus != SECSuccess) { /* error already printed out in handle_connection */ /* errWarn("handle_connection"); */ prStatus = PR_Close(sslSocket); if (prStatus != PR_SUCCESS) { errWarn("PR_Close"); } return secStatus; } PR_Close(sslSocket); return SECSuccess; }
int main(int argc, char **argv) { PRHostEnt he; PRStatus status; PRIntn next_index; PRUint16 port_number; char netdb_buf[PR_NETDB_BUF_SIZE]; PRNetAddr client_addr, server_addr; PRThread *client_thread, *server_thread; PRIntervalTime delta = PR_MillisecondsToInterval(500); err_out = PR_STDERR; std_out = PR_STDOUT; accept_timeout = PR_SecondsToInterval(2); emu_layer_ident = PR_GetUniqueIdentity("Emulated AcceptRead"); emu_layer_methods = *PR_GetDefaultIOMethods(); emu_layer_methods.acceptread = emu_AcceptRead; if (argc != 2 && argc != 3) port_number = DEFAULT_PORT; else port_number = (PRUint16)atoi(argv[(argc == 2) ? 1 : 2]); status = PR_InitializeNetAddr(PR_IpAddrAny, port_number, &server_addr); if (PR_SUCCESS != status) { PL_FPrintError(err_out, "PR_InitializeNetAddr failed"); PR_ProcessExit(1); } if (argc < 3) { status = PR_InitializeNetAddr( PR_IpAddrLoopback, port_number, &client_addr); if (PR_SUCCESS != status) { PL_FPrintError(err_out, "PR_InitializeNetAddr failed"); PR_ProcessExit(1); } } else { status = PR_GetHostByName( argv[1], netdb_buf, sizeof(netdb_buf), &he); if (status == PR_FAILURE) { PL_FPrintError(err_out, "PR_GetHostByName failed"); PR_ProcessExit(1); } next_index = PR_EnumerateHostEnt(0, &he, port_number, &client_addr); if (next_index == -1) { PL_FPrintError(err_out, "PR_EnumerateHostEnt failed"); PR_ProcessExit(1); } } for ( write_dally = 0; write_dally < accept_timeout + (2 * delta); write_dally += delta) { PR_fprintf( std_out, "Testing w/ write_dally = %d msec\n", PR_IntervalToMilliseconds(write_dally)); server_thread = PR_CreateThread( PR_USER_THREAD, AcceptingThread, &server_addr, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0); if (server_thread == NULL) { PL_FPrintError(err_out, "PR_CreateThread (server) failed"); PR_ProcessExit(1); } PR_Sleep(delta); /* let the server pot thicken */ client_thread = PR_CreateThread( PR_USER_THREAD, ConnectingThread, &client_addr, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0); if (client_thread == NULL) { PL_FPrintError(err_out, "PR_CreateThread (client) failed"); PR_ProcessExit(1); } if (PR_JoinThread(client_thread) == PR_FAILURE) PL_FPrintError(err_out, "PR_JoinThread (client) failed"); if (PR_JoinThread(server_thread) == PR_FAILURE) PL_FPrintError(err_out, "PR_JoinThread (server) failed"); } return 0; }
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 */
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) { PRHostEnt he; char buf[1024]; PRNetAddr addr; PRFileDesc *sock; PRPollDesc pd; PRStatus rv; PRSocketOptionData optData; PRIntn n; #ifdef XP_MAC int index; PRIntervalTime timeout; SetupMacPrintfLog("nbconn.log"); for (index=0; index<4; index++) { argv[1] = hosts[index]; timeout = PR_INTERVAL_NO_TIMEOUT; if (index == 3) timeout = PR_SecondsToInterval(10UL); #endif PR_STDIO_INIT(); #ifndef XP_MAC if (argc != 2) { fprintf(stderr, "Usage: nbconn <hostname>\n"); exit(1); } #endif if (PR_GetHostByName(argv[1], buf, sizeof(buf), &he) == PR_FAILURE) { printf( "Unknown host: %s\n", buf); exit(1); } else { printf( "host: %s\n", buf); } PR_EnumerateHostEnt(0, &he, 80, &addr); sock = PR_NewTCPSocket(); optData.option = PR_SockOpt_Nonblocking; optData.value.non_blocking = PR_TRUE; PR_SetSocketOption(sock, &optData); rv = PR_Connect(sock, &addr, PR_INTERVAL_NO_TIMEOUT); if (rv == PR_FAILURE && PR_GetError() == PR_IN_PROGRESS_ERROR) { printf( "Connect in progress\n"); } pd.fd = sock; pd.in_flags = PR_POLL_WRITE | PR_POLL_EXCEPT; #ifndef XP_MAC n = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT); #else n = PR_Poll(&pd, 1, timeout); #endif if (n == -1) { printf( "PR_Poll failed\n"); exit(1); } printf( "PR_Poll returns %d\n", n); if (pd.out_flags & PR_POLL_READ) { printf( "PR_POLL_READ\n"); } if (pd.out_flags & PR_POLL_WRITE) { printf( "PR_POLL_WRITE\n"); } if (pd.out_flags & PR_POLL_EXCEPT) { printf( "PR_POLL_EXCEPT\n"); } if (pd.out_flags & PR_POLL_ERR) { printf( "PR_POLL_ERR\n"); } if (pd.out_flags & PR_POLL_NVAL) { printf( "PR_POLL_NVAL\n"); } if (PR_GetConnectStatus(&pd) == PR_SUCCESS) { printf("PR_GetConnectStatus: connect succeeded\n"); /* Mac and Win16 have trouble printing to the console. */ #if !defined(XP_MAC) && !defined(WIN16) PR_Write(sock, "GET /\r\n\r\n", 9); PR_Shutdown(sock, PR_SHUTDOWN_SEND); pd.in_flags = PR_POLL_READ; while (1) { n = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT); printf( "poll returns %d\n", n); n = PR_Read(sock, buf, sizeof(buf)); printf( "read returns %d\n", n); if (n <= 0) { break; } PR_Write(PR_STDOUT, buf, n); } #endif } else { if (PR_GetError() == PR_IN_PROGRESS_ERROR) { printf( "PR_GetConnectStatus: connect still in progress\n"); exit(1); } printf( "PR_GetConnectStatus: connect failed: (%ld, %ld)\n", PR_GetError(), PR_GetOSError()); } PR_Close(sock); #ifdef XP_MAC } /* end of for loop */ #endif printf( "PASS\n"); return 0; }
/* make the connection. */ static SECStatus do_connect(PRNetAddr *addr) { PRFileDesc *sslSocket; PRStatus prStatus; #if 0 PRHostEnt hostEntry; char buffer[PR_NETDB_BUF_SIZE]; PRIntn hostenum; #endif SECStatus secStatus; secStatus = SECSuccess; /* Set up SSL secure socket. */ sslSocket = setupSSLSocket(); if (sslSocket == NULL) return SECFailure; #if 0 /* no client authentication */ secStatus = SSL_SetPKCS11PinArg(sslSocket, password); if (secStatus != SECSuccess) goto done; #endif secStatus = SSL_SetURL(sslSocket, hostName); if (secStatus != SECSuccess) goto done; #if 0 /* Already done */ /* Prepare and setup network connection. */ prStatus = PR_GetHostByName(hostName, buffer, sizeof(buffer), &hostEntry); if (prStatus != PR_SUCCESS) { secStatus = SECFailure; goto done; } hostenum = PR_EnumerateHostEnt(0, &hostEntry, port, addr); if (hostenum == -1) { secStatus = SECFailure; goto done; } #endif prStatus = PR_Connect(sslSocket, addr, PR_INTERVAL_NO_TIMEOUT); if (prStatus != PR_SUCCESS) { secStatus = SECFailure; goto done; } /* Established SSL connection, ready to send data. */ secStatus = SSL_ResetHandshake(sslSocket, /* asServer */ PR_FALSE); if (secStatus != SECSuccess) goto done; /* This is normally done automatically on the first I/O operation, but doing it here catches any authentication problems early. */ secStatus = SSL_ForceHandshake(sslSocket); if (secStatus != SECSuccess) goto done; secStatus = handle_connection(sslSocket); if (secStatus != SECSuccess) goto done; done: prStatus = PR_Close(sslSocket); return secStatus; }
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; }
int test_socket(int argc, char *argv[]) { int j = 0; PKIX_UInt32 actualMinorVersion; char buf[PR_NETDB_BUF_SIZE]; char *serverName = NULL; char *sepPtr = NULL; PRHostEnt hostent; PRUint16 portNum = 0; PRStatus prstatus = PR_FAILURE; PRErrorCode cStat = 0; void *ipaddr = NULL; PKIX_Error *bindError = NULL; PRIntn hostenum; PKIX_TEST_STD_VARS(); startTests("Socket"); PKIX_TEST_EXPECT_NO_ERROR( PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); if (argc != (j + 2)) { printUsage(argv[0]); pkixTestErrorMsg = "Missing command line argument."; goto cleanup; } serverName = argv[j + 1]; subTest("Using pkix_pl_Socket_CreateByName"); PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_CreateByName (PKIX_TRUE, timeout, serverName, &cStat, &sSock, plContext)); PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList (sSock, &sCallbackList, plContext)); PKIX_TEST_EXPECT_NO_ERROR(sCallbackList->listenCallback (sSock, backlog, plContext)); serverState = SERVER_LISTENING; PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_CreateByName (PKIX_FALSE, timeout, serverName, &cStat, &cSock, plContext)); PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList (cSock, &cCallbackList, plContext)); if ((timeout == 0) && (cStat == PR_IN_PROGRESS_ERROR)) { clientState = CLIENT_WAITFORCONNECT; } else { clientState = CLIENT_SEND1; } dispatcher(); subTest("Using pkix_pl_Socket_Create"); sepPtr = strchr(serverName, ':'); /* First strip off the portnum, if present, from the end of the name */ if (sepPtr) { *sepPtr++ = '\0'; portNum = (PRUint16)atoi(sepPtr); } else { portNum = (PRUint16)LDAP_PORT; } /* * The hostname may be a fully-qualified name. Just * use the leftmost component in our lookup. */ sepPtr = strchr(serverName, '.'); if (sepPtr) { *sepPtr++ = '\0'; } prstatus = PR_GetHostByName(serverName, buf, sizeof(buf), &hostent); if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { printUsage(argv[0]); pkixTestErrorMsg = "PR_GetHostByName rejects command line argument."; goto cleanup; } serverNetAddr.inet.family = PR_AF_INET; serverNetAddr.inet.port = PR_htons(portNum); serverNetAddr.inet.ip = PR_INADDR_ANY; hostenum = PR_EnumerateHostEnt(0, &hostent, portNum, &clientNetAddr); if (hostenum == -1) { pkixTestErrorMsg = "PR_EnumerateHostEnt failed."; goto cleanup; } backlog = 5; /* timeout = PR_INTERVAL_NO_TIMEOUT; */ /* timeout = 0; nonblocking */ timeout = 0; bindError = pkix_pl_Socket_Create (PKIX_TRUE, timeout, &serverNetAddr, &cStat, &sSock, plContext); /* If PR_Bind can't handle INADDR_ANY, try it with the real name */ if (bindError) { PKIX_TEST_DECREF_BC(bindError); serverNetAddr.inet.ip = PR_htonl(*(PRUint32 *)ipaddr); PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_Create (PKIX_TRUE, timeout, &serverNetAddr, &cStat, &sSock, plContext)); } PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList (sSock, &sCallbackList, plContext)); PKIX_TEST_EXPECT_NO_ERROR(sCallbackList->listenCallback (sSock, backlog, plContext)); serverState = SERVER_LISTENING; PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_Create (PKIX_FALSE, timeout, &clientNetAddr, &cStat, &cSock, plContext)); PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList (cSock, &cCallbackList, plContext)); if ((timeout == 0) && (cStat == PR_IN_PROGRESS_ERROR)) { clientState = CLIENT_WAITFORCONNECT; } else { clientState = CLIENT_SEND1; } dispatcher(); cleanup: PKIX_TEST_DECREF_AC(sSock); PKIX_TEST_DECREF_AC(cSock); PKIX_TEST_DECREF_AC(rendezvousSock); PKIX_TEST_RETURN(); endTests("Socket"); return (0); }