ACE/tests/SOCK_Connector_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    SOCK_Connector_Test.cpp
   5  *
   6  *   This is a test of ACE_SOCK_Connector, focusing on failure cases more
   7  *   than on success cases.
   8  *
   9  *  @author Steve Huston <shuston@riverace.com>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "test_config.h"
  15 #include "ace/OS_NS_string.h"
  16 #include "ace/INET_Addr.h"
  17 #include "ace/SOCK_Connector.h"
  18 #include "ace/Time_Value.h"
  19 #include "ace/SOCK_Stream.h"
  20 #include "ace/OS_NS_sys_utsname.h"
  21 #include "ace/OS_NS_netdb.h"
  22
  23 #if defined(ACE_LACKS_GETHOSTENT) || defined(ACE_LACKS_SETHOSTENT) || defined(ACE_LACKS_ENDHOSTENT)
  24 #  define MISSING_HOSTENT_FUNCTIONS
  25 #endif
  26
  27 // Host candidate list
  28 struct Host_Candidate
  29 {
  30   ACE_TCHAR host_name[MAXHOSTNAMELEN];
  31 };
  32
  33 const int MAX_CANDIDATES = 50;
  34 Host_Candidate candidate[MAX_CANDIDATES];
  35
  36 #ifndef MISSING_HOSTENT_FUNCTIONS
  37 // Determine if a host exists, is reachable, and is up.  Attempt a
  38 // blocking connection to it; if it succeeds, then the host exists, is
  39 // reachable, and is up.
  40
  41 static u_int
  42 host_is_up (ACE_TCHAR hostname[])
  43 {
  44   ACE_SOCK_Connector con;
  45   ACE_SOCK_Stream sock;
  46
  47   // The ACE_INET_Addr construction causes gethostbyname_r to be
  48   // called, so we need to copy the hostname.
  49   ACE_TCHAR test_host[MAXHOSTNAMELEN];
  50   ACE_OS::strcpy (test_host, hostname);
  51
  52   ACE_INET_Addr another_host ((u_short) 7, test_host);
  53   ACE_Time_Value timeout_value (5);
  54   int const status = con.connect (sock,
  55                                   another_host,
  56                                   &timeout_value);
  57   sock.close ();
  58   return status == 0  ?  1  :  0;
  59 }
  60 #endif /* ! ACE_LACKS_GETHOSTENT */
  61
  62 // The original problem this program tested for was incorrectly saying
  63 // a non-blocking connect completed successfully when it didn't.  The
  64 // test doesn't always work when done to localhost
  65 // (platform-dependant) so we look around for another host - any other
  66 // one will do.
  67
  68 static void
  69 find_another_host (ACE_TCHAR other_host[])
  70 {
  71   static ACE_TCHAR cached_other_host[MAXHOSTNAMELEN] = {'\0'};
  72
  73   if (cached_other_host[0] == '\0')
  74     {
  75
  76       ACE_OS::strcpy (other_host,
  77                       ACE_DEFAULT_SERVER_HOST); // If all else fails
  78
  79 #ifndef MISSING_HOSTENT_FUNCTIONS
  80       // These gethost-type things don't work everywhere.
  81       struct hostent *h = 0;
  82       ACE_utsname un;
  83
  84       ACE_OS::uname (&un);
  85
  86       h = ACE_OS::gethostbyname (un.nodename);
  87
  88       if (h == 0)
  89         ACE_OS::strcpy (other_host, ACE_LOCALHOST);
  90       else
  91         // Use me if can't find another
  92         ACE_OS::strcpy (other_host, ACE_TEXT_CHAR_TO_TCHAR (h->h_name));
  93
  94       // @@ We really need to add wrappers for these hostent methods.
  95
  96       // Optimize for sequential access of DNS or hosts file.
  97       sethostent (1);
  98
  99       int candidate_count = 0;
 100
 101       // Accumulate candidates first.  There is some interaction on
 102       // Linux systems between <gethostent> and <gethostbyname_r>
 103       // (called by ACE_INET_Addr in host_is_up) This otherwise causes
 104       // an infinite loop on Linux --mas 03-08-2001
 105       while ((h = gethostent ()) != 0)
 106         {
 107           if (ACE_OS::strcmp (h->h_name,
 108                               ACE_TEXT_ALWAYS_CHAR (ACE_DEFAULT_SERVER_HOST)) == 0)
 109             continue;
 110           // AIX just _has_ to be different
 111           if (ACE_OS::strcmp (h->h_name, "loopback") == 0)
 112             continue;
 113
 114           // If not me.
 115           if (ACE_OS::strcmp
 116                 (h->h_name, ACE_TEXT_ALWAYS_CHAR (other_host)) != 0
 117               && ACE_OS::strcmp (h->h_name, un.nodename) != 0)
 118             {
 119                ACE_OS::strcpy (candidate[candidate_count].host_name,
 120                                ACE_TEXT_CHAR_TO_TCHAR (h->h_name));
 121                if (++candidate_count >= MAX_CANDIDATES)
 122                  break;
 123             }
 124         }
 125
 126       // Now try to connect to candidates
 127       for (int i = 0; i < candidate_count; i++)
 128         if (host_is_up (candidate[i].host_name))
 129           {
 130             ACE_OS::strcpy (other_host, candidate[i].host_name);
 131             break;
 132           }
 133
 134       sethostent (0);
 135       endhostent ();
 136 #endif /* ! ACE_LACKS_GETHOSTENT */
 137
 138       ACE_OS::strcpy (cached_other_host, other_host);
 139     }
 140   else
 141     ACE_OS::strcpy (other_host, cached_other_host);
 142 }
 143
 144 static int
 145 fail_no_listener_nonblocking (void)
 146 {
 147   ACE_TCHAR test_host[MAXHOSTNAMELEN], test_addr[MAXHOSTNAMELEN + 8];
 148   int status;
 149   ACE_INET_Addr nobody_home;
 150   ACE_SOCK_Connector con;
 151   ACE_SOCK_Stream sock;
 152   ACE_Time_Value nonblock (0, 0);
 153
 154   find_another_host (test_host);
 155   if (nobody_home.set ((u_short) 42000, test_host) == -1)
 156     {
 157       ACE_ERROR ((LM_ERROR,
 158                   ACE_TEXT ("Host lookup for %s %p\n"),
 159                   test_host,
 160                   ACE_TEXT ("failed")));
 161       return -1;
 162     }
 163   nobody_home.addr_to_string (test_addr, MAXHOSTNAMELEN + 8);
 164   ACE_DEBUG ((LM_DEBUG,
 165               ACE_TEXT ("Testing to host \"%s\" (%s)\n"),
 166               test_host, test_addr));
 167
 168   status = con.connect (sock, nobody_home, &nonblock);
 169
 170   // Need a port that will fail.
 171   if (status == 0)
 172     {
 173       ACE_ERROR ((LM_ERROR,
 174                   ACE_TEXT ("Connect which should fail didn't\n")));
 175       status = -1;
 176     }
 177
 178   // On some systems, a failed connect to localhost will return
 179   // ECONNREFUSED or ENETUNREACH directly, instead of
 180   // EWOULDBLOCK. That is also fine.
 181
 182   else if (errno == EWOULDBLOCK ||
 183            errno == ECONNREFUSED ||
 184            errno == ENETUNREACH)
 185     {
 186       if (sock.get_handle () != ACE_INVALID_HANDLE)
 187         status = con.complete (sock);
 188
 189       if (status != -1)
 190         {
 191           ACE_ERROR ((LM_ERROR,
 192                       ACE_TEXT ("Connect which should fail didn't\n")));
 193           status = -1;
 194         }
 195       else
 196         {
 197           ACE_DEBUG ((LM_DEBUG,
 198                       ACE_TEXT ("%p\n"),
 199                       ACE_TEXT ("Proper fail")));
 200           status = 0;
 201         }
 202     }
 203   else
 204     {
 205       ACE_DEBUG ((LM_WARNING,
 206                   ACE_TEXT ("Test not executed fully; ")
 207                   ACE_TEXT ("expected EWOULDBLOCK, %p (%d)\n"),
 208                   ACE_TEXT ("not"), ACE_ERRNO_GET));
 209       status = -1;
 210     }
 211
 212   // Just in case.
 213   sock.close ();
 214
 215   return status;
 216 }
 217
 218
 219 // This test tries to hit a port that's listening.  Echo (7) is pretty
 220 // popular.  Just in case, though, it won't report a failure if it
 221 // gets "refused" (no listener) since the real fixed bug this is
 222 // testing is a returned error of EWOULDBLOCK when the connect really
 223 // did work.  That was a side-affect of how
 224 // <ACE::handle_timed_complete> does checks on some systems.
 225
 226 static int
 227 succeed_nonblocking (void)
 228 {
 229   ACE_TCHAR test_host[MAXHOSTNAMELEN], test_addr[MAXHOSTNAMELEN + 8];
 230   int status;
 231   ACE_INET_Addr echo_server;
 232   ACE_SOCK_Connector con;
 233   ACE_SOCK_Stream sock;
 234   ACE_Time_Value nonblock (0, 0);
 235   u_short test_port = 7;          // Echo
 236
 237   find_another_host (test_host);
 238   if (ACE_OS::strcmp (ACE_TEXT ("localhost"), test_host) == 0)
 239     {
 240 #if defined (ACE_WIN32)
 241       test_port = 80;        // Echo not available on Win32; try web server
 242 #endif /* ACE_WIN32 */
 243     }
 244   if (echo_server.set (test_port, test_host) == -1)
 245     {
 246       ACE_ERROR ((LM_ERROR,
 247                   ACE_TEXT ("Host lookup for %s %p\n"),
 248                   test_host,
 249                   ACE_TEXT ("failed")));
 250       return -1;
 251     }
 252   echo_server.addr_to_string (test_addr, MAXHOSTNAMELEN + 8);
 253   ACE_DEBUG ((LM_DEBUG,
 254               ACE_TEXT ("Testing to host \"%s\", port %d (%s)\n"),
 255               test_host, test_port, test_addr));
 256   status = con.connect (sock, echo_server, &nonblock);
 257
 258   // Need to test the call to 'complete' really.
 259   if (status == 0 || (status == -1 && errno != EWOULDBLOCK))
 260     {
 261       ACE_DEBUG((LM_WARNING,
 262                  ACE_TEXT ("Immediate success/fail; test not completed\n")));
 263       status = 0;
 264     }
 265   else
 266     {
 267       if (sock.get_handle () != ACE_INVALID_HANDLE)
 268         {
 269           status = con.complete (sock);
 270         }
 271
 272       if (status == -1)
 273         {
 274           // Reset the status _before_ doing the printout, in case the
 275           // printout overwrites errno.
 276           if (errno == ECONNREFUSED)
 277             {
 278               status = 0;
 279               ACE_DEBUG ((LM_DEBUG,
 280                           ACE_TEXT ("Should succeed, but refused: ok\n")));
 281             }
 282           else
 283             {
 284               ACE_ERROR ((LM_ERROR,
 285                           ACE_TEXT("Errno <%d>: %p\n"),
 286                           ACE_ERRNO_GET,
 287                           ACE_TEXT("connect should succeed, but")));
 288             }
 289         }
 290       else
 291         ACE_DEBUG((LM_DEBUG,
 292                    ACE_TEXT("Connect which should succeed, did\n")));
 293     }
 294
 295   // Just in case.
 296   sock.close ();
 297
 298   return status;
 299 }
 300
 301 int
 302 run_main (int, ACE_TCHAR *[])
 303 {
 304   ACE_START_TEST (ACE_TEXT ("SOCK_Connector_Test"));
 305
 306   int status = 0;
 307
 308   if (fail_no_listener_nonblocking () == -1)
 309     status = 1;
 310
 311   if (succeed_nonblocking () == -1)
 312     status = 1;
 313
 314   ACE_END_TEST;
 315   return status;
 316 }
 317
 318
 319