ACE/ace/OS_NS_sys_socket.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_errno.h"
   3 #include "ace/OS_NS_macros.h"
   4 #include "ace/OS_NS_sys_uio.h"
   5 #include "ace/OS_NS_stdio.h"
   6 #include "ace/OS_QoS.h"
   7 #include "ace/Global_Macros.h"
   8 #include "ace/os_include/netinet/os_in.h"
   9
  10 #if defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \
  11          && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1)
  12 #include "ace/OS_NS_string.h"
  13 #endif
  14
  15 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 #if defined (ACE_HAS_VOIDPTR_SOCKOPT)
  18 typedef void *ACE_SOCKOPT_TYPE1;
  19 #elif defined (ACE_HAS_CHARPTR_SOCKOPT)
  20 typedef char *ACE_SOCKOPT_TYPE1;
  21 #else
  22 typedef const char *ACE_SOCKOPT_TYPE1;
  23 #endif /* ACE_HAS_VOIDPTR_SOCKOPT */
  24
  25 ACE_INLINE ACE_HANDLE
  26 ACE_OS::accept (ACE_HANDLE handle,
  27                 struct sockaddr *addr,
  28                 int *addrlen)
  29 {
  30   ACE_OS_TRACE ("ACE_OS::accept");
  31   // On a non-blocking socket with no connections to accept, this
  32   // system call will return EWOULDBLOCK or EAGAIN, depending on the
  33   // platform.  UNIX 98 allows either errno, and they may be the same
  34   // numeric value.  So to make life easier for upper ACE layers as
  35   // well as application programmers, always change EAGAIN to
  36   // EWOULDBLOCK.  Rather than hack the ACE_OSCALL_RETURN macro, it's
  37   // handled explicitly here.  If the ACE_OSCALL macro ever changes,
  38   // this function needs to be reviewed.  On Win32, the regular macros
  39   // can be used, as this is not an issue.
  40
  41 #if defined (ACE_LACKS_ACCEPT)
  42   ACE_UNUSED_ARG (handle);
  43   ACE_UNUSED_ARG (addr);
  44   ACE_UNUSED_ARG (addrlen);
  45   ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
  46 #elif defined (ACE_WIN32)
  47   ACE_SOCKCALL_RETURN (::accept ((ACE_SOCKET) handle,
  48                                  addr,
  49                                  (ACE_SOCKET_LEN *) addrlen),
  50                        ACE_HANDLE,
  51                        ACE_INVALID_HANDLE);
  52 #else
  53 #  if defined (ACE_HAS_BROKEN_ACCEPT_ADDR)
  54   // Apparently some platforms like VxWorks can't correctly deal with
  55   // a NULL addr.
  56
  57 #    if defined (ACE_HAS_IPV6)
  58    sockaddr_in6 fake_addr;
  59 #    else
  60    sockaddr_in fake_addr;
  61 #    endif /* ACE_HAS_IPV6 */
  62    int fake_addrlen;
  63
  64    if (addrlen == 0)
  65      addrlen = &fake_addrlen;
  66
  67    if (addr == 0)
  68      {
  69        addr = (sockaddr *) &fake_addr;
  70        *addrlen = sizeof fake_addr;
  71      }
  72 #  endif /* ACE_HAS_BROKEN_ACCEPT_ADDR */
  73   ACE_HANDLE ace_result = ::accept ((ACE_SOCKET) handle,
  74                                     addr,
  75                                     (ACE_SOCKET_LEN *) addrlen);
  76
  77 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
  78   // Optimize this code out if we can detect that EAGAIN ==
  79   // EWOULDBLOCK at compile time.  If we cannot detect equality at
  80   // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor
  81   // macros) perform the check at run-time.  The goal is to avoid two
  82   // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK.
  83   if (ace_result == ACE_INVALID_HANDLE
  84 #  if !defined (EAGAIN) || !defined (EWOULDBLOCK)
  85       && EAGAIN != EWOULDBLOCK
  86 #  endif  /* !EAGAIN || !EWOULDBLOCK */
  87       && errno == EAGAIN)
  88     {
  89       errno = EWOULDBLOCK;
  90     }
  91 # endif /* EAGAIN != EWOULDBLOCK*/
  92
  93   return ace_result;
  94
  95 #endif /* defined (ACE_WIN32) */
  96 }
  97
  98 ACE_INLINE int
  99 ACE_OS::bind (ACE_HANDLE handle, struct sockaddr *addr, int addrlen)
 100 {
 101   ACE_OS_TRACE ("ACE_OS::bind");
 102 #if defined (ACE_LACKS_BIND)
 103   ACE_UNUSED_ARG (handle);
 104   ACE_UNUSED_ARG (addr);
 105   ACE_UNUSED_ARG (addrlen);
 106   ACE_NOTSUP_RETURN (-1);
 107 #elif defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x640)
 108   // VxWorks clears the sin_port member after a successful bind when
 109   // sin_addr != INADDR_ANY, so after the bind we do retrieve the
 110   // original address so that user code can safely check the addr
 111   // after the bind. See bugzilla 3107 for more details
 112   int result;
 113   ACE_SOCKCALL (::bind ((ACE_SOCKET) handle,
 114                         addr,
 115                         (ACE_SOCKET_LEN) addrlen), int, -1, result);
 116   if (result == -1)
 117     return -1;
 118   else
 119     return ACE_OS::getsockname (handle, addr, &addrlen);
 120 #else
 121   ACE_SOCKCALL_RETURN (::bind ((ACE_SOCKET) handle,
 122                                addr,
 123                                (ACE_SOCKET_LEN) addrlen), int, -1);
 124 #endif
 125 }
 126
 127 ACE_INLINE int
 128 ACE_OS::closesocket (ACE_HANDLE handle)
 129 {
 130   ACE_OS_TRACE ("ACE_OS::closesocket");
 131 #if defined (ACE_WIN32) || defined (ACE_MQX)
 132   // @note Do not shutdown the write end here.  Doing so will break
 133   //       applications that duplicate a handle on fork(), for
 134   //       example, and expect to continue writing in the fork()ed
 135   //       process.
 136
 137   ACE_SOCKCALL_RETURN (::closesocket ((SOCKET) handle), int, -1);
 138 #else
 139   //FUZZ: disable check_for_lack_ACE_OS
 140   return ::close (handle);
 141   //FUZZ: enable check_for_lack_ACE_OS
 142 #endif /* ACE_WIN32 */
 143 }
 144
 145 ACE_INLINE int
 146 ACE_OS::connect (ACE_HANDLE handle,
 147                  struct sockaddr *addr,
 148                  int addrlen)
 149 {
 150   ACE_OS_TRACE ("ACE_OS::connect");
 151 #if defined (ACE_LACKS_CONNECT)
 152   ACE_UNUSED_ARG (handle);
 153   ACE_UNUSED_ARG (addr);
 154   ACE_UNUSED_ARG (addrlen);
 155   ACE_NOTSUP_RETURN (-1);
 156 #else
 157   ACE_SOCKCALL_RETURN (::connect ((ACE_SOCKET) handle,
 158                                   addr,
 159                                   (ACE_SOCKET_LEN) addrlen), int, -1);
 160 #endif /* ACE_LACKS_CONNECT */
 161 }
 162
 163 ACE_INLINE int
 164 ACE_OS::enum_protocols (int *protocols,
 165                         ACE_Protocol_Info *protocol_buffer,
 166                         u_long *buffer_length)
 167 {
 168 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
 169
 170   ACE_SOCKCALL_RETURN (::WSAEnumProtocols (protocols,
 171                                            protocol_buffer,
 172                                            buffer_length),
 173                        int,
 174                        SOCKET_ERROR);
 175
 176 #else
 177   ACE_UNUSED_ARG (protocols);
 178   ACE_UNUSED_ARG (protocol_buffer);
 179   ACE_UNUSED_ARG (buffer_length);
 180   ACE_NOTSUP_RETURN (-1);
 181 #endif /* ACE_HAS_WINSOCK2 */
 182 }
 183
 184 ACE_INLINE int
 185 ACE_OS::getpeername (ACE_HANDLE handle, struct sockaddr *addr,
 186                      int *addrlen)
 187 {
 188   ACE_OS_TRACE ("ACE_OS::getpeername");
 189
 190 #if defined (ACE_LACKS_GETPEERNAME)
 191   ACE_UNUSED_ARG (handle);
 192   ACE_UNUSED_ARG (addr);
 193   ACE_UNUSED_ARG (addrlen);
 194   ACE_NOTSUP_RETURN (-1);
 195 #elif defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \
 196            && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1)
 197   int result;
 198   ACE_SOCKCALL (::getpeername ((ACE_SOCKET) handle,
 199                                addr,
 200                                (ACE_SOCKET_LEN *) addrlen),
 201                int,
 202                 -1,
 203                 result);
 204
 205   // Some platforms, like older versions of the Linux kernel, do not
 206   // initialize the sin_zero field since that field is generally only
 207   // used for padding/alignment purposes.  On those platforms
 208   // memcmp()-based comparisons of the sockaddr_in structure, such as
 209   // the one in the ACE_INET_Addr equality operator, may fail due to
 210   // random bytes in the sin_zero field even though that field is
 211   // unused.  Prevent equality comparison of two different sockaddr_in
 212   // instances that refer to the same socket from failing by
 213   // explicitly initializing the sockaddr_in::sin_zero field to a
 214   // consistent value, e.g. zero.
 215   if (result != -1 && addr->sa_family == AF_INET)
 216     {
 217       ACE_OS::memset (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero,
 218                       0,
 219                       sizeof (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero));
 220     }
 221
 222   return result;
 223 #else
 224   ACE_SOCKCALL_RETURN (::getpeername ((ACE_SOCKET) handle,
 225                                       addr,
 226                                       (ACE_SOCKET_LEN *) addrlen),
 227                        int,
 228                        -1);
 229 #endif /* ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO */
 230 }
 231
 232 ACE_INLINE int
 233 ACE_OS::getsockname (ACE_HANDLE handle,
 234                      struct sockaddr *addr,
 235                      int *addrlen)
 236 {
 237   ACE_OS_TRACE ("ACE_OS::getsockname");
 238 #if defined (ACE_LACKS_GETSOCKNAME)
 239   ACE_UNUSED_ARG (handle);
 240   ACE_UNUSED_ARG (addr);
 241   ACE_UNUSED_ARG (addrlen);
 242   ACE_NOTSUP_RETURN (-1);
 243 #elif defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \
 244            && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1)
 245   int result;
 246   ACE_SOCKCALL (::getsockname ((ACE_SOCKET) handle,
 247                                addr,
 248                                (ACE_SOCKET_LEN *) addrlen),
 249                int, -1, result);
 250
 251   // Some platforms, like older versions of the Linux kernel, do not
 252   // initialize the sin_zero field since that field is generally only
 253   // used for padding/alignment purposes.  On those platforms
 254   // memcmp()-based comparisons of the sockaddr_in structure, such as
 255   // the one in the ACE_INET_Addr equality operator, may fail due to
 256   // random bytes in the sin_zero field even though that field is
 257   // unused.  Prevent equality comparison of two different sockaddr_in
 258   // instances that refer to the same socket from failing by
 259   // explicitly initializing the sockaddr_in::sin_zero field to a
 260   // consistent value, e.g. zero.
 261   if (result != -1 && addr->sa_family == AF_INET)
 262     {
 263       ACE_OS::memset (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero,
 264                       0,
 265                       sizeof (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero));
 266     }
 267
 268   return result;
 269 #else
 270   ACE_SOCKCALL_RETURN (::getsockname ((ACE_SOCKET) handle,
 271                                       addr,
 272                                       (ACE_SOCKET_LEN *) addrlen),
 273                        int, -1);
 274 #endif /* ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO */
 275 }
 276
 277 #if !defined(ACE_SOCKOPT_LEN)
 278 #define ACE_SOCKOPT_LEN ACE_SOCKET_LEN
 279 #endif
 280
 281 ACE_INLINE int
 282 ACE_OS::getsockopt (ACE_HANDLE handle,
 283                     int level,
 284                     int optname,
 285                     char *optval,
 286                     int *optlen)
 287 {
 288   ACE_OS_TRACE ("ACE_OS::getsockopt");
 289 #if defined (ACE_LACKS_GETSOCKOPT)
 290   ACE_UNUSED_ARG (handle);
 291   ACE_UNUSED_ARG (level);
 292   ACE_UNUSED_ARG (optname);
 293   ACE_UNUSED_ARG (optval);
 294   ACE_UNUSED_ARG (optlen);
 295   ACE_NOTSUP_RETURN (-1);
 296 #else
 297   ACE_SOCKCALL_RETURN (::getsockopt ((ACE_SOCKET) handle,
 298                                      level,
 299                                      optname,
 300                                      optval,
 301                                      (ACE_SOCKOPT_LEN *) optlen),
 302                        int,
 303                        -1);
 304 #endif /* ACE_LACKS_GETSOCKOPT */
 305 }
 306
 307 ACE_INLINE int
 308 ACE_OS::listen (ACE_HANDLE handle, int backlog)
 309 {
 310   ACE_OS_TRACE ("ACE_OS::listen");
 311 #if defined (ACE_LACKS_LISTEN)
 312   ACE_UNUSED_ARG (handle);
 313   ACE_UNUSED_ARG (backlog);
 314   ACE_NOTSUP_RETURN (-1);
 315 #else
 316   ACE_SOCKCALL_RETURN (::listen ((ACE_SOCKET) handle, backlog), int, -1);
 317 #endif /* ACE_LACKS_LISTEN */
 318 }
 319
 320 ACE_INLINE ssize_t
 321 ACE_OS::recv (ACE_HANDLE handle, char *buf, size_t len, int flags)
 322 {
 323   ACE_OS_TRACE ("ACE_OS::recv");
 324
 325   // On UNIX, a non-blocking socket with no data to receive, this
 326   // system call will return EWOULDBLOCK or EAGAIN, depending on the
 327   // platform.  UNIX 98 allows either errno, and they may be the same
 328   // numeric value.  So to make life easier for upper ACE layers as
 329   // well as application programmers, always change EAGAIN to
 330   // EWOULDBLOCK.  Rather than hack the ACE_OSCALL_RETURN macro, it's
 331   // handled explicitly here.  If the ACE_OSCALL macro ever changes,
 332   // this function needs to be reviewed.  On Win32, the regular macros
 333   // can be used, as this is not an issue.
 334 #if defined (ACE_LACKS_RECV)
 335   ACE_UNUSED_ARG (handle);
 336   ACE_UNUSED_ARG (buf);
 337   ACE_UNUSED_ARG (len);
 338   ACE_UNUSED_ARG (flags);
 339   ACE_NOTSUP_RETURN (-1);
 340 #elif defined (ACE_WIN32)
 341   ACE_SOCKCALL_RETURN (::recv ((ACE_SOCKET) handle, buf,
 342                                static_cast<int> (len), flags), ssize_t, -1);
 343 #else
 344   ssize_t ace_result_;
 345   ace_result_ = ::recv ((ACE_SOCKET) handle, buf, len, flags);
 346
 347 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
 348   // Optimize this code out if we can detect that EAGAIN ==
 349   // EWOULDBLOCK at compile time.  If we cannot detect equality at
 350   // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor
 351   // macros) perform the check at run-time.  The goal is to avoid two
 352   // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK.
 353   if (ace_result_ == -1
 354 #  if !defined (EAGAIN) || !defined (EWOULDBLOCK)
 355       && EAGAIN != EWOULDBLOCK
 356 #  endif  /* !EAGAIN || !EWOULDBLOCK */
 357       && errno == EAGAIN)
 358     {
 359       errno = EWOULDBLOCK;
 360     }
 361 # endif /* EAGAIN != EWOULDBLOCK*/
 362
 363   return ace_result_;
 364 #endif /* ACE_LACKS_RECV */
 365 }
 366
 367 ACE_INLINE ssize_t
 368 ACE_OS::recvfrom (ACE_HANDLE handle,
 369                   char *buf,
 370                   size_t len,
 371                   int flags,
 372                   struct sockaddr *addr,
 373                   int *addrlen)
 374 {
 375   ACE_OS_TRACE ("ACE_OS::recvfrom");
 376 #if defined (ACE_LACKS_RECVFROM)
 377   ACE_UNUSED_ARG (handle);
 378   ACE_UNUSED_ARG (buf);
 379   ACE_UNUSED_ARG (len);
 380   ACE_UNUSED_ARG (flags);
 381   ACE_UNUSED_ARG (addr);
 382   ACE_UNUSED_ARG (addrlen);
 383   ACE_NOTSUP_RETURN (-1);
 384 #elif defined (ACE_WIN32)
 385   int const shortened_len = static_cast<int> (len);
 386   int const result = ::recvfrom ((ACE_SOCKET) handle,
 387                                  buf,
 388                                  shortened_len,
 389                                  flags,
 390                                  addr,
 391                                  (ACE_SOCKET_LEN *) addrlen);
 392   if (result == SOCKET_ERROR)
 393     {
 394       ACE_OS::set_errno_to_wsa_last_error ();
 395       if (errno == WSAEMSGSIZE &&
 396           ACE_BIT_ENABLED (flags, MSG_PEEK))
 397         return shortened_len;
 398       else
 399         return -1;
 400     }
 401   else
 402     {
 403       return result;
 404     }
 405 #else /* non Win32 */
 406   ACE_SOCKCALL_RETURN (::recvfrom ((ACE_SOCKET) handle,
 407                                    buf,
 408                                    len,
 409                                    flags,
 410                                    addr,
 411                                    (ACE_SOCKET_LEN *) addrlen),
 412                        ssize_t, -1);
 413 #endif /* ACE_LACKS_RECVFROM */
 414 }
 415
 416 ACE_INLINE ssize_t
 417 ACE_OS::recvfrom (ACE_HANDLE handle,
 418                   iovec *buffers,
 419                   int buffer_count,
 420                   size_t &number_of_bytes_recvd,
 421                   int &flags,
 422                   struct sockaddr *addr,
 423                   int *addrlen,
 424                   ACE_OVERLAPPED *overlapped,
 425                   ACE_OVERLAPPED_COMPLETION_FUNC func)
 426 {
 427   ACE_OS_TRACE ("ACE_OS::recvfrom");
 428
 429 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
 430   DWORD bytes_recvd;
 431   DWORD the_flags = flags;
 432   int result = ::WSARecvFrom ((SOCKET) handle,
 433                               (WSABUF*)buffers,
 434                               buffer_count,
 435                               &bytes_recvd,
 436                               &the_flags,
 437                               addr,
 438                               addrlen,
 439                               overlapped,
 440                               func);
 441   if (result != 0) {
 442     ACE_OS::set_errno_to_wsa_last_error ();
 443   }
 444   flags = the_flags;
 445   number_of_bytes_recvd = static_cast<size_t> (bytes_recvd);
 446   return result;
 447 #else
 448   ACE_UNUSED_ARG (handle);
 449   ACE_UNUSED_ARG (buffers);
 450   ACE_UNUSED_ARG (buffer_count);
 451   ACE_UNUSED_ARG (number_of_bytes_recvd);
 452   ACE_UNUSED_ARG (flags);
 453   ACE_UNUSED_ARG (addr);
 454   ACE_UNUSED_ARG (addrlen);
 455   ACE_UNUSED_ARG (overlapped);
 456   ACE_UNUSED_ARG (func);
 457   ACE_NOTSUP_RETURN (-1);
 458 #endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */
 459 }
 460
 461 ACE_INLINE ssize_t
 462 ACE_OS::recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags)
 463 {
 464   ACE_OS_TRACE ("ACE_OS::recvmsg");
 465 #if !defined (ACE_LACKS_RECVMSG)
 466 # if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
 467   DWORD bytes_received = 0;
 468   int const result = msg->msg_control
 469     ? recvmsg_win32_i (handle, msg, flags, bytes_received)
 470     : ::WSARecvFrom ((SOCKET) handle,
 471                      (WSABUF *) msg->msg_iov,
 472                      msg->msg_iovlen,
 473                      &bytes_received,
 474                      (DWORD *) &flags,
 475                      msg->msg_name,
 476                      &msg->msg_namelen,
 477                      0,
 478                      0);
 479
 480   if (result != 0)
 481     {
 482       ACE_OS::set_errno_to_wsa_last_error ();
 483       return -1;
 484     }
 485   else
 486     return bytes_received;
 487 # else /* ACE_HAS_WINSOCK2 */
 488   ACE_SOCKCALL_RETURN (::recvmsg (handle, msg, flags), ssize_t, -1);
 489 # endif /* ACE_HAS_WINSOCK2 */
 490 #else
 491   ACE_UNUSED_ARG (flags);
 492   ACE_UNUSED_ARG (msg);
 493   ACE_UNUSED_ARG (handle);
 494
 495   ACE_NOTSUP_RETURN (-1);
 496 #endif /* ACE_LACKS_RECVMSG */
 497 }
 498
 499 ACE_INLINE ssize_t
 500 ACE_OS::recvv (ACE_HANDLE handle,
 501                iovec *buffers,
 502                int n)
 503 {
 504 #if defined (ACE_HAS_WINSOCK2)
 505
 506   DWORD bytes_received = 0;
 507   int result = 1;
 508
 509   // Winsock 2 has WSARecv and can do this directly, but Winsock 1 needs
 510   // to do the recvs piece-by-piece.
 511
 512 # if (ACE_HAS_WINSOCK2 != 0)
 513   DWORD flags = 0;
 514   result = ::WSARecv ((SOCKET) handle,
 515                       (WSABUF *) buffers,
 516                       n,
 517                       &bytes_received,
 518                       &flags,
 519                       0,
 520                       0);
 521 # else
 522   // Step through the buffers requested by caller; for each one, cycle
 523   // through reads until it's filled or an error occurs.
 524   for (int i = 0; i < n && result > 0; ++i)
 525     {
 526       char *chunkp = buffers[i].iov_base;     // Point to part of chunk being read
 527       int chunklen = buffers[i].iov_len;    // Track how much to read to chunk
 528       while (chunklen > 0 && result > 0)
 529         {
 530           result = ::recv ((SOCKET) handle, chunkp, chunklen, 0);
 531           if (result > 0)
 532             {
 533               chunkp += result;
 534               chunklen -= result;
 535               bytes_received += result;
 536             }
 537         }
 538     }
 539 # endif /* ACE_HAS_WINSOCK2 != 0 */
 540
 541   if (result == SOCKET_ERROR)
 542     {
 543       ACE_OS::set_errno_to_wsa_last_error ();
 544       return -1;
 545     }
 546   else
 547     return (ssize_t) bytes_received;
 548 #else
 549   return ACE_OS::readv (handle, buffers, n);
 550 #endif /* ACE_HAS_WINSOCK2 */
 551 }
 552
 553 ACE_INLINE ssize_t
 554 ACE_OS::send (ACE_HANDLE handle, const char *buf, size_t len, int flags)
 555 {
 556   ACE_OS_TRACE ("ACE_OS::send");
 557
 558   // On UNIX, a non-blocking socket with no data to receive, this
 559   // system call will return EWOULDBLOCK or EAGAIN, depending on the
 560   // platform.  UNIX 98 allows either errno, and they may be the same
 561   // numeric value.  So to make life easier for upper ACE layers as
 562   // well as application programmers, always change EAGAIN to
 563   // EWOULDBLOCK.  Rather than hack the ACE_OSCALL_RETURN macro, it's
 564   // handled explicitly here.  If the ACE_OSCALL macro ever changes,
 565   // this function needs to be reviewed.  On Win32, the regular macros
 566   // can be used, as this is not an issue.
 567 #if defined (ACE_LACKS_SEND)
 568   ACE_UNUSED_ARG (handle);
 569   ACE_UNUSED_ARG (buf);
 570   ACE_UNUSED_ARG (len);
 571   ACE_UNUSED_ARG (flags);
 572   ACE_NOTSUP_RETURN (-1);
 573 #elif defined (ACE_WIN32)
 574   ssize_t result = ::send ((ACE_SOCKET) handle,
 575                            buf,
 576                            static_cast<int> (len),
 577                            flags);
 578   if (result == -1)
 579     {
 580       ACE_OS::set_errno_to_wsa_last_error();
 581       if (errno != ENOBUFS)
 582         return -1;
 583
 584       ACE_SOCKCALL_RETURN(send_partial_i(handle, buf, len, flags), ssize_t, -1);
 585     }
 586   else
 587     return result;
 588
 589 #else
 590 # if defined (ACE_MQX)
 591   ssize_t const ace_result_ = ::send ((ACE_SOCKET) handle, (void*)buf, len, flags);
 592 #else
 593   ssize_t const ace_result_ = ::send ((ACE_SOCKET) handle, buf, len, flags);
 594 #endif
 595
 596 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
 597   // Optimize this code out if we can detect that EAGAIN ==
 598   // EWOULDBLOCK at compile time.  If we cannot detect equality at
 599   // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor
 600   // macros) perform the check at run-time.  The goal is to avoid two
 601   // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK.
 602   if (ace_result_ == -1
 603 #  if !defined (EAGAIN) || !defined (EWOULDBLOCK)
 604       && EAGAIN != EWOULDBLOCK
 605 #  endif  /* !EAGAIN || !EWOULDBLOCK */
 606       && errno == EAGAIN)
 607     {
 608       errno = EWOULDBLOCK;
 609     }
 610 # endif /* EAGAIN != EWOULDBLOCK*/
 611
 612   return ace_result_;
 613 #endif /* defined (ACE_WIN32) */
 614 }
 615
 616 ACE_INLINE ssize_t
 617 ACE_OS::sendmsg (ACE_HANDLE handle,
 618                  const struct msghdr *msg,
 619                  int flags)
 620 {
 621   ACE_OS_TRACE ("ACE_OS::sendmsg");
 622 #if !defined (ACE_LACKS_SENDMSG)
 623 # if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
 624   DWORD bytes_sent = 0;
 625   int const result = msg->msg_control
 626     ? sendmsg_win32_i (handle, msg, flags, bytes_sent)
 627     : ::WSASendTo ((SOCKET) handle,
 628                    (WSABUF *) msg->msg_iov,
 629                    msg->msg_iovlen,
 630                    &bytes_sent,
 631                    flags,
 632                    msg->msg_name,
 633                    msg->msg_namelen,
 634                    0,
 635                    0);
 636
 637   if (result != 0)
 638     {
 639       ACE_OS::set_errno_to_wsa_last_error ();
 640       return -1;
 641     }
 642   else
 643     return (ssize_t) bytes_sent;
 644 # elif defined (ACE_HAS_NONCONST_SENDMSG)
 645   ACE_SOCKCALL_RETURN (::sendmsg (handle,
 646                                   const_cast<struct msghdr *>(msg),
 647                                   flags), ssize_t, -1);
 648 # else
 649   ACE_SOCKCALL_RETURN (::sendmsg (handle, msg, flags), ssize_t, -1);
 650 # endif
 651 #else
 652   ACE_UNUSED_ARG (flags);
 653   ACE_UNUSED_ARG (msg);
 654   ACE_UNUSED_ARG (handle);
 655
 656   ACE_NOTSUP_RETURN (-1);
 657 #endif /* ACE_LACKS_SENDMSG */
 658 }
 659
 660 ACE_INLINE ssize_t
 661 ACE_OS::sendto (ACE_HANDLE handle,
 662                 const char *buf,
 663                 size_t len,
 664                 int flags,
 665                 const struct sockaddr *addr,
 666                 int addrlen)
 667 {
 668   ACE_OS_TRACE ("ACE_OS::sendto");
 669 #if defined (ACE_LACKS_SENDTO)
 670   ACE_UNUSED_ARG (handle);
 671   ACE_UNUSED_ARG (buf);
 672   ACE_UNUSED_ARG (len);
 673   ACE_UNUSED_ARG (flags);
 674   ACE_UNUSED_ARG (addr);
 675   ACE_UNUSED_ARG (addrlen);
 676   ACE_NOTSUP_RETURN (-1);
 677 #elif defined (ACE_VXWORKS)
 678   ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle,
 679                                  const_cast <char *> (buf),
 680                                  len,
 681                                  flags,
 682                                  const_cast<struct sockaddr *> (addr),
 683                                  addrlen),
 684                        ssize_t, -1);
 685 #elif defined (ACE_WIN32)
 686   ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle,
 687                                  buf,
 688                                  static_cast<int> (len),
 689                                  flags,
 690                                  const_cast<struct sockaddr *> (addr),
 691                                  addrlen),
 692                        ssize_t, -1);
 693 #elif defined (ACE_MQX)
 694   ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle,
 695                                  (void*)buf,
 696                                  len,
 697                                  flags,
 698                                  const_cast<struct sockaddr *> (addr),
 699                                  addrlen),
 700                        ssize_t, -1);
 701 #else
 702   ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle,
 703                                  buf,
 704                                  len,
 705                                  flags,
 706                                  const_cast<struct sockaddr *> (addr),
 707                                  addrlen),
 708                        ssize_t, -1);
 709 #endif /* ACE_LACKS_SENDTO */
 710 }
 711
 712 ACE_INLINE ssize_t
 713 ACE_OS::sendto (ACE_HANDLE handle,
 714                 const iovec *buffers,
 715                 int buffer_count,
 716                 size_t &number_of_bytes_sent,
 717                 int flags,
 718                 const struct sockaddr *addr,
 719                 int addrlen,
 720                 ACE_OVERLAPPED *overlapped,
 721                 ACE_OVERLAPPED_COMPLETION_FUNC func)
 722 {
 723   ACE_OS_TRACE ("ACE_OS::sendto");
 724 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
 725   DWORD bytes_sent = 0;
 726   int result = ::WSASendTo ((SOCKET) handle,
 727                             (WSABUF*) buffers,
 728                             buffer_count,
 729                             &bytes_sent,
 730                             flags,
 731                             addr,
 732                             addrlen,
 733                             overlapped,
 734                             func);
 735   if (result != 0) {
 736     ACE_OS::set_errno_to_wsa_last_error ();
 737   }
 738   number_of_bytes_sent = static_cast<size_t> (bytes_sent);
 739   return (ssize_t) result;
 740 #else
 741   ACE_UNUSED_ARG (overlapped);
 742   ACE_UNUSED_ARG (func);
 743
 744   number_of_bytes_sent = 0;
 745
 746   ssize_t result = 0;
 747
 748   for (int i = 0; i < buffer_count; ++i)
 749     {
 750        result = ACE_OS::sendto (handle,
 751                                 reinterpret_cast<char *> (
 752                                                  buffers[i].iov_base),
 753                                 buffers[i].iov_len,
 754                                 flags,
 755                                 addr,
 756                                 addrlen);
 757        if (result == -1)
 758          break;
 759        number_of_bytes_sent += static_cast<size_t> (result);
 760     }
 761
 762   return result;
 763 #endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */
 764 }
 765
 766 ACE_INLINE ssize_t
 767 ACE_OS::sendv (ACE_HANDLE handle,
 768                const iovec *buffers,
 769                int n)
 770 {
 771 #if defined (ACE_HAS_WINSOCK2)
 772   DWORD bytes_sent = 0;
 773   ssize_t result = 0;
 774
 775   // Winsock 2 has WSASend and can do this directly, but Winsock 1
 776   // needs to do the sends one-by-one.
 777 # if (ACE_HAS_WINSOCK2 != 0) && !defined (ACE_DONT_USE_WSASEND)
 778   result = ::WSASend ((SOCKET) handle,
 779                       (WSABUF *) buffers,
 780                       n,
 781                       &bytes_sent,
 782                       0,
 783                       0,
 784                       0);
 785   if (result == SOCKET_ERROR)
 786     {
 787       ACE_OS::set_errno_to_wsa_last_error ();
 788       if ((errno != ENOBUFS) ||
 789           (bytes_sent != 0))
 790         {
 791           return -1;
 792         }
 793       result = sendv_partial_i(handle, buffers, n);
 794       if (result == SOCKET_ERROR)
 795         {
 796           ACE_OS::set_errno_to_wsa_last_error ();
 797           return -1;
 798         }
 799       bytes_sent = static_cast<DWORD>(result);
 800     }
 801 # else
 802   for (int i = 0; i < n; ++i)
 803     {
 804       result = ::send ((SOCKET) handle,
 805                        buffers[i].iov_base,
 806                        buffers[i].iov_len,
 807                        0);
 808
 809       if (result == SOCKET_ERROR)
 810         {
 811           // There is a subtle difference in behaviour depending on
 812           // whether or not any data was sent.  If no data was sent,
 813           // then always return -1.  Otherwise return bytes_sent.
 814           // This gives the caller an opportunity to keep track of
 815           // bytes that have already been sent.
 816           if (bytes_sent > 0)
 817             break;
 818           else
 819             {
 820               ACE_OS::set_errno_to_wsa_last_error ();
 821               return -1;
 822             }
 823         }
 824       else
 825         {
 826           // Gets ignored on error anyway
 827           bytes_sent += result;
 828
 829           // If the transfer isn't complete just drop out of the loop.
 830           if (result < (int)buffers[i].iov_len)
 831             break;
 832         }
 833     }
 834 # endif /* ACE_HAS_WINSOCK2 != 0 */
 835
 836   return (ssize_t) bytes_sent;
 837
 838 #elif defined (ACE_MQX)
 839   ssize_t bytes_sent = 0;
 840   for (int i = 0; i < n; ++i)
 841     {
 842       ssize_t result = ACE_OS::send (handle, buffers[i].iov_base,
 843                                      buffers[i].iov_len, 0);
 844
 845       if (result == -1)
 846         {
 847           // There is a subtle difference in behaviour depending on
 848           // whether or not any data was sent.  If no data was sent,
 849           // then always return -1.  Otherwise return bytes_sent.
 850           // This gives the caller an opportunity to keep track of
 851           // bytes that have already been sent.
 852           if (bytes_sent > 0)
 853             break;
 854           else
 855             {
 856               // errno should already be set from the ACE_OS::send call.
 857               return -1;
 858             }
 859         }
 860       else
 861         {
 862           // Gets ignored on error anyway
 863           bytes_sent += result;
 864
 865           // If the transfer isn't complete just drop out of the loop.
 866           if (result < buffers[i].iov_len)
 867             break;
 868         }
 869     }
 870
 871   return bytes_sent;
 872 #elif defined (ACE_HAS_SOCK_BUF_SIZE_MAX)
 873
 874   // Platform limits the maximum socket message size.  Pare down the
 875   // iovec, if necessary, to obey the limit.
 876   iovec local_iov[ACE_IOV_MAX];
 877   long total = 0;
 878   long new_total = 0;
 879   for (int i = 0; i < n; i++)
 880     {
 881       local_iov[i].iov_base = buffers[i].iov_base;
 882       local_iov[i].iov_len  = buffers[i].iov_len;
 883
 884       new_total = total + buffers[i].iov_len;
 885       if (new_total >= ACE_HAS_SOCK_BUF_SIZE_MAX_VALUE)
 886         {
 887           local_iov[i].iov_len = ACE_HAS_SOCK_BUF_SIZE_MAX_VALUE - total;
 888           n = i+1;
 889           break;
 890         }
 891       total = new_total;
 892     }
 893   return ACE_OS::writev (handle, local_iov, n);
 894
 895 #else
 896   return ACE_OS::writev (handle, buffers, n);
 897 #endif /* ACE_HAS_WINSOCK2 */
 898 }
 899
 900 ACE_INLINE int
 901 ACE_OS::setsockopt (ACE_HANDLE handle,
 902                     int level,
 903                     int optname,
 904                     const char *optval,
 905                     int optlen)
 906 {
 907   ACE_OS_TRACE ("ACE_OS::setsockopt");
 908 #if defined (ACE_LACKS_SETSOCKOPT)
 909   ACE_UNUSED_ARG (handle);
 910   ACE_UNUSED_ARG (level);
 911   ACE_UNUSED_ARG (optname);
 912   ACE_UNUSED_ARG (optval);
 913   ACE_UNUSED_ARG (optlen);
 914   ACE_NOTSUP_RETURN (-1);
 915 #else
 916   int result;
 917   ACE_SOCKCALL (::setsockopt ((ACE_SOCKET) handle,
 918                               level,
 919                               optname,
 920                               (ACE_SOCKOPT_TYPE1) optval,
 921                               optlen),
 922                 int,
 923                 -1,
 924                 result);
 925 #if defined (WSAEOPNOTSUPP)
 926   if (result == -1 && (errno == WSAEOPNOTSUPP || errno == WSAENOPROTOOPT))
 927 #else
 928   if (result == -1)
 929 #endif /* WSAEOPNOTSUPP */
 930     errno = ENOTSUP;
 931   return result;
 932 #endif
 933 }
 934
 935 ACE_INLINE int
 936 ACE_OS::shutdown (ACE_HANDLE handle, int how)
 937 {
 938   ACE_OS_TRACE ("ACE_OS::shutdown");
 939 #if defined (ACE_LACKS_SHUTDOWN)
 940   ACE_UNUSED_ARG (handle);
 941   ACE_UNUSED_ARG (how);
 942   ACE_NOTSUP_RETURN (-1);
 943 #else
 944   ACE_SOCKCALL_RETURN (::shutdown ((ACE_SOCKET) handle, how), int, -1);
 945 #endif /* ACE_LACKS_SHUTDOWN */
 946 }
 947
 948 ACE_INLINE ACE_HANDLE
 949 ACE_OS::socket (int domain,
 950                 int type,
 951                 int proto)
 952 {
 953   ACE_OS_TRACE ("ACE_OS::socket");
 954 #if defined (ACE_LACKS_SOCKET)
 955   ACE_UNUSED_ARG (domain);
 956   ACE_UNUSED_ARG (type);
 957   ACE_UNUSED_ARG (proto);
 958   ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
 959 #else
 960   ACE_SOCKCALL_RETURN (::socket (domain,
 961                                  type,
 962                                  proto),
 963                        ACE_HANDLE,
 964                        ACE_INVALID_HANDLE);
 965 #endif /* ACE_LACKS_SOCKET */
 966 }
 967
 968 ACE_INLINE ACE_HANDLE
 969 ACE_OS::socket (int domain,
 970                 int type,
 971                 int proto,
 972                 ACE_Protocol_Info *protocolinfo,
 973                 ACE_SOCK_GROUP g,
 974                 u_long flags)
 975 {
 976   ACE_OS_TRACE ("ACE_OS::socket");
 977
 978 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
 979   ACE_SOCKCALL_RETURN (::WSASocket (domain,
 980                                     type,
 981                                     proto,
 982                                     protocolinfo,
 983                                     g,
 984                                     flags),
 985                        ACE_HANDLE,
 986                        ACE_INVALID_HANDLE);
 987 #else
 988   ACE_UNUSED_ARG (protocolinfo);
 989   ACE_UNUSED_ARG (g);
 990   ACE_UNUSED_ARG (flags);
 991
 992   return ACE_OS::socket (domain,
 993                          type,
 994                          proto);
 995 #endif /* ACE_HAS_WINSOCK2 */
 996 }
 997
 998 ACE_INLINE int
 999 ACE_OS::socketpair (int domain, int type,
1000                     int protocol, ACE_HANDLE sv[2])
1001 {
1002   ACE_OS_TRACE ("ACE_OS::socketpair");
1003 #if defined (ACE_LACKS_SOCKETPAIR)
1004   ACE_UNUSED_ARG (domain);
1005   ACE_UNUSED_ARG (type);
1006   ACE_UNUSED_ARG (protocol);
1007   ACE_UNUSED_ARG (sv);
1008
1009   ACE_NOTSUP_RETURN (-1);
1010 #else
1011   return ::socketpair (domain, type, protocol, sv);
1012 #endif /* ACE_LACKS_SOCKETPAIR */
1013 }
1014
1015 ACE_INLINE unsigned int
1016 ACE_OS::if_nametoindex (const char *ifname)
1017 {
1018   ACE_OS_TRACE ("ACE_OS::if_nametoindex");
1019 #ifdef ACE_LACKS_IF_NAMETOINDEX
1020   ACE_UNUSED_ARG (ifname);
1021   ACE_NOTSUP_RETURN (0);
1022 #else
1023   return ::if_nametoindex (ifname);
1024 #endif /* ACE_LACKS_IF_NAMETOINDEX */
1025 }
1026
1027 ACE_INLINE char *
1028 ACE_OS::if_indextoname (unsigned int ifindex, char *ifname)
1029 {
1030   ACE_OS_TRACE ("ACE_OS::if_indextoname");
1031 #ifdef ACE_LACKS_IF_NAMETOINDEX
1032   ACE_UNUSED_ARG (ifindex);
1033   ACE_UNUSED_ARG (ifname);
1034   ACE_NOTSUP_RETURN (0);
1035 #else
1036   return ::if_indextoname (ifindex, ifname);
1037 #endif /* ACE_LACKS_IF_NAMETOINDEX */
1038 }
1039
1040 ACE_INLINE struct if_nameindex *
1041 ACE_OS::if_nameindex ()
1042 {
1043   ACE_OS_TRACE ("ACE_OS::if_nameindex");
1044 #ifdef ACE_LACKS_IF_NAMEINDEX
1045   ACE_NOTSUP_RETURN (0);
1046 #else
1047   return ::if_nameindex ();
1048 #endif /* ACE_LACKS_IF_NAMEINDEX */
1049 }
1050
1051 ACE_INLINE void
1052 ACE_OS::if_freenameindex (struct if_nameindex *ptr)
1053 {
1054   ACE_OS_TRACE ("ACE_OS::if_freenameindex");
1055 #ifdef ACE_LACKS_IF_NAMEINDEX
1056   ACE_UNUSED_ARG (ptr);
1057 #else
1058   if (ptr)
1059   {
1060     ::if_freenameindex (ptr);
1061   }
1062 #endif /* ACE_LACKS_IF_NAMEINDEX */
1063 }
1064
1065 ACE_END_VERSIONED_NAMESPACE_DECL