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);
}
}
NSAPI_PUBLIC char *util_hostname(void)
{
char str[MAXHOSTNAMELEN];
PRHostEnt hent;
char buf[PR_NETDB_BUF_SIZE];
PRStatus err;
gethostname(str, MAXHOSTNAMELEN);
err = PR_GetHostByName(
str,
buf,
PR_NETDB_BUF_SIZE,
&hent);
if (err == PR_FAILURE)
return NULL;
return net_find_fqdn(&hent);
}
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);
}
char*
getHostByName (const char* host)
{
char* buf = new char[PR_NETDB_BUF_SIZE];
PRHostEnt hp;
if (PR_GetHostByName(host, buf, PR_NETDB_BUF_SIZE, &hp) == PR_FAILURE) {
return NULL;
}
char* ip = new char[INET6_ADDRSTRLEN];
int offset = 0;
offset += sprintf(&ip[offset], "%u.", (unsigned char) hp.h_addr_list[0][0]);
offset += sprintf(&ip[offset], "%u.", (unsigned char) hp.h_addr_list[0][1]);
offset += sprintf(&ip[offset], "%u.", (unsigned char) hp.h_addr_list[0][2]);
offset += sprintf(&ip[offset], "%u", (unsigned char) hp.h_addr_list[0][3]);
delete [] buf;
return ip;
}
PRStatus RCHostLookup::ByName(const char* name)
{
PRStatus rv;
PRNetAddr addr;
PRHostEnt hostentry;
PRIntn index = 0, max;
RCNetAddr* vector = NULL;
RCNetAddr* old_vector = NULL;
void* buffer = PR_Malloc(PR_NETDB_BUF_SIZE);
if (NULL == buffer) return PR_FAILURE;
rv = PR_GetHostByName(name, (char*)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::ByName */
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));
}
/* 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;
}
nsresult nsProfileLock::LockWithSymlink(const nsACString& lockFilePath, PRBool aHaveFcntlLock)
{
nsresult rv;
struct in_addr inaddr;
inaddr.s_addr = htonl(INADDR_LOOPBACK);
char hostname[256];
PRStatus status = PR_GetSystemInfo(PR_SI_HOSTNAME, hostname, sizeof hostname);
if (status == PR_SUCCESS)
{
char netdbbuf[PR_NETDB_BUF_SIZE];
PRHostEnt hostent;
status = PR_GetHostByName(hostname, netdbbuf, sizeof netdbbuf, &hostent);
if (status == PR_SUCCESS)
memcpy(&inaddr, hostent.h_addr, sizeof inaddr);
}
char *signature =
PR_smprintf("%s:%s%lu", inet_ntoa(inaddr), aHaveFcntlLock ? "+" : "",
(unsigned long)getpid());
const nsPromiseFlatCString& flat = PromiseFlatCString(lockFilePath);
const char *fileName = flat.get();
int symlink_rv, symlink_errno = 0, tries = 0;
// use ns4.x-compatible symlinks if the FS supports them
while ((symlink_rv = symlink(signature, fileName)) < 0)
{
symlink_errno = errno;
if (symlink_errno != EEXIST)
break;
if (!IsSymlinkStaleLock(&inaddr, fileName, aHaveFcntlLock))
break;
// Lock seems to be bogus: try to claim it. Give up after a large
// number of attempts (100 comes from the 4.x codebase).
(void) unlink(fileName);
if (++tries > 100)
break;
}
PR_smprintf_free(signature);
signature = nsnull;
if (symlink_rv == 0)
{
// We exclusively created the symlink: record its name for eventual
// unlock-via-unlink.
rv = NS_OK;
mHaveLock = PR_TRUE;
mPidLockFileName = strdup(fileName);
if (mPidLockFileName)
{
PR_APPEND_LINK(this, &mPidLockList);
if (!setupPidLockCleanup++)
{
// Clean up on normal termination.
atexit(RemovePidLockFilesExiting);
// Clean up on abnormal termination, using POSIX sigaction.
// Don't arm a handler if the signal is being ignored, e.g.,
// because mozilla is run via nohup.
if (!sDisableSignalHandling) {
struct sigaction act, oldact;
#ifdef SA_SIGINFO
act.sa_sigaction = FatalSignalHandler;
act.sa_flags = SA_SIGINFO;
#else
act.sa_handler = FatalSignalHandler;
#endif
sigfillset(&act.sa_mask);
#define CATCH_SIGNAL(signame) \
PR_BEGIN_MACRO \
if (sigaction(signame, NULL, &oldact) == 0 && \
oldact.sa_handler != SIG_IGN) \
{ \
sigaction(signame, &act, &signame##_oldact); \
} \
PR_END_MACRO
CATCH_SIGNAL(SIGHUP);
CATCH_SIGNAL(SIGINT);
CATCH_SIGNAL(SIGQUIT);
CATCH_SIGNAL(SIGILL);
CATCH_SIGNAL(SIGABRT);
CATCH_SIGNAL(SIGSEGV);
CATCH_SIGNAL(SIGTERM);
#undef CATCH_SIGNAL
}
}
}
}
else if (symlink_errno == EEXIST)
rv = NS_ERROR_FILE_ACCESS_DENIED;
else
{
#ifdef DEBUG
printf("symlink() failed. errno = %d\n", errno);
#endif
rv = NS_ERROR_FAILURE;
}
return rv;
}
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 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;
}
char *dns_ip2host(char *ip, int verify)
{
/* struct in_addr iaddr; */
PRNetAddr iaddr;
char *hn;
static unsigned long laddr = 0;
static char myhostname[256];
PRHostEnt hent;
char buf[PR_NETDB_BUF_SIZE];
PRStatus err;
err = PR_InitializeNetAddr(PR_IpAddrNull, 0, &iaddr);
/* richm: ipv6 cleanup - use inet_aton or other more appropriate function
instead of inet_addr */
if((iaddr.inet.ip = inet_addr(ip)) == (in_addr_t)-1)
goto bong;
/*
* See if it happens to be the localhost IP address, and try
* the local host name if so.
*/
if (laddr == 0) {
laddr = inet_addr("127.0.0.1");
myhostname[0] = 0;
PR_GetSystemInfo(PR_SI_HOSTNAME, myhostname, sizeof(myhostname));
}
/* Have to match the localhost IP address and have a hostname */
if ((iaddr.inet.ip == laddr) && (myhostname[0] != 0)) {
/*
* Now try for a fully-qualified domain name, starting with
* the local hostname.
*/
err = PR_GetHostByName(myhostname,
buf,
PR_NETDB_BUF_SIZE,
&hent);
/* Don't verify if we get a fully-qualified name this way */
verify = 0;
}
else {
err = PR_GetHostByAddr(&iaddr,
buf,
PR_NETDB_BUF_SIZE,
&hent);
}
if ((err == PR_FAILURE) || !(hn = net_find_fqdn(&hent))) goto bong;
if(verify) {
char **haddr = 0;
err = PR_GetHostByName(hn,
buf,
PR_NETDB_BUF_SIZE,
&hent);
if(err == PR_SUCCESS) {
for(haddr = hent.h_addr_list; *haddr; haddr++) {
if(((struct in_addr *)(*haddr))->s_addr == iaddr.inet.ip)
break;
}
}
if((err == PR_FAILURE) || (!(*haddr)))
goto bong;
}
return hn;
bong:
return NULL;
}
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)
{
PRHostEnt hostentry;
char buf[PR_NETDB_BUF_SIZE];
PRNetAddr addr;
PRFileDesc *socket = NULL, *file = NULL;
PRIntn cmdSize;
char host[HOST_SIZE];
char port[PORT_SIZE];
char path[PATH_SIZE];
char line[LINE_SIZE];
int exitStatus = 0;
PRBool endOfHeader = PR_FALSE;
char *url;
char *fileName = NULL;
PRUint32 fileSize;
if (argc != 2 && argc != 4) {
PrintUsage();
exit(1);
}
if (argc == 2) {
/*
* case 1: httpget url
*/
url = argv[1];
} else {
if (strcmp(argv[1], "-o") == 0) {
/*
* case 2: httpget -o outputfile url
*/
fileName = argv[2];
url = argv[3];
} else {
/*
* case 3: httpget url -o outputfile
*/
url = argv[1];
if (strcmp(argv[2], "-o") != 0) {
PrintUsage();
exit(1);
}
fileName = argv[3];
}
}
if (ParseURL(url, host, sizeof(host), port, sizeof(port),
path, sizeof(path)) == PR_FAILURE) {
exit(1);
}
if (PR_GetHostByName(host, buf, sizeof(buf), &hostentry)
== PR_FAILURE) {
fprintf(stderr, "httpget: unknown host name: %s\n", host);
exit(1);
}
addr.inet.family = PR_AF_INET;
addr.inet.port = PR_htons((short) atoi(port));
addr.inet.ip = *((PRUint32 *) hostentry.h_addr_list[0]);
socket = PR_NewTCPSocket();
if (socket == NULL) {
fprintf(stderr, "httpget: cannot create new tcp socket\n");
exit(1);
}
if (PR_Connect(socket, &addr, PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE) {
fprintf(stderr, "httpget: cannot connect to http server\n");
exitStatus = 1;
goto done;
}
if (fileName == NULL) {
file = PR_STDOUT;
} else {
file = PR_Open(fileName, PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE,
00777);
if (file == NULL) {
fprintf(stderr, "httpget: cannot open file %s: (%d, %d)\n",
fileName, PR_GetError(), PR_GetOSError());
exitStatus = 1;
goto done;
}
}
cmdSize = PR_snprintf(buf, sizeof(buf), "GET %s HTTP/1.0\r\n\r\n", path);
PR_ASSERT(cmdSize == (PRIntn) strlen("GET HTTP/1.0\r\n\r\n")
+ (PRIntn) strlen(path));
if (PR_Write(socket, buf, cmdSize) != cmdSize) {
fprintf(stderr, "httpget: cannot write to http server\n");
exitStatus = 1;
goto done;
}
if (ReadLine(socket, line, sizeof(line)) <= 0) {
fprintf(stderr, "httpget: cannot read line from http server\n");
exitStatus = 1;
goto done;
}
/* HTTP response: 200 == OK */
if (strstr(line, "200") == NULL) {
fprintf(stderr, "httpget: %s\n", line);
exitStatus = 1;
goto done;
}
while (ReadLine(socket, line, sizeof(line)) > 0) {
if (line[0] == '\n') {
endOfHeader = PR_TRUE;
break;
}
if (strncmp(line, "Content-Length", 14) == 0
|| strncmp(line, "Content-length", 14) == 0) {
char *p = line + 14;
while (*p == ' ' || *p == '\t') {
p++;
}
if (*p != ':') {
continue;
}
p++;
while (*p == ' ' || *p == '\t') {
p++;
}
fileSize = 0;
while ('0' <= *p && *p <= '9') {
fileSize = 10 * fileSize + (*p - '0');
p++;
}
}
}
if (endOfHeader == PR_FALSE) {
fprintf(stderr, "httpget: cannot read line from http server\n");
exitStatus = 1;
goto done;
}
if (fileName == NULL || fileSize == 0) {
FetchFile(socket, file);
} else {
FastFetchFile(socket, file, fileSize);
}
done:
if (socket) PR_Close(socket);
if (file) PR_Close(file);
PR_Cleanup();
return exitStatus;
}
/* 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 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);
}
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;
}
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;
}
nsresult nsProfileLock::LockWithSymlink(nsIFile *aLockFile, bool aHaveFcntlLock)
{
nsresult rv;
nsAutoCString lockFilePath;
rv = aLockFile->GetNativePath(lockFilePath);
if (NS_FAILED(rv)) {
NS_ERROR("Could not get native path");
return rv;
}
// don't replace an existing lock time if fcntl already got one
if (!mReplacedLockTime)
aLockFile->GetLastModifiedTimeOfLink(&mReplacedLockTime);
struct in_addr inaddr;
inaddr.s_addr = htonl(INADDR_LOOPBACK);
char hostname[256];
PRStatus status = PR_GetSystemInfo(PR_SI_HOSTNAME, hostname, sizeof hostname);
if (status == PR_SUCCESS)
{
char netdbbuf[PR_NETDB_BUF_SIZE];
PRHostEnt hostent;
status = PR_GetHostByName(hostname, netdbbuf, sizeof netdbbuf, &hostent);
if (status == PR_SUCCESS)
memcpy(&inaddr, hostent.h_addr, sizeof inaddr);
}
char *signature =
PR_smprintf("%s:%s%lu", inet_ntoa(inaddr), aHaveFcntlLock ? "+" : "",
(unsigned long)getpid());
const char *fileName = lockFilePath.get();
int symlink_rv, symlink_errno = 0, tries = 0;
// use ns4.x-compatible symlinks if the FS supports them
while ((symlink_rv = symlink(signature, fileName)) < 0)
{
symlink_errno = errno;
if (symlink_errno != EEXIST)
break;
if (!IsSymlinkStaleLock(&inaddr, fileName, aHaveFcntlLock))
break;
// Lock seems to be bogus: try to claim it. Give up after a large
// number of attempts (100 comes from the 4.x codebase).
(void) unlink(fileName);
if (++tries > 100)
break;
}
PR_smprintf_free(signature);
signature = nullptr;
if (symlink_rv == 0)
{
// We exclusively created the symlink: record its name for eventual
// unlock-via-unlink.
rv = NS_OK;
mHaveLock = true;
mPidLockFileName = strdup(fileName);
if (mPidLockFileName)
{
PR_APPEND_LINK(this, &mPidLockList);
if (!setupPidLockCleanup++)
{
// Clean up on normal termination.
// This instanciates a dummy class, and will trigger the class
// destructor when libxul is unloaded. This is equivalent to atexit(),
// but gracefully handles dlclose().
static RemovePidLockFilesExiting r;
// Clean up on abnormal termination, using POSIX sigaction.
// Don't arm a handler if the signal is being ignored, e.g.,
// because mozilla is run via nohup.
if (!sDisableSignalHandling) {
struct sigaction act, oldact;
#ifdef SA_SIGINFO
act.sa_sigaction = FatalSignalHandler;
act.sa_flags = SA_SIGINFO;
#else
act.sa_handler = FatalSignalHandler;
#endif
sigfillset(&act.sa_mask);
#define CATCH_SIGNAL(signame) \
PR_BEGIN_MACRO \
if (sigaction(signame, nullptr, &oldact) == 0 && \
oldact.sa_handler != SIG_IGN) \
{ \
sigaction(signame, &act, &signame##_oldact); \
} \
PR_END_MACRO
CATCH_SIGNAL(SIGHUP);
CATCH_SIGNAL(SIGINT);
CATCH_SIGNAL(SIGQUIT);
CATCH_SIGNAL(SIGILL);
CATCH_SIGNAL(SIGABRT);
CATCH_SIGNAL(SIGSEGV);
CATCH_SIGNAL(SIGTERM);
#undef CATCH_SIGNAL
}
}
}
}
else if (symlink_errno == EEXIST)
rv = NS_ERROR_FILE_ACCESS_DENIED;
else
{
#ifdef DEBUG
printf("symlink() failed. errno = %d\n", errno);
#endif
rv = NS_ERROR_FAILURE;
}
return rv;
}
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;
}