The Tor Browser: nsprpub/pr/tests/accept.c@44a2da4a2ab2 (annotated)

nsprpub/pr/tests/accept.c@44a2da4a2ab2 (annotated)

nsprpub/pr/tests/accept.c

Fri, 16 Jan 2015 04:50:19 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 04:50:19 +0100
branch: TOR_BUG_9701
changeset 13: 44a2da4a2ab2
permissions: -rw-r--r--

Replace accessor implementation with direct member state manipulation, by
request https://trac.torproject.org/projects/tor/ticket/9701#comment:32

 /* -*- 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/. */
 /***********************************************************************
 **  1996 - Netscape Communications Corporation
 **
 ** Name: accept.c
 **
 ** Description: Run accept() sucessful connection tests.
 **
 ** Modification History:
 ** 04-Jun-97 AGarcia - Reconvert test file to return a 0 for PASS and a 1 for FAIL
 ** 13-May-97 AGarcia- Converted the test to accomodate the debug_mode
 **             The debug mode will print all of the printfs associated with this test.
 **             The regress mode will be the default mode. Since the regress tool limits
 **           the output to a one line status:PASS or FAIL,all of the printf statements
 **             have been handled with an if (debug_mode) statement.
 ** 04-June-97 AGarcia removed the Test_Result function. Regress tool has been updated to
 **            recognize the return code from tha main program.
 ** 12-June-97 Revert to return code 0 and 1.
 ***********************************************************************/
 /***********************************************************************
 ** Includes
 ***********************************************************************/
 #include "nspr.h"
 #include "prpriv.h"
 #include <stdlib.h>
 #include <string.h>
 #include "plgetopt.h"
 #include "plerror.h"
 #define BASE_PORT 10000
 #define CLIENT_DATA        128
 #define ACCEPT_NORMAL        0x1
 #define ACCEPT_FAST        0x2
 #define ACCEPT_READ        0x3
 #define ACCEPT_READ_FAST    0x4
 #define ACCEPT_READ_FAST_CB    0x5
 #define CLIENT_NORMAL        0x1
 #define CLIENT_TIMEOUT_ACCEPT    0x2
 #define CLIENT_TIMEOUT_SEND    0x3
 #define SERVER_MAX_BIND_COUNT        100
 #if defined(XP_OS2) || defined(SYMBIAN)
 #define TIMEOUTSECS 10
 #else
 #define TIMEOUTSECS 2
 #endif
 PRIntervalTime timeoutTime;
 static PRInt32 count = 1;
 static PRFileDesc *output;
 static PRNetAddr serverAddr;
 static PRThreadScope thread_scope = PR_LOCAL_THREAD;
 static PRInt32 clientCommand;
 static PRInt32 iterations;
 static PRStatus rv;
 static PRFileDesc *listenSock;
 static PRFileDesc *clientSock = NULL;
 static PRNetAddr listenAddr;
 static PRNetAddr clientAddr;
 static PRThread *clientThread;
 static PRNetAddr *raddr;
 static char buf[4096 + 2*sizeof(PRNetAddr) + 32];
 static PRInt32 status;
 static PRInt32 bytesRead;
 PRIntn failed_already=0;
 PRIntn debug_mode;
 void Test_Assert(const char *msg, const char *file, PRIntn line)
 {
     failed_already=1;
     if (debug_mode) {
         PR_fprintf(output,  "@%s:%d ", file, line);
         PR_fprintf(output, msg);
     }
 }  /* Test_Assert */
 #define TEST_ASSERT(expr) \
     if (!(expr)) Test_Assert(#expr, __FILE__, __LINE__)
 #ifdef WINNT
 #define CALLBACK_MAGIC 0x12345678
 void timeout_callback(void *magic)
 {
     TEST_ASSERT(magic == (void *)CALLBACK_MAGIC);
     if (debug_mode)
         PR_fprintf(output, "timeout callback called okay\n");
 }
 #endif
 static void PR_CALLBACK
 ClientThread(void *_action)
 {
     PRInt32 action = * (PRInt32 *) _action;
     PRInt32 iterations = count;
     PRFileDesc *sock = NULL;
     serverAddr.inet.family = PR_AF_INET;
     serverAddr.inet.port = listenAddr.inet.port;
     serverAddr.inet.ip = PR_htonl(PR_INADDR_LOOPBACK);
     for (; iterations--;) {
         PRInt32 rv;
         char buf[CLIENT_DATA];
         memset(buf, 0xaf, sizeof(buf)); /* initialize with arbitrary data */
         sock = PR_NewTCPSocket();
         if (!sock) {
             if (!debug_mode)
                 failed_already=1;
             else
                 PR_fprintf(output, "client: unable to create socket\n");
             return;
         }
         if (action != CLIENT_TIMEOUT_ACCEPT) {
             if ((rv = PR_Connect(sock, &serverAddr,
                 timeoutTime)) < 0) {
                 if (!debug_mode)
                     failed_already=1;
                 else
                     PR_fprintf(output,
                         "client: unable to connect to server (%ld, %ld, %ld, %ld)\n",
                         iterations, rv, PR_GetError(), PR_GetOSError());
                 goto ErrorExit;
             }
             if (action != CLIENT_TIMEOUT_SEND) {
                 if ((rv = PR_Send(sock, buf, CLIENT_DATA,
 , timeoutTime))< 0) {
                     if (!debug_mode)
                         failed_already=1;
                     else
                         PR_fprintf(output,
                             "client: unable to send to server (%d, %ld, %ld)\n",
                             CLIENT_DATA, rv, PR_GetError());
                 	goto ErrorExit;
                 }
             } else {
                 PR_Sleep(PR_SecondsToInterval(TIMEOUTSECS + 1));
             }
         } else {
             PR_Sleep(PR_SecondsToInterval(TIMEOUTSECS + 1));
         }
         if (debug_mode)
             PR_fprintf(output, ".");
         PR_Close(sock);
 		sock = NULL;
     }
     if (debug_mode)
         PR_fprintf(output, "\n");
 ErrorExit:
 	if (sock != NULL)
         PR_Close(sock);
 }
 static void
 RunTest(PRInt32 acceptType, PRInt32 clientAction)
 {
 int i;
     /* First bind to the socket */
     listenSock = PR_NewTCPSocket();
     if (!listenSock) {
         failed_already=1;
         if (debug_mode)
             PR_fprintf(output, "unable to create listen socket\n");
         return;
     }
 	memset(&listenAddr, 0 , sizeof(listenAddr));
     listenAddr.inet.family = PR_AF_INET;
     listenAddr.inet.port = PR_htons(BASE_PORT);
     listenAddr.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(listenSock, &listenAddr) == PR_FAILURE) {
         if (PR_GetError() == PR_ADDRESS_IN_USE_ERROR) {
             listenAddr.inet.port += 2;
             if (i++ < SERVER_MAX_BIND_COUNT)
                 continue;
         }
         failed_already=1;
         if (debug_mode)
         	PR_fprintf(output,"accept: ERROR - PR_Bind failed\n");
 		return;
     }
     rv = PR_Listen(listenSock, 100);
     if (rv == PR_FAILURE) {
         failed_already=1;
         if (debug_mode)
             PR_fprintf(output, "unable to listen\n");
         return;
     }
     clientCommand = clientAction;
     clientThread = PR_CreateThread(PR_USER_THREAD, ClientThread,
         (void *)&clientCommand, PR_PRIORITY_NORMAL, thread_scope,
         PR_JOINABLE_THREAD, 0);
     if (!clientThread) {
         failed_already=1;
         if (debug_mode)
             PR_fprintf(output, "error creating client thread\n");
         return;
     }
     iterations = count;
     for (;iterations--;) {
         switch (acceptType) {
         case ACCEPT_NORMAL:
             clientSock = PR_Accept(listenSock, &clientAddr,
                 timeoutTime);
             switch(clientAction) {
             case CLIENT_TIMEOUT_ACCEPT:
                 TEST_ASSERT(clientSock == 0);
                 TEST_ASSERT(PR_GetError() == PR_IO_TIMEOUT_ERROR);
                 break;
             case CLIENT_NORMAL:
                 TEST_ASSERT(clientSock);
                 bytesRead = PR_Recv(clientSock,
                     buf,  CLIENT_DATA,  0,  timeoutTime);
                 TEST_ASSERT(bytesRead == CLIENT_DATA);
                 break;
             case CLIENT_TIMEOUT_SEND:
                 TEST_ASSERT(clientSock);
                 bytesRead = PR_Recv(clientSock,
                     buf,  CLIENT_DATA,  0,  timeoutTime);
                 TEST_ASSERT(bytesRead == -1);
                 TEST_ASSERT(PR_GetError() == PR_IO_TIMEOUT_ERROR);
                 break;
             }
             break;
         case ACCEPT_READ:
             status = PR_AcceptRead(listenSock, &clientSock,
                 &raddr, buf, CLIENT_DATA, timeoutTime);
             switch(clientAction) {
             case CLIENT_TIMEOUT_ACCEPT:
                 /* Invalid test case */
                 TEST_ASSERT(0);
                 break;
             case CLIENT_NORMAL:
                 TEST_ASSERT(clientSock);
                 TEST_ASSERT(status == CLIENT_DATA);
                 break;
             case CLIENT_TIMEOUT_SEND:
                 TEST_ASSERT(status == -1);
                 TEST_ASSERT(PR_GetError() == PR_IO_TIMEOUT_ERROR);
                 break;
             }
             break;
 #ifdef WINNT
         case ACCEPT_FAST:
             clientSock = PR_NTFast_Accept(listenSock,
                 &clientAddr, timeoutTime);
             switch(clientAction) {
             case CLIENT_TIMEOUT_ACCEPT:
                 TEST_ASSERT(clientSock == 0);
                 if (debug_mode)
                     PR_fprintf(output, "PR_GetError is %ld\n", PR_GetError());
                 TEST_ASSERT(PR_GetError() == PR_IO_TIMEOUT_ERROR);
                 break;
             case CLIENT_NORMAL:
                 TEST_ASSERT(clientSock);
                 bytesRead = PR_Recv(clientSock,
                     buf,  CLIENT_DATA,  0,  timeoutTime);
                 TEST_ASSERT(bytesRead == CLIENT_DATA);
                 break;
             case CLIENT_TIMEOUT_SEND:
                 TEST_ASSERT(clientSock);
                 bytesRead = PR_Recv(clientSock,
                     buf,  CLIENT_DATA,  0,  timeoutTime);
                 TEST_ASSERT(bytesRead == -1);
                 TEST_ASSERT(PR_GetError() == PR_IO_TIMEOUT_ERROR);
                 break;
             }
             break;
             break;
         case ACCEPT_READ_FAST:
             status = PR_NTFast_AcceptRead(listenSock,
                 &clientSock, &raddr, buf, 4096, timeoutTime);
             switch(clientAction) {
             case CLIENT_TIMEOUT_ACCEPT:
                 /* Invalid test case */
                 TEST_ASSERT(0);
                 break;
             case CLIENT_NORMAL:
                 TEST_ASSERT(clientSock);
                 TEST_ASSERT(status == CLIENT_DATA);
                 break;
             case CLIENT_TIMEOUT_SEND:
                 TEST_ASSERT(clientSock == NULL);
                 TEST_ASSERT(status == -1);
                 TEST_ASSERT(PR_GetError() == PR_IO_TIMEOUT_ERROR);
                 break;
             }
             break;
         case ACCEPT_READ_FAST_CB:
             status = PR_NTFast_AcceptRead_WithTimeoutCallback(
                 listenSock, &clientSock, &raddr, buf, 4096,
                 timeoutTime, timeout_callback, (void *)CALLBACK_MAGIC);
             switch(clientAction) {
             case CLIENT_TIMEOUT_ACCEPT:
                 /* Invalid test case */
                 TEST_ASSERT(0);
                 break;
             case CLIENT_NORMAL:
                 TEST_ASSERT(clientSock);
                 TEST_ASSERT(status == CLIENT_DATA);
                 break;
             case CLIENT_TIMEOUT_SEND:
                 if (debug_mode)
                     PR_fprintf(output, "clientSock = 0x%8.8lx\n", clientSock);
                 TEST_ASSERT(clientSock == NULL);
                 TEST_ASSERT(status == -1);
                 TEST_ASSERT(PR_GetError() == PR_IO_TIMEOUT_ERROR);
                 break;
             }
             break;
 #endif
         }
         if (clientSock != NULL) {
             PR_Close(clientSock);
             clientSock = NULL;
         }
     }
     PR_Close(listenSock);
     PR_JoinThread(clientThread);
 }
 void AcceptUpdatedTest(void)
 {
     RunTest(ACCEPT_NORMAL, CLIENT_NORMAL);
 }
 void AcceptNotUpdatedTest(void)
 {
     RunTest(ACCEPT_FAST, CLIENT_NORMAL);
 }
 void AcceptReadTest(void)
 {
     RunTest(ACCEPT_READ, CLIENT_NORMAL);
 }
 void AcceptReadNotUpdatedTest(void)
 {
     RunTest(ACCEPT_READ_FAST, CLIENT_NORMAL);
 }
 void AcceptReadCallbackTest(void)
 {
     RunTest(ACCEPT_READ_FAST_CB, CLIENT_NORMAL);
 }
 void TimeoutAcceptUpdatedTest(void)
 {
     RunTest(ACCEPT_NORMAL, CLIENT_TIMEOUT_ACCEPT);
 }
 void TimeoutAcceptNotUpdatedTest(void)
 {
     RunTest(ACCEPT_FAST, CLIENT_TIMEOUT_ACCEPT);
 }
 void TimeoutAcceptReadCallbackTest(void)
 {
     RunTest(ACCEPT_READ_FAST_CB, CLIENT_TIMEOUT_ACCEPT);
 }
 void TimeoutReadUpdatedTest(void)
 {
     RunTest(ACCEPT_NORMAL, CLIENT_TIMEOUT_SEND);
 }
 void TimeoutReadNotUpdatedTest(void)
 {
     RunTest(ACCEPT_FAST, CLIENT_TIMEOUT_SEND);
 }
 void TimeoutReadReadTest(void)
 {
     RunTest(ACCEPT_READ, CLIENT_TIMEOUT_SEND);
 }
 void TimeoutReadReadNotUpdatedTest(void)
 {
     RunTest(ACCEPT_READ_FAST, CLIENT_TIMEOUT_SEND);
 }
 void TimeoutReadReadCallbackTest(void)
 {
     RunTest(ACCEPT_READ_FAST_CB, CLIENT_TIMEOUT_SEND);
 }
 /************************************************************************/
 static void Measure(void (*func)(void), const char *msg)
 {
     PRIntervalTime start, stop;
     double d;
     start = PR_IntervalNow();
     (*func)();
     stop = PR_IntervalNow();
     d = (double)PR_IntervalToMicroseconds(stop - start);
     if (debug_mode)
         PR_fprintf(output, "%40s: %6.2f usec\n", msg, d / count);
 }
 int main(int argc, char **argv)
 {
     /* The command line argument: -d is used to determine if the test is being run
     in debug mode. The regress tool requires only one line output:PASS or FAIL.
     All of the printfs associated with this test has been handled with a if (debug_mode)
     test.
     Usage: test_name [-d] [-c n]
     */
     PLOptStatus os;
     PLOptState *opt = PL_CreateOptState(argc, argv, "Gdc:");
     while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
     {
         if (PL_OPT_BAD == os) continue;
         switch (opt->option)
         {
         case 'G':  /* global threads */
             thread_scope = PR_GLOBAL_THREAD;
             break;
         case 'd':  /* debug mode */
             debug_mode = 1;
             break;
         case 'c':  /* loop counter */
             count = atoi(opt->value);
             break;
         default:
             break;
         }
     }
     PL_DestroyOptState(opt);
     PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
     output = PR_STDERR;
     PR_STDIO_INIT();
     timeoutTime = PR_SecondsToInterval(TIMEOUTSECS);
     if (debug_mode)
         PR_fprintf(output, "\nRun accept() sucessful connection tests\n");
     Measure(AcceptUpdatedTest, "PR_Accept()");
     Measure(AcceptReadTest, "PR_AcceptRead()");
 #ifdef WINNT
     Measure(AcceptNotUpdatedTest, "PR_NTFast_Accept()");
     Measure(AcceptReadNotUpdatedTest, "PR_NTFast_AcceptRead()");
     Measure(AcceptReadCallbackTest, "PR_NTFast_AcceptRead_WithTimeoutCallback()");
 #endif
     if (debug_mode)
         PR_fprintf(output, "\nRun accept() timeout in the accept tests\n");
 #ifdef WINNT
     Measure(TimeoutReadReadCallbackTest, "PR_NTFast_AcceptRead_WithTimeoutCallback()");
 #endif
     Measure(TimeoutReadUpdatedTest, "PR_Accept()");
     if (debug_mode)
         PR_fprintf(output, "\nRun accept() timeout in the read tests\n");
     Measure(TimeoutReadReadTest, "PR_AcceptRead()");
 #ifdef WINNT
     Measure(TimeoutReadNotUpdatedTest, "PR_NTFast_Accept()");
     Measure(TimeoutReadReadNotUpdatedTest, "PR_NTFast_AcceptRead()");
     Measure(TimeoutReadReadCallbackTest, "PR_NTFast_AcceptRead_WithTimeoutCallback()");
 #endif
     PR_fprintf(output, "%s\n", (failed_already) ? "FAIL" : "PASS");
     return failed_already;
 }

The Tor Browser / annotate

nsprpub/pr/tests/accept.c@44a2da4a2ab2 (annotated)

nsprpub/pr/tests/accept.c