The Tor Browser: nsprpub/pr/tests/nbconn.c@925c144e1f1f (annotated)

nsprpub/pr/tests/nbconn.c@925c144e1f1f (annotated)

nsprpub/pr/tests/nbconn.c

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /*
  * A test for nonblocking connect.  Functions tested include PR_Connect,
  * PR_Poll, and PR_GetConnectStatus.
  *
  * The test should be invoked with a host name, for example:
  *     nbconn www.netscape.com
  * It will do a nonblocking connect to port 80 (HTTP) on that host,
  * and when connected, issue the "GET /" HTTP command.
  *
  * You should run this test in three ways:
  * 1. To a known web site, such as www.netscape.com.  The HTML of the
  *    top-level page at the web site should be printed.
  * 2. To a machine not running a web server at port 80.  This test should
  *    fail.  Ideally the error code should be PR_CONNECT_REFUSED_ERROR.
  *    But it is possible to return PR_UNKNOWN_ERROR on certain platforms.
  * 3. To an unreachable machine, for example, a machine that is off line.
  *    The test should fail after the connect times out.  Ideally the
  *    error code should be PR_IO_TIMEOUT_ERROR, but it is possible to
  *    return PR_UNKNOWN_ERROR on certain platforms.
  */
 #include "nspr.h"
 #include "plgetopt.h"
 #include <stdio.h>
 #include <string.h>
 #define SERVER_MAX_BIND_COUNT        100
 #define DATA_BUF_SIZE        		 256
 #define TCP_SERVER_PORT            10000
 #define TCP_UNUSED_PORT            211
 typedef struct Server_Param {
     PRFileDesc *sp_fd;		/* server port */
 } Server_Param;
 static void PR_CALLBACK TCP_Server(void *arg);
 int _debug_on;
 #define DPRINTF(arg) if (_debug_on) printf arg
 static PRIntn connection_success_test();
 static PRIntn connection_failure_test();
 int main(int argc, char **argv)
 {
     PRHostEnt he;
     char buf[1024];
     PRNetAddr addr;
     PRPollDesc pd;
     PRStatus rv;
     PRSocketOptionData optData;
 	const char *hostname = NULL;
     PRIntn default_case, n, bytes_read, bytes_sent;
 	PRInt32 failed_already = 0;
     /*
      * -d           debug mode
      */
     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 0:  /* debug mode */
             hostname = opt->value;
             break;
         case 'd':  /* debug mode */
             _debug_on = 1;
             break;
         default:
             break;
         }
     }
     PL_DestroyOptState(opt);
     PR_STDIO_INIT();
     if (hostname)
 		default_case = 0;
 	else
 		default_case = 1;
 	if (default_case) {
 		/*
 		 * In the default case the following tests are executed:
 		 *	1. successful connection: a server thread accepts a connection
 		 *	   from the main thread
 		 *	2. unsuccessful connection: the main thread tries to connect to a
 		 *	   nonexistent port and expects to get an error
 		 */
 		rv = connection_success_test();
 		if (rv == 0)
 			rv = connection_failure_test();
 		return rv;
 	} else {
     	PRFileDesc *sock;
 		if (PR_GetHostByName(argv[1], buf, sizeof(buf), &he) == PR_FAILURE) {
 			printf( "Unknown host: %s\n", argv[1]);
 			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;
 		n = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
 		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");
 			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);
 			}
 		} 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);
     	printf( "PASS\n");
     	return 0;
 	}
 }
 /*
  * TCP Server
  *    Server Thread
  *    Accept a connection from the client and write some data
  */
 static void PR_CALLBACK
 TCP_Server(void *arg)
 {
     Server_Param *sp = (Server_Param *) arg;
     PRFileDesc *sockfd, *newsockfd;
 	char data_buf[DATA_BUF_SIZE];
     PRIntn rv, bytes_read;
 	sockfd = sp->sp_fd;
 	if ((newsockfd = PR_Accept(sockfd, NULL,
 		PR_INTERVAL_NO_TIMEOUT)) == NULL) {
 		fprintf(stderr,"ERROR - PR_Accept failed: (%d,%d)\n",
 										PR_GetError(), PR_GetOSError());
 		return;
 	}
 	bytes_read = 0;
 	while (bytes_read != DATA_BUF_SIZE) {
 		rv = PR_Read(newsockfd, data_buf + bytes_read ,
 									DATA_BUF_SIZE - bytes_read);
 		if (rv < 0) {
 			fprintf(stderr,"Error - PR_Read failed: (%d, %d)\n",
 							PR_GetError(), PR_GetOSError());
 			PR_Close(newsockfd);
 			return;
 		}
 		PR_ASSERT(rv != 0);
 		bytes_read += rv;
 	}
 	DPRINTF(("Bytes read from client - %d\n",bytes_read));
 	rv = PR_Write(newsockfd, data_buf,DATA_BUF_SIZE);
 	if (rv < 0) {
 		fprintf(stderr,"Error - PR_Write failed: (%d, %d)\n",
 						PR_GetError(), PR_GetOSError());
 		PR_Close(newsockfd);
 		return;
 	}
 	PR_ASSERT(rv == DATA_BUF_SIZE);
 	DPRINTF(("Bytes written to client - %d\n",rv));
 	PR_Close(newsockfd);
 }
 /*
  * test for successful connection using a non-blocking socket
  */
 static PRIntn
 connection_success_test()
 {
 	PRFileDesc *sockfd = NULL, *conn_fd = NULL;
 	PRNetAddr netaddr;
 	PRInt32 i, rv;
     PRPollDesc pd;
     PRSocketOptionData optData;
 	PRThread *thr = NULL;
 	Server_Param sp;
 	char send_buf[DATA_BUF_SIZE], recv_buf[DATA_BUF_SIZE];
     PRIntn default_case, n, bytes_read, bytes_sent;
     PRIntn failed_already = 0;
 	/*
 	 * Create a tcp socket
 	 */
 	if ((sockfd = PR_NewTCPSocket()) == NULL) {
 		fprintf(stderr,"Error - PR_NewTCPSocket failed\n");
 		failed_already=1;
 		goto def_exit;
 	}
 	memset(&netaddr, 0 , sizeof(netaddr));
 	netaddr.inet.family = PR_AF_INET;
 	netaddr.inet.port = PR_htons(TCP_SERVER_PORT);
 	netaddr.inet.ip = PR_htonl(PR_INADDR_ANY);
 	/*
 	 * try a few times to bind server's address, if addresses are in
 	 * use
 	 */
 	i = 0;
 	while (PR_Bind(sockfd, &netaddr) < 0) {
 		if (PR_GetError() == PR_ADDRESS_IN_USE_ERROR) {
 			netaddr.inet.port += 2;
 			if (i++ < SERVER_MAX_BIND_COUNT)
 				continue;
 		}
 		fprintf(stderr,"ERROR - PR_Bind failed: (%d,%d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 	if (PR_Listen(sockfd, 32) < 0) {
 		fprintf(stderr,"ERROR - PR_Listen failed: (%d,%d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 	if (PR_GetSockName(sockfd, &netaddr) < 0) {
 		fprintf(stderr,"ERROR - PR_GetSockName failed: (%d,%d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 	if ((conn_fd = PR_NewTCPSocket()) == NULL) {
 		fprintf(stderr,"Error - PR_NewTCPSocket failed\n");
 		failed_already=1;
 		goto def_exit;
 	}
 	optData.option = PR_SockOpt_Nonblocking;
 	optData.value.non_blocking = PR_TRUE;
 	PR_SetSocketOption(conn_fd, &optData);
 	rv = PR_Connect(conn_fd, &netaddr, PR_INTERVAL_NO_TIMEOUT);
 	if (rv == PR_FAILURE) {
 		if (PR_GetError() == PR_IN_PROGRESS_ERROR) {
 			DPRINTF(("Connect in progress\n"));
 		} else  {
 			fprintf(stderr,"Error - PR_Connect failed: (%d, %d)\n",
 									PR_GetError(), PR_GetOSError());
 			failed_already=1;
 			goto def_exit;
 		}
 	}
 	/*
 	 * Now create a thread to accept a connection
 	 */
 	sp.sp_fd = sockfd;
 	thr = PR_CreateThread(PR_USER_THREAD, TCP_Server, (void *)&sp,
 			PR_PRIORITY_NORMAL, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
 	if (thr == NULL) {
 		fprintf(stderr,"Error - PR_CreateThread failed: (%d,%d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 	DPRINTF(("Created TCP_Server thread [0x%x]\n",thr));
 	pd.fd = conn_fd;
 	pd.in_flags = PR_POLL_WRITE | PR_POLL_EXCEPT;
 	n = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
 	if (n == -1) {
 		fprintf(stderr,"Error - PR_Poll failed: (%d, %d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 	if (PR_GetConnectStatus(&pd) == PR_SUCCESS) {
 		PRInt32 rv;
 		DPRINTF(("Connection successful\n"));
 		/*
 		 * Write some data, read it back and check data integrity to
 		 * make sure the connection is good
 		 */
 		pd.in_flags = PR_POLL_WRITE;
 		bytes_sent = 0;
 		memset(send_buf, 'a', DATA_BUF_SIZE);
 		while (bytes_sent != DATA_BUF_SIZE) {
 			rv = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
 			if (rv < 0) {
 				fprintf(stderr,"Error - PR_Poll failed: (%d, %d)\n",
 								PR_GetError(), PR_GetOSError());
 				failed_already=1;
 				goto def_exit;
 			}
 			PR_ASSERT((rv == 1) && (pd.out_flags == PR_POLL_WRITE));
 			rv = PR_Write(conn_fd, send_buf + bytes_sent,
 										DATA_BUF_SIZE - bytes_sent);
 			if (rv < 0) {
 				fprintf(stderr,"Error - PR_Write failed: (%d, %d)\n",
 								PR_GetError(), PR_GetOSError());
 				failed_already=1;
 				goto def_exit;
 			}
 			PR_ASSERT(rv > 0);
 			bytes_sent += rv;
 		}
 		DPRINTF(("Bytes written to server - %d\n",bytes_sent));
 		PR_Shutdown(conn_fd, PR_SHUTDOWN_SEND);
 		pd.in_flags = PR_POLL_READ;
 		bytes_read = 0;
 		memset(recv_buf, 0, DATA_BUF_SIZE);
 		while (bytes_read != DATA_BUF_SIZE) {
 			rv = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
 			if (rv < 0) {
 				fprintf(stderr,"Error - PR_Poll failed: (%d, %d)\n",
 								PR_GetError(), PR_GetOSError());
 				failed_already=1;
 				goto def_exit;
 			}
 			PR_ASSERT((rv == 1) && (pd.out_flags == PR_POLL_READ));
 			rv = PR_Read(conn_fd, recv_buf + bytes_read ,
 										DATA_BUF_SIZE - bytes_read);
 			if (rv < 0) {
 				fprintf(stderr,"Error - PR_Read failed: (%d, %d)\n",
 								PR_GetError(), PR_GetOSError());
 				failed_already=1;
 				goto def_exit;
 			}
 			PR_ASSERT(rv != 0);
 			bytes_read += rv;
 		}
 		DPRINTF(("Bytes read from server - %d\n",bytes_read));
 		/*
 		 * verify the data read
 		 */
 		if (memcmp(send_buf, recv_buf, DATA_BUF_SIZE) != 0) {
 			fprintf(stderr,"ERROR - data corruption\n");
 			failed_already=1;
 			goto def_exit;
 		}
 		DPRINTF(("Data integrity verified\n"));
 	} else {
 		fprintf(stderr,"PR_GetConnectStatus: connect failed: (%ld, %ld)\n",
 				PR_GetError(), PR_GetOSError());
 		failed_already = 1;
 		goto def_exit;
 	}
 def_exit:
 	if (thr) {
 		PR_JoinThread(thr);
 		thr = NULL;
 	}
 	if (sockfd) {
 		PR_Close(sockfd);
 		sockfd = NULL;
 	}
 	if (conn_fd) {
 		PR_Close(conn_fd);
 		conn_fd = NULL;
 	}
 	if (failed_already)
 		return 1;
 	else
 		return 0;
 }
 /*
  * test for connection to a nonexistent port using a non-blocking socket
  */
 static PRIntn
 connection_failure_test()
 {
 	PRFileDesc *sockfd = NULL, *conn_fd = NULL;
 	PRNetAddr netaddr;
 	PRInt32 i, rv;
     PRPollDesc pd;
     PRSocketOptionData optData;
     PRIntn n, failed_already = 0;
 	/*
 	 * Create a tcp socket
 	 */
 	if ((sockfd = PR_NewTCPSocket()) == NULL) {
 		fprintf(stderr,"Error - PR_NewTCPSocket failed\n");
 		failed_already=1;
 		goto def_exit;
 	}
 	memset(&netaddr, 0 , sizeof(netaddr));
 	netaddr.inet.family = PR_AF_INET;
 	netaddr.inet.port = PR_htons(TCP_SERVER_PORT);
 	netaddr.inet.ip = PR_htonl(PR_INADDR_ANY);
 	/*
 	 * try a few times to bind server's address, if addresses are in
 	 * use
 	 */
 	i = 0;
 	while (PR_Bind(sockfd, &netaddr) < 0) {
 		if (PR_GetError() == PR_ADDRESS_IN_USE_ERROR) {
 			netaddr.inet.port += 2;
 			if (i++ < SERVER_MAX_BIND_COUNT)
 				continue;
 		}
 		fprintf(stderr,"ERROR - PR_Bind failed: (%d,%d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 	if (PR_GetSockName(sockfd, &netaddr) < 0) {
 		fprintf(stderr,"ERROR - PR_GetSockName failed: (%d,%d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 #ifdef AIX
 	/*
 	 * On AIX, set to unused/reserved port
 	 */
 	netaddr.inet.port = PR_htons(TCP_UNUSED_PORT);
 #endif
 	if ((conn_fd = PR_NewTCPSocket()) == NULL) {
 		fprintf(stderr,"Error - PR_NewTCPSocket failed\n");
 		failed_already=1;
 		goto def_exit;
 	}
 	optData.option = PR_SockOpt_Nonblocking;
 	optData.value.non_blocking = PR_TRUE;
 	PR_SetSocketOption(conn_fd, &optData);
 	rv = PR_Connect(conn_fd, &netaddr, PR_INTERVAL_NO_TIMEOUT);
 	if (rv == PR_FAILURE) {
 		DPRINTF(("PR_Connect to a non-listen port failed: (%d, %d)\n",
 									PR_GetError(), PR_GetOSError()));
 	} else {
 		PR_ASSERT(rv == PR_SUCCESS);
 		fprintf(stderr,"Error - PR_Connect succeeded, expected to fail\n");
 		failed_already=1;
 		goto def_exit;
 	}
 	pd.fd = conn_fd;
 	pd.in_flags = PR_POLL_WRITE | PR_POLL_EXCEPT;
 	n = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
 	if (n == -1) {
 		fprintf(stderr,"Error - PR_Poll failed: (%d, %d)\n",
 									PR_GetError(), PR_GetOSError());
 		failed_already=1;
 		goto def_exit;
 	}
 	if (PR_GetConnectStatus(&pd) == PR_SUCCESS) {
 		PRInt32 rv;
 		fprintf(stderr,"PR_GetConnectStatus succeeded, expected to fail\n");
 		failed_already = 1;
 		goto def_exit;
 	}
 	rv = PR_GetError();
 	DPRINTF(("Connection failed, successfully with PR_Error %d\n",rv));
 def_exit:
 	if (sockfd) {
 		PR_Close(sockfd);
 		sockfd = NULL;
 	}
 	if (conn_fd) {
 		PR_Close(conn_fd);
 		conn_fd = NULL;
 	}
 	if (failed_already)
 		return 1;
 	else
 		return 0;
 }

The Tor Browser / annotate

nsprpub/pr/tests/nbconn.c@925c144e1f1f (annotated)

nsprpub/pr/tests/nbconn.c