ChangeLogTag:Tue Feb 28 19:46:16 UTC 2006 Steve Huston <shuston@riverace.com>

2 files changed, 101 insertions, 58 deletions

diff --git a/ChangeLog b/ChangeLog
index 548941bb4ce..0c82da30ff9 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,21 @@
+Tue Feb 28 19:46:16 UTC 2006  Steve Huston  <shuston@riverace.com>
+
+        * tests/MT_SOCK_Test.cpp: Add a special-case check for Win64. It
+          appears that Win64 listen/accept side has some changed behavior
+          but I haven't found any Windows docs to state this; just observed
+          behavior. It appears that WinXP-64 will appear to accept connections
+          at the TCP level past the listen backlog but if data arrives before
+          the actual application-level accept() occurs, the connection is
+          reset. I can see where this would be sensible for a web server or
+          something like that, but it causes a problem for this use case where
+          the test client side connects and starts sending.
+          Note I also tried modifying the checks in the connect path (in
+          ACE.cpp, handle_timed_complete()), but the connection really does
+          appear to be accepted clean; a peek recv will complete without
+          the reset being noticed, hence my speculation that Microsoft
+          "enhanced" the behavior at the server side.
+          Also, fixed a lot of bad indentation and some missing ACE_TEXTs.
+
 Tue Feb 28 11:12:12 UTC 2006  Johnny Willemsen  <jwilemsen@remedy.nl>
 
         * ace/Connector.cpp:
diff --git a/tests/MT_SOCK_Test.cpp b/tests/MT_SOCK_Test.cpp
index 483c075b455..403db298f4c 100644
--- a/tests/MT_SOCK_Test.cpp
+++ b/tests/MT_SOCK_Test.cpp
@@ -63,8 +63,7 @@ client (void *arg)
   ACE_Time_Value *timeout = &tv;
 #endif /* ACE_HAS_BROKEN_NON_BLOCKING_CONNECTS */
 
-  ACE_DEBUG ((LM_DEBUG,
-    ACE_TEXT ("(%P|%t) client: Connecting...\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) client: Connecting...\n")));
   // Initiate timed connection with server.
 
   // Attempt a timed connect to the server.
@@ -74,24 +73,24 @@ client (void *arg)
     {
       ACE_DEBUG ((LM_DEBUG,
                   ACE_TEXT ("(%P|%t) %p\n"),
-      ACE_TEXT ("client: Connection timed out.")));
+                  ACE_TEXT ("client: Connection timed out.")));
       return 0;
     }
 
   if (cli_stream.get_local_addr (client_addr) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
                        ACE_TEXT ("(%P|%t) %p\n"),
-    ACE_TEXT ("client: get_local_addr")),
+                       ACE_TEXT ("client: get_local_addr")),
                       0);
 
   ACE_DEBUG ((LM_DEBUG,
-    ACE_TEXT ("(%P|%t) client: Connected at %d\n"),
+              ACE_TEXT ("(%P|%t) client: Connected at %d\n"),
               client_addr.get_port_number ()));
 
   if (cli_stream.disable (ACE_NONBLOCK) == -1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("(%P|%t) %p\n"),
-    ACE_TEXT ("client: disable")));
+                ACE_TEXT ("client: disable")));
 
   // Send data to server (correctly handles "incomplete writes").
 
@@ -100,26 +99,45 @@ client (void *arg)
   for (const char *c = ACE_ALPHABET; *c != '\0'; c++)
     if (cli_stream.send_n (c, 1) == -1)
       {
-      ACE_ERROR ((LM_ERROR,
-        ACE_TEXT ("(%P|%t) (%d) %p\n"), errno,
-        ACE_TEXT ("client: send_n")));
+#if defined (ACE_WIN64)
+        // This is, I believe, more of an issue with WinXP-64 _server_
+        // side, but we can trap it here since we know we're connecting
+        // to localhost. It appears, though I haven't found documentation
+        // stating, that WinXP-64 will appear to accept connections at the
+        // TCP level past the listen backlog but if data arrives before the
+        // actual application-level accept() occurs, the connection is reset.
+        // So, if we get a reset on the first send, don't flag the error -
+        // just note it and act like the connection was refused.
+        if (c == ACE_ALPHABET && errno == ECONNRESET) // First byte sent
+          {
+            ACE_DEBUG
+              ((LM_DEBUG,
+                ACE_TEXT ("(%P|%t) client: Connection refused (delayed)\n")));
+            cli_stream.close ();
+            return 0;
+          }
+#endif /* ACE_WIN64 */
+
+        ACE_ERROR ((LM_ERROR,
+                    ACE_TEXT ("(%P|%t) (errno %d) %p\n"), errno,
+                    ACE_TEXT ("client: send_n")));
         ACE_ERROR ((LM_ERROR, "client: Closing stream.\n"));
         cli_stream.close();
         return 0;
       }
 
   ACE_DEBUG ((LM_DEBUG,
-    ACE_TEXT ("(%P|%t) client: Closing writer...\n")));
+              ACE_TEXT ("(%P|%t) client: Closing writer...\n")));
 
   // Explicitly close the writer-side of the connection.
   if (cli_stream.close_writer () == -1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("(%P|%t) %p\n"),
-    ACE_TEXT ("client: close_writer")));
+                ACE_TEXT ("client: close_writer")));
   char buf[1];
 
   ACE_DEBUG ((LM_DEBUG,
-    ACE_TEXT ("(%P|%t) client: Waiting for server handshake...\n")));
+              ACE_TEXT ("(%P|%t) client: Waiting for server handshake...\n")));
 
   // Wait for handshake with server.
   if (cli_stream.recv_n (buf, 1) != 1)
@@ -127,14 +145,15 @@ client (void *arg)
                 ACE_TEXT ("(%P|%t) %p\n"),
     ACE_TEXT ("client: recv_n")));
 
-  ACE_DEBUG ((LM_DEBUG,
-    ACE_TEXT ("(%P|%t) client: Handshake received. Closing stream.\n")));
+  ACE_DEBUG
+    ((LM_DEBUG,
+      ACE_TEXT ("(%P|%t) client: Handshake received. Closing stream.\n")));
 
   // Close the connection completely.
   if (cli_stream.close () == -1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("(%P|%t) %p\n"),
-    ACE_TEXT ("client: close")));
+                ACE_TEXT ("client: close")));
   return 0;
 }
 
@@ -147,7 +166,7 @@ server (void *arg)
   if (peer_acceptor->enable (ACE_NONBLOCK) == -1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("(%P|%t) %p\n"),
-    ACE_TEXT ("server: enable acceptor")));
+                ACE_TEXT ("server: enable acceptor")));
 
   // Keep these objects out here to prevent excessive constructor
   // calls...
@@ -173,7 +192,7 @@ server (void *arg)
       handle_set.reset ();
       handle_set.set_bit (peer_acceptor->get_handle ());
 
-    ACE_DEBUG((LM_DEBUG, "(%P|%t) server: Waiting for connection...\n"));
+      ACE_DEBUG((LM_DEBUG, "(%P|%t) server: Waiting for connection...\n"));
 
       int select_width;
 #  if defined (ACE_WIN64)
@@ -183,26 +202,28 @@ server (void *arg)
 #  else
       select_width = int (peer_acceptor->get_handle ()) + 1;
 #  endif /* ACE_WIN64 */
-    int result = ACE_OS::select (select_width, handle_set, 0, 0, &tv);
+      int result = ACE_OS::select (select_width, handle_set, 0, 0, &tv);
       ACE_ASSERT (tv == def_timeout);
 
       if (result == -1)
         ACE_ERROR_RETURN ((LM_ERROR,
                            ACE_TEXT ("(%P|%t) %p\n"),
-      ACE_TEXT ("server: select acceptor")),
+                           ACE_TEXT ("server: select acceptor")),
                           0);
       else if (result == 0)
         {
           ACE_DEBUG ((LM_DEBUG,
-        ACE_TEXT ("(%P|%t) server: Test finished.\n")));
-      // The meaning of the backlog parameter for listen() varies by platform. For
-      // some reason lost to history, the specified value is typically 
-      // backlog * 1.5, backlog * 1.5 + 1, or event taken literally as on Windows.
-      // We'll accept any number less than backlog * 2 as valid.
-      if (num_clients_connected >= BACKLOG * 2)
-        ACE_ERROR((LM_ERROR,
-          "(%P|%t) server: Incorrect # client connections. Expected:%d-%d Actual:%d\n",
-          BACKLOG, BACKLOG * 2, num_clients_connected));
+                      ACE_TEXT ("(%P|%t) server: Test finished.\n")));
+          // The meaning of the backlog parameter for listen() varies by
+          // platform. For some reason lost to history, the specified value
+          // is typically backlog * 1.5, backlog * 1.5 + 1, or event taken
+          // literally as on Windows. We'll accept any number less than
+          // backlog * 2 as valid.
+          if (num_clients_connected >= BACKLOG * 2)
+            ACE_ERROR ((LM_ERROR,
+                        ACE_TEXT ("(%P|%t) server: Incorrect # client ")
+                        ACE_TEXT ("connections. Expected:%d-%d Actual:%d\n"),
+                        BACKLOG, BACKLOG * 2, num_clients_connected));
           return 0;
         }
 
@@ -214,25 +235,25 @@ server (void *arg)
         {
           const char *t = ACE_ALPHABET;
 
-      ++num_clients_connected;
+          ++num_clients_connected;
 
           ACE_DEBUG ((LM_DEBUG,
-        ACE_TEXT ("(%P|%t) server: Client %s connected from %d\n"),
-                      ACE_TEXT_CHAR_TO_TCHAR(cli_addr.get_host_name ()),
+                      ACE_TEXT ("(%P|%t) server: Client %C connected from %d\n"),
+                      cli_addr.get_host_name (),
                       cli_addr.get_port_number ()));
 
           // Enable non-blocking I/O.
           if (new_stream.enable (ACE_NONBLOCK) == -1)
             ACE_ERROR_RETURN ((LM_ERROR,
                                ACE_TEXT ("(%P|%t) %p\n"),
-        ACE_TEXT ("server: enable non blocking i/o")),
+                               ACE_TEXT ("server: enable non blocking i/o")),
                               0);
           handle_set.reset ();
           handle_set.set_bit (new_stream.get_handle ());
 
           // Read data from client (terminate on error).
-      ACE_DEBUG ((LM_DEBUG,
-        ACE_TEXT ("(%P|%t) server: Waiting for data...\n")));
+          ACE_DEBUG ((LM_DEBUG,
+                      ACE_TEXT ("(%P|%t) server: Waiting for data...\n")));
 
           for (ssize_t r_bytes; ;)
             {
@@ -252,7 +273,7 @@ server (void *arg)
                                    ACE_TEXT ("select")),
                                   0);
 
-        ACE_DEBUG((LM_DEBUG, "(%P|%t) server: Receiving data...\n"));
+              ACE_DEBUG ((LM_DEBUG, "(%P|%t) server: Receiving data...\n"));
 
               while ((r_bytes = new_stream.recv (buf, 1)) > 0)
                 {
@@ -260,39 +281,42 @@ server (void *arg)
                   t++;
                 }
 
-        ACE_DEBUG((LM_DEBUG, "(%P|%t) server: Received data.\n"));
+              ACE_DEBUG((LM_DEBUG, "(%P|%t) server: Received data.\n"));
 
               if (r_bytes == 0)
                 {
                   // Handshake back with client.
-                  ACE_DEBUG ((LM_DEBUG,
-            ACE_TEXT ("(%P|%t) server: Connection closed by client.\n")));
+                  ACE_DEBUG
+                    ((LM_DEBUG,
+                      ACE_TEXT ("(%P|%t) server: Connection closed by client.\n")));
 
-          ACE_DEBUG ((LM_DEBUG, "(%P|%t) server: Sending handshake.\n"));
+                  ACE_DEBUG
+                    ((LM_DEBUG,
+                      ACE_TEXT ("(%P|%t) server: Sending handshake.\n")));
 
                   if (new_stream.send_n ("", 1) != 1)
                     ACE_ERROR ((LM_ERROR,
                                 ACE_TEXT ("(%P|%t) %p\n"),
-            ACE_TEXT ("server: send_n")));
+                                ACE_TEXT ("server: send_n")));
 
-          ACE_DEBUG((LM_DEBUG, "(%P|%t) server: Closing stream.\n"));
+                  ACE_DEBUG ((LM_DEBUG, "(%P|%t) server: Closing stream.\n"));
 
                   // Close endpoint.
                   if (new_stream.close () == -1)
                     ACE_ERROR ((LM_ERROR,
                                 ACE_TEXT ("(%P|%t) %p\n"),
-            ACE_TEXT ("server: close")));
+                                ACE_TEXT ("server: close")));
                   break;
                 }
               else if (r_bytes == -1)
                 {
                   if (errno == EWOULDBLOCK || errno == EAGAIN)
                     ACE_DEBUG ((LM_DEBUG,
-            ACE_TEXT ("(%P|%t) server: (EWOULDBLOCK) Waiting for more data...\n")));
+                                ACE_TEXT ("(%P|%t) server: (EWOULDBLOCK) Waiting for more data...\n")));
                   else
                     ACE_ERROR_RETURN ((LM_ERROR,
                                        ACE_TEXT ("(%P|%t) %p\n"),
-            ACE_TEXT ("server: recv_n")),
+                                       ACE_TEXT ("server: recv_n")),
                                       0);
                 }
             }
@@ -301,11 +325,11 @@ server (void *arg)
         {
           if (errno == EWOULDBLOCK)
             ACE_DEBUG ((LM_DEBUG,
-        ACE_TEXT ("(%P|%t) server: No more connections pending.\n")));
+                        ACE_TEXT ("(%P|%t) server: No more connections pending.\n")));
           else
             ACE_ERROR ((LM_ERROR,
                         ACE_TEXT ("(%P|%t) %p\n"),
-        ACE_TEXT ("server: accept")));
+                        ACE_TEXT ("server: accept")));
         }
     }
   ACE_NOTREACHED (return 0);
@@ -327,7 +351,7 @@ spawn (int num_clients)
       || peer_acceptor.get_local_addr (server_addr) == -1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("(%P|%t) %p\n"),
-    ACE_TEXT ("spawn: open")));
+                ACE_TEXT ("spawn: open")));
   else
     {
       ACE_DEBUG ((LM_DEBUG,
@@ -341,8 +365,8 @@ spawn (int num_clients)
             {
             case -1:
               ACE_ERROR ((LM_ERROR,
-          "(%P|%t) %p\n", "spawn: fork failed"));
-        i = num_clients;
+                          ACE_TEXT ("(%P|%t) %p\n", "spawn: fork failed")));
+              i = num_clients;
               // Break out of 'for' loop.
               break;
             case 0:
@@ -361,11 +385,11 @@ spawn (int num_clients)
       // Reap the child pids.
       for (pid_t pid; (pid = ACE_OS::wait ()) != -1; )
         ACE_DEBUG ((LM_DEBUG,
-      "(%P|%t) spawn: reaping pid %d\n", pid));
+                    ACE_TEXT ("(%P|%t) spawn: reaping pid %d\n"), pid));
 
 #elif defined (ACE_HAS_THREADS)
 
-    ACE_DEBUG((LM_DEBUG, "Spawning server...\n"));
+      ACE_DEBUG((LM_DEBUG, "Spawning server...\n"));
 
       if (ACE_Thread_Manager::instance ()->spawn
           (ACE_THR_FUNC (server),
@@ -373,33 +397,34 @@ spawn (int num_clients)
            THR_BOUND | THR_DETACHED) == -1)
         ACE_ERROR ((LM_ERROR,
                     ACE_TEXT ("(%P|%t) %p\n%a"),
-      ACE_TEXT ("spawn: failed"),
+                    ACE_TEXT ("spawn: failed"),
                     1));
 
-    ACE_DEBUG((LM_DEBUG, "Spawning %d clients...\n", num_clients));
+      ACE_DEBUG((LM_DEBUG, "Spawning %d clients...\n", num_clients));
 
       if (ACE_Thread_Manager::instance ()->spawn_n
-      (num_clients,
+          (num_clients,
            ACE_THR_FUNC (client),
            (void *) &server_addr,
            THR_BOUND | THR_DETACHED) == -1)
         ACE_ERROR ((LM_ERROR,
                     ACE_TEXT ("(%P|%t) %p\n%a"),
-      ACE_TEXT ("spawn: failed 2"),
+                    ACE_TEXT ("spawn: failed 2"),
                     1));
 
-    ACE_DEBUG((LM_DEBUG, "Waiting for threads to finish...\n"));
+      ACE_DEBUG((LM_DEBUG, "Waiting for threads to finish...\n"));
 
       // Wait for the threads to exit.
       ACE_Thread_Manager::instance ()->wait ();
 #else
       ACE_ERROR ((LM_INFO,
                   ACE_TEXT ("(%P|%t) ")
-      ACE_TEXT ("spawn: only one thread may be run")
+                  ACE_TEXT ("spawn: only one thread may be run")
                   ACE_TEXT (" in a process on this platform\n")));
 #endif /* !ACE_LACKS_FORK */
 
-    ACE_DEBUG((LM_DEBUG, "Threads complete. Closing Acceptor.\n"));
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("Threads complete. Closing Acceptor.\n")));
 
       peer_acceptor.close ();
     }