dep/ACE_wrappers/ace/SOCK_SEQPACK_Acceptor.cpp

   1 // $Id: SOCK_SEQPACK_Acceptor.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/SOCK_SEQPACK_Acceptor.h"
   4
   5 #include "ace/Auto_Ptr.h"
   6 #include "ace/Log_Msg.h"
   7 #include "ace/OS_Memory.h"
   8 #include "ace/OS_NS_string.h"
   9 #include "ace/OS_NS_sys_socket.h"
  10 #include "ace/os_include/os_fcntl.h"
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "ace/SOCK_SEQPACK_Acceptor.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 ACE_RCSID(ace, SOCK_SEQPACK_Acceptor, "SOCK_SEQPACK_Acceptor.cpp,v 4.30 2002/03/08 23:18:09 spark Exp")
  17
  18 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  19
  20 ACE_ALLOC_HOOK_DEFINE(ACE_SOCK_SEQPACK_Acceptor)
  21
  22 // Do nothing routine for constructor.
  23
  24 ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor (void)
  25 {
  26   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor");
  27 }
  28
  29 // Performs the timed accept operation.
  30
  31 int
  32 ACE_SOCK_SEQPACK_Acceptor::shared_accept_start (ACE_Time_Value *timeout,
  33                                         int restart,
  34                                         int &in_blocking_mode) const
  35 {
  36   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::shared_accept_start");
  37
  38   ACE_HANDLE handle = this->get_handle ();
  39
  40   // Handle the case where we're doing a timed <accept>.
  41   if (timeout != 0)
  42     {
  43       if (ACE::handle_timed_accept (handle,
  44                                     timeout,
  45                                     restart) == -1)
  46         return -1;
  47       else
  48         {
  49           in_blocking_mode = ACE_BIT_DISABLED (ACE::get_flags (handle),
  50                                                ACE_NONBLOCK);
  51           // Set the handle into non-blocking mode if it's not already
  52           // in it.
  53           if (in_blocking_mode
  54               && ACE::set_flags (handle,
  55                                  ACE_NONBLOCK) == -1)
  56             return -1;
  57         }
  58     }
  59
  60   return 0;
  61 }
  62
  63 int
  64 ACE_SOCK_SEQPACK_Acceptor::shared_accept_finish (ACE_SOCK_SEQPACK_Association new_association,
  65                                          int in_blocking_mode,
  66                                          int reset_new_handle) const
  67 {
  68   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::shared_accept_finish ()");
  69
  70   ACE_HANDLE new_handle = new_association.get_handle ();
  71
  72   // Check to see if we were originally in blocking mode, and if so,
  73   // set the <new_association>'s handle and <this> handle to be in blocking
  74   // mode.
  75   if (in_blocking_mode)
  76     {
  77       // Save/restore errno.
  78       ACE_Errno_Guard error (errno);
  79
  80       // Only disable ACE_NONBLOCK if we weren't in non-blocking mode
  81       // originally.
  82       ACE::clr_flags (this->get_handle (),
  83                       ACE_NONBLOCK);
  84       ACE::clr_flags (new_handle,
  85                       ACE_NONBLOCK);
  86     }
  87
  88 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
  89   if (reset_new_handle)
  90     // Reset the event association inherited by the new handle.
  91     ::WSAEventSelect ((SOCKET) new_handle, 0, 0);
  92 #else
  93   ACE_UNUSED_ARG (reset_new_handle);
  94 #endif /* ACE_WIN32 */
  95
  96   return new_handle == ACE_INVALID_HANDLE ? -1 : 0;
  97 }
  98
  99 // General purpose routine for accepting new connections.
 100
 101 int
 102 ACE_SOCK_SEQPACK_Acceptor::accept (ACE_SOCK_SEQPACK_Association &new_association,
 103                            ACE_Addr *remote_addr,
 104                            ACE_Time_Value *timeout,
 105                            int restart,
 106                            int reset_new_handle) const
 107 {
 108   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::accept");
 109
 110   int in_blocking_mode = 0;
 111   if (this->shared_accept_start (timeout,
 112                                  restart,
 113                                  in_blocking_mode) == -1)
 114     return -1;
 115   else
 116     {
 117       // On Win32 the third parameter to <accept> must be a NULL
 118       // pointer if we want to ignore the client's address.
 119       int *len_ptr = 0;
 120       sockaddr *addr = 0;
 121       int len = 0;
 122
 123       if (remote_addr != 0)
 124         {
 125           len = remote_addr->get_size ();
 126           len_ptr = &len;
 127           addr = (sockaddr *) remote_addr->get_addr ();
 128         }
 129
 130       do
 131         new_association.set_handle (ACE_OS::accept (this->get_handle (),
 132                                                addr,
 133                                                len_ptr));
 134       while (new_association.get_handle () == ACE_INVALID_HANDLE
 135              && restart != 0
 136              && errno == EINTR
 137              && timeout == 0);
 138
 139       // Reset the size of the addr, so the proper UNIX/IPv4/IPv6 family
 140       // is known.
 141       if (new_association.get_handle () != ACE_INVALID_HANDLE
 142           && remote_addr != 0)
 143         {
 144           remote_addr->set_size (len);
 145           remote_addr->set_type (addr->sa_family);
 146         }
 147     }
 148
 149   return this->shared_accept_finish (new_association,
 150                                      in_blocking_mode,
 151                                      reset_new_handle);
 152 }
 153
 154 void
 155 ACE_SOCK_SEQPACK_Acceptor::dump (void) const
 156 {
 157 #if defined (ACE_HAS_DUMP)
 158   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::dump");
 159 #endif /* ACE_HAS_DUMP */
 160 }
 161
 162 int
 163 ACE_SOCK_SEQPACK_Acceptor::shared_open (const ACE_Addr &local_sap,
 164                                 int protocol_family,
 165                                 int backlog)
 166 {
 167   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::shared_open");
 168   int error = 0;
 169
 170 #if defined (ACE_HAS_IPV6)
 171   ACE_ASSERT (protocol_family == PF_INET || protocol_family == PF_INET6);
 172
 173   if (protocol_family == PF_INET6)
 174     {
 175       sockaddr_in6 local_inet6_addr;
 176       ACE_OS::memset (reinterpret_cast<void *> (&local_inet6_addr),
 177                       0,
 178                       sizeof local_inet6_addr);
 179
 180       if (local_sap == ACE_Addr::sap_any)
 181         {
 182           local_inet6_addr.sin6_family = AF_INET6;
 183           local_inet6_addr.sin6_port = 0;
 184           local_inet6_addr.sin6_addr = in6addr_any;
 185         }
 186       else
 187         local_inet6_addr = *reinterpret_cast<sockaddr_in6 *> (local_sap.get_addr ());
 188
 189       // We probably don't need a bind_port written here.
 190       // There are currently no supported OS's that define
 191       // ACE_LACKS_WILDCARD_BIND.
 192       if (ACE_OS::bind (this->get_handle (),
 193                         reinterpret_cast<sockaddr *> (&local_inet6_addr),
 194                         sizeof local_inet6_addr) == -1)
 195         error = 1;
 196     }
 197   else
 198 #endif
 199   if (protocol_family == PF_INET)
 200     {
 201       sockaddr_in local_inet_addr;
 202       ACE_OS::memset (reinterpret_cast<void *> (&local_inet_addr),
 203                       0,
 204                       sizeof local_inet_addr);
 205
 206       if (local_sap == ACE_Addr::sap_any)
 207         {
 208           local_inet_addr.sin_port = 0;
 209         }
 210       else
 211         local_inet_addr = *reinterpret_cast<sockaddr_in *> (local_sap.get_addr ());
 212       if (local_inet_addr.sin_port == 0)
 213         {
 214           if (ACE::bind_port (this->get_handle ()) == -1)
 215             error = 1;
 216         }
 217       else if (ACE_OS::bind (this->get_handle (),
 218                              reinterpret_cast<sockaddr *> (&local_inet_addr),
 219                              sizeof local_inet_addr) == -1)
 220         error = 1;
 221     }
 222   else if (ACE_OS::bind (this->get_handle (),
 223                          (sockaddr *) local_sap.get_addr (),
 224                          local_sap.get_size ()) == -1)
 225     error = 1;
 226
 227   if (error != 0
 228       || ACE_OS::listen (this->get_handle (),
 229                          backlog) == -1)
 230     {
 231       error = 1;
 232       this->close ();
 233     }
 234
 235   return error ? -1 : 0;
 236 }
 237
 238 // Multihomed version of same.
 239
 240 int
 241 ACE_SOCK_SEQPACK_Acceptor::shared_open (const ACE_Multihomed_INET_Addr &local_sap,
 242                                         int protocol_family,
 243                                         int backlog)
 244 {
 245   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::shared_open");
 246   int error = 0;
 247
 248   // TODO: Add multi-address support to IPV6
 249 #if defined (ACE_HAS_IPV6)
 250   ACE_ASSERT (protocol_family == PF_INET || protocol_family == PF_INET6);
 251
 252   if (protocol_family == PF_INET6)
 253     {
 254       sockaddr_in6 local_inet6_addr;
 255       ACE_OS::memset (reinterpret_cast<void *> (&local_inet6_addr),
 256                       0,
 257                       sizeof local_inet6_addr);
 258
 259       if (local_sap.ACE_Addr::operator== (ACE_Addr::sap_any))
 260         {
 261           local_inet6_addr.sin6_family = AF_INET6;
 262           local_inet6_addr.sin6_port = 0;
 263           local_inet6_addr.sin6_addr = in6addr_any;
 264         }
 265       else
 266         local_inet6_addr = *reinterpret_cast<sockaddr_in6 *> (local_sap.get_addr ());
 267
 268       // We probably don't need a bind_port written here.
 269       // There are currently no supported OS's that define
 270       // ACE_LACKS_WILDCARD_BIND.
 271       if (ACE_OS::bind (this->get_handle (),
 272                         reinterpret_cast<sockaddr *> (&local_inet6_addr),
 273                         sizeof local_inet6_addr) == -1)
 274         error = 1;
 275     }
 276   else
 277 #endif
 278   if (protocol_family == PF_INET)
 279     {
 280       sockaddr_in local_inet_addr;
 281       ACE_OS::memset (reinterpret_cast<void *> (&local_inet_addr),
 282                       0,
 283                       sizeof local_inet_addr);
 284
 285       if (local_sap.ACE_Addr::operator== (ACE_Addr::sap_any))
 286         {
 287           local_inet_addr.sin_port = 0;
 288         }
 289       else
 290         local_inet_addr = *reinterpret_cast<sockaddr_in *> (local_sap.get_addr ());
 291
 292 //  A port number of 0 means that the user is requesting that the
 293 //  operating system choose an arbitrary, unused port.  Since some
 294 //  operating systems don't provide this service, ACE provides an
 295 //  emulation layer.  Therefore, the "ACE way" to bind an arbitrary,
 296 //  unused port is to call ACE:bind_port, which either
 297 //
 298 //    (1)  Calls ACE_OS::bind with port 0, if the operating system
 299 //         directly supports the automated selection, or
 300 //
 301 //    (2)  Performs more complicated logic to emulate this feature if
 302 //         it's missing from the OS.
 303 //
 304 //  The emulation logic in choice (2) is compiled if and only if
 305 //  ACE_LACKS_WILDCARD_BIND is defined at compile time.
 306 //
 307 //  Along these lines, the following block of code seems like it would
 308 //  be sufficient to support the wildcard bind operation:
 309 //
 310 //      if (local_inet_addr.sin_port == 0)
 311 //         {
 312 //           if (ACE::bind_port (this->get_handle (),
 313 //               ACE_NTOHL (ACE_UINT32 (local_inet_addr.sin_addr.s_addr))) == -1)
 314 //             error = 1;
 315 //
 316 //         }
 317 //      else
 318 //
 319 //  Unfortunately, this code is insufficient because it does not
 320 //  address the possibility of secondary addresses.
 321 //
 322 //  However, rather than writing the correct code now, I'm putting it
 323 //  off, because this class, ACE_SOCK_SEQPACK_Acceptor, is currently
 324 //  only used with SCTP, and ACE currently supports SCTP only through
 325 //  the OpenSS7 and LKSCTP implmentations, which are available only on
 326 //  Linux.  Linux has native support for the wildcard bind, so the
 327 //  following code works regardless of whether or not the port is 0.
 328
 329         {
 330           // The total number of addresses is the number of secondary
 331           // addresses plus one.
 332           size_t num_addresses = local_sap.get_num_secondary_addresses() + 1;
 333
 334           // Create an array of sockaddr_in to hold the underlying
 335           // representations of the primary and secondary
 336           // addresses.
 337           sockaddr_in*  local_inet_addrs = 0;
 338           ACE_NEW_NORETURN (local_inet_addrs,
 339                             sockaddr_in[num_addresses]);
 340
 341           if (!local_inet_addrs)
 342             error = 1;
 343           else
 344             {
 345               // Populate the array by invoking the get_addresses method
 346               // on the Multihomed_INET_Addr
 347               local_sap.get_addresses(local_inet_addrs,
 348                                       num_addresses);
 349
 350 #if defined (ACE_HAS_LKSCTP)
 351
 352               sockaddr_in *local_sockaddr = 0;
 353
 354               // bind the primary first
 355               if (ACE_OS::bind (this->get_handle (),
 356                                 reinterpret_cast<sockaddr *> (&(local_inet_addrs[0])),
 357                                 sizeof(sockaddr)) == -1)
 358               {
 359                 error = 1;
 360               }
 361
 362               // do we need to bind multiple addresses?
 363               if (num_addresses > 1)
 364               {
 365                 ACE_NEW_NORETURN(local_sockaddr,
 366                                sockaddr_in[num_addresses - 1]);
 367
 368                 // all of the secondary addresses need the local port set
 369                 for (size_t i = 1; i < num_addresses; i++)
 370                 {
 371                   local_inet_addrs[i].sin_port = local_inet_addrs[0].sin_port;
 372                 }
 373
 374                 // copy only the sockaddrs that we need to bindx
 375                 for (size_t i = 0; i < num_addresses - 1; i++)
 376                 {
 377                   ACE_OS::memcpy(&(local_sockaddr[i]),
 378                                  &(local_inet_addrs[i + 1]),
 379                                  sizeof(sockaddr_in));
 380                 }
 381
 382                 // now call bindx
 383                 if (!error && sctp_bindx(this->get_handle (),
 384                                          reinterpret_cast<sockaddr *> (local_sockaddr),
 385                                          num_addresses - 1,
 386                                          SCTP_BINDX_ADD_ADDR))
 387                 {
 388                   error = 1;
 389                 }
 390
 391                 delete [] local_sockaddr;
 392               }
 393 #else
 394               // Call bind
 395               size_t name_len = (sizeof local_inet_addr) * num_addresses;
 396               if (ACE_OS::bind (this->get_handle (),
 397                                 reinterpret_cast<sockaddr *> (local_inet_addrs),
 398                                 static_cast<int> (name_len)) == -1)
 399                 error = 1;
 400 #endif /* ACE_HAS_LKSCTP */
 401             }
 402
 403           delete [] local_inet_addrs;
 404         }
 405     }
 406   else if (ACE_OS::bind (this->get_handle (),
 407                          (sockaddr *) local_sap.get_addr (),
 408                          local_sap.get_size ()) == -1)
 409     error = 1;
 410
 411   if (error != 0
 412       || ACE_OS::listen (this->get_handle (),
 413                          backlog) == -1)
 414     {
 415       error = 1;
 416       this->close ();
 417     }
 418
 419   return error ? -1 : 0;
 420 }
 421
 422 int
 423 ACE_SOCK_SEQPACK_Acceptor::open (const ACE_Addr &local_sap,
 424                          ACE_Protocol_Info *protocolinfo,
 425                          ACE_SOCK_GROUP g,
 426                          u_long flags,
 427                          int reuse_addr,
 428                          int protocol_family,
 429                          int backlog,
 430                          int protocol)
 431 {
 432   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::open");
 433
 434   if (protocol_family == PF_UNSPEC)
 435     protocol_family = local_sap.get_type ();
 436
 437 #if defined (ACE_HAS_LKSCTP)
 438   if (ACE_SOCK::open (SOCK_STREAM,
 439 #else
 440   if (ACE_SOCK::open (SOCK_SEQPACKET,
 441 #endif
 442                       protocol_family,
 443                       protocol,
 444                       protocolinfo,
 445                       g,
 446                       flags,
 447                       reuse_addr) == -1)
 448     return -1;
 449   else
 450     return this->shared_open (local_sap,
 451                               protocol_family,
 452                               backlog);
 453 }
 454
 455 ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor (const ACE_Addr &local_sap,
 456                                       ACE_Protocol_Info *protocolinfo,
 457                                       ACE_SOCK_GROUP g,
 458                                       u_long flags,
 459                                       int reuse_addr,
 460                                       int protocol_family,
 461                                       int backlog,
 462                                       int protocol)
 463 {
 464   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor");
 465   if (this->open (local_sap,
 466                   protocolinfo,
 467                   g,
 468                   flags,
 469                   reuse_addr,
 470                   protocol_family,
 471                   backlog,
 472                   protocol) == -1)
 473     ACE_ERROR ((LM_ERROR,
 474                 ACE_TEXT ("%p\n"),
 475                 ACE_TEXT ("ACE_SOCK_SEQPACK_Acceptor")));
 476 }
 477
 478 // General purpose routine for performing server ACE_SOCK creation.
 479
 480 int
 481 ACE_SOCK_SEQPACK_Acceptor::open (const ACE_Addr &local_sap,
 482                          int reuse_addr,
 483                          int protocol_family,
 484                          int backlog,
 485                          int protocol)
 486 {
 487   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::open");
 488
 489   if (local_sap != ACE_Addr::sap_any)
 490     protocol_family = local_sap.get_type ();
 491   else if (protocol_family == PF_UNSPEC)
 492     {
 493 #if defined (ACE_HAS_IPV6)
 494       protocol_family = ACE::ipv6_enabled () ? PF_INET6 : PF_INET;
 495 #else
 496       protocol_family = PF_INET;
 497 #endif /* ACE_HAS_IPV6 */
 498     }
 499
 500 #if defined (ACE_HAS_LKSCTP)
 501   if (ACE_SOCK::open (SOCK_STREAM,
 502 #else
 503   if (ACE_SOCK::open (SOCK_SEQPACKET,
 504 #endif
 505                       protocol_family,
 506                       protocol,
 507                       reuse_addr) == -1)
 508     return -1;
 509   else
 510     return this->shared_open (local_sap,
 511                               protocol_family,
 512                               backlog);
 513 }
 514
 515 // Multihomed version of same.
 516
 517 int
 518 ACE_SOCK_SEQPACK_Acceptor::open (const ACE_Multihomed_INET_Addr &local_sap,
 519                          int reuse_addr,
 520                          int protocol_family,
 521                          int backlog,
 522                          int protocol)
 523 {
 524   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::open");
 525
 526   if (local_sap.ACE_Addr::operator!= (ACE_Addr::sap_any))
 527     protocol_family = local_sap.get_type ();
 528   else if (protocol_family == PF_UNSPEC)
 529     {
 530 #if defined (ACE_HAS_IPV6)
 531       protocol_family = ACE::ipv6_enabled () ? PF_INET6 : PF_INET;
 532 #else
 533       protocol_family = PF_INET;
 534 #endif /* ACE_HAS_IPV6 */
 535     }
 536
 537 #if defined (ACE_HAS_LKSCTP)
 538   if (ACE_SOCK::open (SOCK_STREAM,
 539 #else
 540   if (ACE_SOCK::open (SOCK_SEQPACKET,
 541 #endif
 542                       protocol_family,
 543                       protocol,
 544                       reuse_addr) == -1)
 545     return -1;
 546   else
 547     return this->shared_open (local_sap,
 548                               protocol_family,
 549                               backlog);
 550 }
 551
 552 // General purpose routine for performing server ACE_SOCK creation.
 553
 554 ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor (const ACE_Addr &local_sap,
 555                                       int reuse_addr,
 556                                       int protocol_family,
 557                                       int backlog,
 558                                       int protocol)
 559 {
 560   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor");
 561   if (this->open (local_sap,
 562                   reuse_addr,
 563                   protocol_family,
 564                   backlog,
 565                   protocol) == -1)
 566     ACE_ERROR ((LM_ERROR,
 567                 ACE_TEXT ("%p\n"),
 568                 ACE_TEXT ("ACE_SOCK_SEQPACK_Acceptor")));
 569 }
 570
 571 // Multihomed version of same.
 572
 573 ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor (const ACE_Multihomed_INET_Addr &local_sap,
 574                                       int reuse_addr,
 575                                       int protocol_family,
 576                                       int backlog,
 577                                       int protocol)
 578 {
 579   ACE_TRACE ("ACE_SOCK_SEQPACK_Acceptor::ACE_SOCK_SEQPACK_Acceptor");
 580   if (this->open (local_sap,
 581                   reuse_addr,
 582                   protocol_family,
 583                   backlog,
 584                   protocol) == -1)
 585     ACE_ERROR ((LM_ERROR,
 586                 ACE_TEXT ("%p\n"),
 587                 ACE_TEXT ("ACE_SOCK_SEQPACK_Acceptor")));
 588 }
 589
 590 int
 591 ACE_SOCK_SEQPACK_Acceptor::close (void)
 592 {
 593   return ACE_SOCK::close ();
 594 }
 595
 596 ACE_END_VERSIONED_NAMESPACE_DECL