Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 319 insertions, 0 deletions

diff --git a/nsprpub/pr/tests/ntioto.c b/nsprpub/pr/tests/ntioto.c
new file mode 100644
index 0000000000..809e0ae5c6
--- /dev/null
+++ b/nsprpub/pr/tests/ntioto.c
@@ -0,0 +1,319 @@
+/* -*- 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/. */
+
+/*
+** File: ntioto.c
+** Description:
+** This test, ntioto.c, was designed to reproduce a bug reported by NES
+** on WindowsNT (fibers implementation). NSPR was asserting in ntio.c
+** after PR_AcceptRead() had timed out. I/O performed subsequent to the
+** call to PR_AcceptRead() could complete on a CPU other than the one
+** on which it was started. The assert in ntio.c detected this, then
+** asserted.
+**
+** Design:
+** This test will fail with an assert in ntio.c if the problem it was
+** designed to catch occurs. It returns 0 otherwise.
+**
+** The main() thread initializes and tears things down. A file is
+** opened for writing; this file will be written to by AcceptThread()
+** and JitterThread().  Main() creates a socket for reading, listens
+** and binds the socket.
+**
+** ConnectThread() connects to the socket created by main, then polls
+** the "state" variable. When state is AllDone, ConnectThread() exits.
+**
+** AcceptThread() calls PR_AcceptRead() on the socket. He fully expects
+** it to time out. After the timeout, AccpetThread() interacts with
+** JitterThread() via a common condition variable and the state
+** variable. The two threads ping-pong back and forth, each thread
+** writes the the file opened by main. This should provoke the
+** condition reported by NES (if we didn't fix it).
+**
+** The failure is not solid. It may fail within a few ping-pongs between
+** AcceptThread() and JitterThread() or may take a while. The default
+** iteration count, jitter, is set by DEFAULT_JITTER. This may be
+** modified at the command line with the -j option.
+**
+*/
+
+#include <plgetopt.h>
+#include <nspr.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** Test harness infrastructure
+*/
+PRLogModuleInfo *lm;
+PRLogModuleLevel msgLevel = PR_LOG_NONE;
+PRIntn  debug = 0;
+PRIntn  verbose = 0;
+PRUint32  failed_already = 0;
+/* end Test harness infrastructure */
+
+/* JITTER_DEFAULT: the number of times AcceptThread() and JitterThread() ping-pong */
+#define JITTER_DEFAULT  100000
+
+#ifdef DEBUG
+#define PORT_INC_DO +100
+#else
+#define PORT_INC_DO
+#endif
+#ifdef IS_64
+#define PORT_INC_3264 +200
+#else
+#define PORT_INC_3264
+#endif
+
+#define BASE_PORT 9867 PORT_INC_DO PORT_INC_3264
+
+PRIntervalTime timeout;
+PRNetAddr   listenAddr;
+PRFileDesc  *listenSock;
+PRLock      *ml;
+PRCondVar   *cv;
+volatile enum  {
+    RunJitter,
+    RunAcceptRead,
+    AllDone
+} state = RunAcceptRead;
+PRFileDesc  *file1;
+PRIntn  iCounter = 0;
+PRIntn  jitter = JITTER_DEFAULT;
+PRBool  resume = PR_FALSE;
+
+/*
+** Emit help text for this test
+*/
+static void Help( void )
+{
+    printf("Template: Help(): display your help message(s) here");
+    exit(1);
+} /* end Help() */
+
+
+/*
+** static computation of PR_AcceptRead() buffer size.
+*/
+#define ACCEPT_READ_DATASIZE 10
+#define ACCEPT_READ_BUFSIZE (PR_ACCEPT_READ_BUF_OVERHEAD + ACCEPT_READ_DATASIZE)
+
+static void AcceptThread(void *arg)
+{
+    PRIntn bytesRead;
+    char dataBuf[ACCEPT_READ_BUFSIZE];
+    PRFileDesc  *arSock;
+    PRNetAddr   *arAddr;
+
+    bytesRead = PR_AcceptRead( listenSock,
+                               &arSock,
+                               &arAddr,
+                               dataBuf,
+                               ACCEPT_READ_DATASIZE,
+                               PR_SecondsToInterval(1));
+
+    if ( bytesRead == -1 && PR_GetError() == PR_IO_TIMEOUT_ERROR ) {
+        if ( debug ) {
+            printf("AcceptRead timed out\n");
+        }
+    } else {
+        if ( debug ) {
+            printf("Oops! read: %d, error: %d\n", bytesRead, PR_GetError());
+        }
+    }
+
+    while( state != AllDone )  {
+        PR_Lock( ml );
+        while( state != RunAcceptRead ) {
+            PR_WaitCondVar( cv, PR_INTERVAL_NO_TIMEOUT );
+        }
+        if ( ++iCounter >= jitter ) {
+            state = AllDone;
+        }
+        else {
+            state = RunJitter;
+        }
+        if ( verbose ) {
+            printf(".");
+        }
+        PR_NotifyCondVar( cv );
+        PR_Unlock( ml );
+        PR_Write( file1, ".", 1 );
+    }
+
+    return;
+} /* end AcceptThread() */
+
+static void JitterThread(void *arg)
+{
+    while( state != AllDone )  {
+        PR_Lock( ml );
+        while( state != RunJitter && state != AllDone ) {
+            PR_WaitCondVar( cv, PR_INTERVAL_NO_TIMEOUT );
+        }
+        if ( state != AllDone) {
+            state = RunAcceptRead;
+        }
+        if ( verbose ) {
+            printf("+");
+        }
+        PR_NotifyCondVar( cv );
+        PR_Unlock( ml );
+        PR_Write( file1, "+", 1 );
+    }
+    return;
+} /* end Goofy() */
+
+static void ConnectThread( void *arg )
+{
+    PRStatus    rv;
+    PRFileDesc  *clientSock;
+    PRNetAddr   serverAddress;
+    clientSock = PR_NewTCPSocket();
+
+    PR_ASSERT(clientSock);
+
+    if ( resume ) {
+        if ( debug ) {
+            printf("pausing 3 seconds before connect\n");
+        }
+        PR_Sleep( PR_SecondsToInterval(3));
+    }
+
+    memset(&serverAddress, 0, sizeof(serverAddress));
+    rv = PR_InitializeNetAddr(PR_IpAddrLoopback, BASE_PORT, &serverAddress);
+    PR_ASSERT( PR_SUCCESS == rv );
+    rv = PR_Connect( clientSock,
+                     &serverAddress,
+                     PR_SecondsToInterval(1));
+    PR_ASSERT( PR_SUCCESS == rv );
+
+    /* that's all we do. ... Wait for the acceptread() to timeout */
+    while( state != AllDone ) {
+        PR_Sleep( PR_SecondsToInterval(1));
+    }
+    return;
+} /* end ConnectThread() */
+
+
+int main(int argc, char **argv)
+{
+    PRThread *tJitter;
+    PRThread *tAccept;
+    PRThread *tConnect;
+    PRStatus rv;
+    /* This test if valid for WinNT only! */
+
+#if !defined(WINNT)
+    return 0;
+#endif
+
+    {
+        /*
+        ** Get command line options
+        */
+        PLOptStatus os;
+        PLOptState *opt = PL_CreateOptState(argc, argv, "hdrvj:");
+
+        while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
+        {
+            if (PL_OPT_BAD == os) {
+                continue;
+            }
+            switch (opt->option)
+            {
+                case 'd':  /* debug */
+                    debug = 1;
+                    msgLevel = PR_LOG_ERROR;
+                    break;
+                case 'v':  /* verbose mode */
+                    verbose = 1;
+                    msgLevel = PR_LOG_DEBUG;
+                    break;
+                case 'j':
+                    jitter = atoi(opt->value);
+                    if ( jitter == 0) {
+                        jitter = JITTER_DEFAULT;
+                    }
+                    break;
+                case 'r':
+                    resume = PR_TRUE;
+                    break;
+                case 'h':  /* help message */
+                    Help();
+                    break;
+                default:
+                    break;
+            }
+        }
+        PL_DestroyOptState(opt);
+    }
+
+    lm = PR_NewLogModule("Test");       /* Initialize logging */
+
+    /* set concurrency */
+    PR_SetConcurrency( 4 );
+
+    /* setup thread synchronization mechanics */
+    ml = PR_NewLock();
+    cv = PR_NewCondVar( ml );
+
+    /* setup a tcp socket */
+    memset(&listenAddr, 0, sizeof(listenAddr));
+    rv = PR_InitializeNetAddr(PR_IpAddrAny, BASE_PORT, &listenAddr);
+    PR_ASSERT( PR_SUCCESS == rv );
+
+    listenSock = PR_NewTCPSocket();
+    PR_ASSERT( listenSock );
+
+    rv = PR_Bind( listenSock, &listenAddr);
+    PR_ASSERT( PR_SUCCESS == rv );
+
+    rv = PR_Listen( listenSock, 5 );
+    PR_ASSERT( PR_SUCCESS == rv );
+
+    /* open a file for writing, provoke bug */
+    file1 = PR_Open("xxxTestFile", PR_CREATE_FILE | PR_RDWR, 666);
+
+    /* create Connect thread */
+    tConnect = PR_CreateThread(
+                   PR_USER_THREAD, ConnectThread, NULL,
+                   PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
+                   PR_JOINABLE_THREAD, 0 );
+    PR_ASSERT( tConnect );
+
+    /* create jitter off thread */
+    tJitter = PR_CreateThread(
+                  PR_USER_THREAD, JitterThread, NULL,
+                  PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
+                  PR_JOINABLE_THREAD, 0 );
+    PR_ASSERT( tJitter );
+
+    /* create acceptread thread */
+    tAccept = PR_CreateThread(
+                  PR_USER_THREAD, AcceptThread, NULL,
+                  PR_PRIORITY_NORMAL, PR_LOCAL_THREAD,
+                  PR_JOINABLE_THREAD, 0 );
+    PR_ASSERT( tAccept );
+
+    /* wait for all threads to quit, then terminate gracefully */
+    PR_JoinThread( tConnect );
+    PR_JoinThread( tAccept );
+    PR_JoinThread( tJitter );
+    PR_Close( listenSock );
+    PR_DestroyCondVar(cv);
+    PR_DestroyLock(ml);
+    PR_Close( file1 );
+    PR_Delete( "xxxTestFile");
+
+    /* test return and exit */
+    if (debug) {
+        printf("%s\n", (failed_already)? "FAIL" : "PASS");
+    }
+    return( (failed_already == PR_TRUE )? 1 : 0 );
+}  /* main() */
+/* end ntioto.c */