00001
00002
00003
00004
00005 #include "ace/OS_NS_errno.h"
00006 #include "ace/OS_NS_macros.h"
00007 #include "ace/OS_NS_sys_uio.h"
00008 #include "ace/OS_NS_stdio.h"
00009 #include "ace/OS_QoS.h"
00010 #include "ace/Global_Macros.h"
00011 #include "ace/os_include/netinet/os_in.h"
00012
00013 #if defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \
00014 && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1)
00015 #include "ace/OS_NS_string.h"
00016 #endif
00017
00018 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00019
00020 #if defined (ACE_HAS_VOIDPTR_SOCKOPT)
00021 typedef void *ACE_SOCKOPT_TYPE1;
00022 #elif defined (ACE_HAS_CHARPTR_SOCKOPT)
00023 typedef char *ACE_SOCKOPT_TYPE1;
00024 #else
00025 typedef const char *ACE_SOCKOPT_TYPE1;
00026 #endif
00027
00028 ACE_INLINE ACE_HANDLE
00029 ACE_OS::accept (ACE_HANDLE handle,
00030 struct sockaddr *addr,
00031 int *addrlen)
00032 {
00033 ACE_OS_TRACE ("ACE_OS::accept");
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044 #if defined (ACE_LACKS_ACCEPT)
00045 ACE_UNUSED_ARG (handle);
00046 ACE_UNUSED_ARG (addr);
00047 ACE_UNUSED_ARG (addrlen);
00048 ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
00049 #elif defined (ACE_WIN32)
00050 ACE_SOCKCALL_RETURN (::accept ((ACE_SOCKET) handle,
00051 addr,
00052 (ACE_SOCKET_LEN *) addrlen),
00053 ACE_HANDLE,
00054 ACE_INVALID_HANDLE);
00055 #else
00056 # if defined (ACE_HAS_BROKEN_ACCEPT_ADDR)
00057
00058
00059
00060 sockaddr_in fake_addr;
00061 int fake_addrlen;
00062
00063 if (addrlen == 0)
00064 addrlen = &fake_addrlen;
00065
00066 if (addr == 0)
00067 {
00068 addr = (sockaddr *) &fake_addr;
00069 *addrlen = sizeof fake_addr;
00070 }
00071 # endif
00072 ACE_HANDLE ace_result = ::accept ((ACE_SOCKET) handle,
00073 addr,
00074 (ACE_SOCKET_LEN *) addrlen);
00075
00076 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
00077
00078
00079
00080
00081
00082 if (ace_result == ACE_INVALID_HANDLE
00083 # if !defined (EAGAIN) || !defined (EWOULDBLOCK)
00084 && EAGAIN != EWOULDBLOCK
00085 # endif
00086 && errno == EAGAIN)
00087 {
00088 errno = EWOULDBLOCK;
00089 }
00090 # endif
00091
00092 return ace_result;
00093
00094 #endif
00095 }
00096
00097 ACE_INLINE int
00098 ACE_OS::bind (ACE_HANDLE handle, struct sockaddr *addr, int addrlen)
00099 {
00100 ACE_OS_TRACE ("ACE_OS::bind");
00101 #if defined (ACE_LACKS_BIND)
00102 ACE_UNUSED_ARG (handle);
00103 ACE_UNUSED_ARG (addr);
00104 ACE_UNUSED_ARG (addrlen);
00105 ACE_NOTSUP_RETURN (-1);
00106 #elif defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x640)
00107
00108
00109
00110
00111 int result;
00112 ACE_SOCKCALL (::bind ((ACE_SOCKET) handle,
00113 addr,
00114 (ACE_SOCKET_LEN) addrlen), int, -1, result);
00115 if (result == -1)
00116 return -1;
00117 else
00118 return ACE_OS::getsockname (handle, addr, &addrlen);
00119 #else
00120 ACE_SOCKCALL_RETURN (::bind ((ACE_SOCKET) handle,
00121 addr,
00122 (ACE_SOCKET_LEN) addrlen), int, -1);
00123 #endif
00124 }
00125
00126 ACE_INLINE int
00127 ACE_OS::closesocket (ACE_HANDLE handle)
00128 {
00129 ACE_OS_TRACE ("ACE_OS::closesocket");
00130 #if defined (ACE_WIN32)
00131
00132
00133
00134
00135
00136 ACE_SOCKCALL_RETURN (::closesocket ((SOCKET) handle), int, -1);
00137 #else
00138
00139 ACE_OSCALL_RETURN (::close (handle), int, -1);
00140
00141 #endif
00142 }
00143
00144 ACE_INLINE int
00145 ACE_OS::connect (ACE_HANDLE handle,
00146 struct sockaddr *addr,
00147 int addrlen)
00148 {
00149 ACE_OS_TRACE ("ACE_OS::connect");
00150 #if defined (ACE_LACKS_CONNECT)
00151 ACE_UNUSED_ARG (handle);
00152 ACE_UNUSED_ARG (addr);
00153 ACE_UNUSED_ARG (addrlen);
00154 ACE_NOTSUP_RETURN (-1);
00155 #else
00156 ACE_SOCKCALL_RETURN (::connect ((ACE_SOCKET) handle,
00157 addr,
00158 (ACE_SOCKET_LEN) addrlen), int, -1);
00159 #endif
00160 }
00161
00162 ACE_INLINE int
00163 ACE_OS::enum_protocols (int *protocols,
00164 ACE_Protocol_Info *protocol_buffer,
00165 u_long *buffer_length)
00166 {
00167 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
00168
00169 ACE_SOCKCALL_RETURN (::WSAEnumProtocols (protocols,
00170 protocol_buffer,
00171 buffer_length),
00172 int,
00173 SOCKET_ERROR);
00174
00175 #else
00176 ACE_UNUSED_ARG (protocols);
00177 ACE_UNUSED_ARG (protocol_buffer);
00178 ACE_UNUSED_ARG (buffer_length);
00179 ACE_NOTSUP_RETURN (-1);
00180 #endif
00181 }
00182
00183 ACE_INLINE int
00184 ACE_OS::getpeername (ACE_HANDLE handle, struct sockaddr *addr,
00185 int *addrlen)
00186 {
00187 ACE_OS_TRACE ("ACE_OS::getpeername");
00188
00189 #if defined (ACE_LACKS_GETPEERNAME)
00190 ACE_UNUSED_ARG (handle);
00191 ACE_UNUSED_ARG (addr);
00192 ACE_UNUSED_ARG (addrlen);
00193 ACE_NOTSUP_RETURN (-1);
00194 #elif defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \
00195 && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1)
00196 int result;
00197 ACE_SOCKCALL (::getpeername ((ACE_SOCKET) handle,
00198 addr,
00199 (ACE_SOCKET_LEN *) addrlen),
00200 int,
00201 -1,
00202 result);
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214 if (result != -1 && addr->sa_family == AF_INET)
00215 {
00216 ACE_OS::memset (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero,
00217 0,
00218 sizeof (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero));
00219 }
00220
00221 return result;
00222 #else
00223 ACE_SOCKCALL_RETURN (::getpeername ((ACE_SOCKET) handle,
00224 addr,
00225 (ACE_SOCKET_LEN *) addrlen),
00226 int,
00227 -1);
00228 #endif
00229 }
00230
00231 ACE_INLINE int
00232 ACE_OS::getsockname (ACE_HANDLE handle,
00233 struct sockaddr *addr,
00234 int *addrlen)
00235 {
00236 ACE_OS_TRACE ("ACE_OS::getsockname");
00237 #if defined (ACE_LACKS_GETSOCKNAME)
00238 ACE_UNUSED_ARG (handle);
00239 ACE_UNUSED_ARG (addr);
00240 ACE_UNUSED_ARG (addrlen);
00241 ACE_NOTSUP_RETURN (-1);
00242 #elif defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \
00243 && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1)
00244 int result;
00245 ACE_SOCKCALL (::getsockname ((ACE_SOCKET) handle,
00246 addr,
00247 (ACE_SOCKET_LEN *) addrlen),
00248 int, -1, result);
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260 if (result != -1 && addr->sa_family == AF_INET)
00261 {
00262 ACE_OS::memset (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero,
00263 0,
00264 sizeof (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero));
00265 }
00266
00267 return result;
00268 #else
00269 ACE_SOCKCALL_RETURN (::getsockname ((ACE_SOCKET) handle,
00270 addr,
00271 (ACE_SOCKET_LEN *) addrlen),
00272 int, -1);
00273 #endif
00274 }
00275
00276 ACE_INLINE int
00277 ACE_OS::getsockopt (ACE_HANDLE handle,
00278 int level,
00279 int optname,
00280 char *optval,
00281 int *optlen)
00282 {
00283 ACE_OS_TRACE ("ACE_OS::getsockopt");
00284 #if defined (ACE_LACKS_GETSOCKOPT)
00285 ACE_UNUSED_ARG (handle);
00286 ACE_UNUSED_ARG (level);
00287 ACE_UNUSED_ARG (optname);
00288 ACE_UNUSED_ARG (optval);
00289 ACE_UNUSED_ARG (optlen);
00290 ACE_NOTSUP_RETURN (-1);
00291 #else
00292 ACE_SOCKCALL_RETURN (::getsockopt ((ACE_SOCKET) handle,
00293 level,
00294 optname,
00295 optval,
00296 (ACE_SOCKET_LEN *) optlen),
00297 int,
00298 -1);
00299 #endif
00300 }
00301
00302 ACE_INLINE int
00303 ACE_OS::listen (ACE_HANDLE handle, int backlog)
00304 {
00305 ACE_OS_TRACE ("ACE_OS::listen");
00306 #if defined (ACE_LACKS_LISTEN)
00307 ACE_UNUSED_ARG (handle);
00308 ACE_UNUSED_ARG (backlog);
00309 ACE_NOTSUP_RETURN (-1);
00310 #else
00311 ACE_SOCKCALL_RETURN (::listen ((ACE_SOCKET) handle, backlog), int, -1);
00312 #endif
00313 }
00314
00315 ACE_INLINE ssize_t
00316 ACE_OS::recv (ACE_HANDLE handle, char *buf, size_t len, int flags)
00317 {
00318 ACE_OS_TRACE ("ACE_OS::recv");
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329 #if defined (ACE_LACKS_RECV)
00330 ACE_UNUSED_ARG (handle);
00331 ACE_UNUSED_ARG (buf);
00332 ACE_UNUSED_ARG (len);
00333 ACE_UNUSED_ARG (flags);
00334 ACE_NOTSUP_RETURN (-1);
00335 #elif defined (ACE_WIN32)
00336 ACE_SOCKCALL_RETURN (::recv ((ACE_SOCKET) handle, buf,
00337 static_cast<int> (len), flags), ssize_t, -1);
00338 #else
00339 ssize_t ace_result_;
00340 ace_result_ = ::recv ((ACE_SOCKET) handle, buf, len, flags);
00341
00342 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
00343
00344
00345
00346
00347
00348 if (ace_result_ == -1
00349 # if !defined (EAGAIN) || !defined (EWOULDBLOCK)
00350 && EAGAIN != EWOULDBLOCK
00351 # endif
00352 && errno == EAGAIN)
00353 {
00354 errno = EWOULDBLOCK;
00355 }
00356 # endif
00357
00358 return ace_result_;
00359 #endif
00360 }
00361
00362 ACE_INLINE ssize_t
00363 ACE_OS::recvfrom (ACE_HANDLE handle,
00364 char *buf,
00365 size_t len,
00366 int flags,
00367 struct sockaddr *addr,
00368 int *addrlen)
00369 {
00370 ACE_OS_TRACE ("ACE_OS::recvfrom");
00371 #if defined (ACE_LACKS_RECVFROM)
00372 ACE_UNUSED_ARG (handle);
00373 ACE_UNUSED_ARG (buf);
00374 ACE_UNUSED_ARG (len);
00375 ACE_UNUSED_ARG (flags);
00376 ACE_UNUSED_ARG (addr);
00377 ACE_UNUSED_ARG (addrlen);
00378 ACE_NOTSUP_RETURN (-1);
00379 #elif defined (ACE_WIN32)
00380 int const shortened_len = static_cast<int> (len);
00381 int const result = ::recvfrom ((ACE_SOCKET) handle,
00382 buf,
00383 shortened_len,
00384 flags,
00385 addr,
00386 (ACE_SOCKET_LEN *) addrlen);
00387 if (result == SOCKET_ERROR)
00388 {
00389 ACE_OS::set_errno_to_wsa_last_error ();
00390 if (errno == WSAEMSGSIZE &&
00391 ACE_BIT_ENABLED (flags, MSG_PEEK))
00392 return shortened_len;
00393 else
00394 return -1;
00395 }
00396 else
00397 {
00398 # if defined (ACE_HAS_PHARLAP)
00399
00400
00401 if (addrlen != 0 && addr != 0 &&
00402 *addrlen == 8 && addr->sa_family == AF_INET)
00403 *addrlen = sizeof(sockaddr_in);
00404 # endif
00405 return result;
00406 }
00407 #else
00408 ACE_SOCKCALL_RETURN (::recvfrom ((ACE_SOCKET) handle,
00409 buf,
00410 len,
00411 flags,
00412 addr,
00413 (ACE_SOCKET_LEN *) addrlen),
00414 ssize_t, -1);
00415 #endif
00416 }
00417
00418 ACE_INLINE ssize_t
00419 ACE_OS::recvfrom (ACE_HANDLE handle,
00420 iovec *buffers,
00421 int buffer_count,
00422 size_t &number_of_bytes_recvd,
00423 int &flags,
00424 struct sockaddr *addr,
00425 int *addrlen,
00426 ACE_OVERLAPPED *overlapped,
00427 ACE_OVERLAPPED_COMPLETION_FUNC func)
00428 {
00429 ACE_OS_TRACE ("ACE_OS::recvfrom");
00430
00431 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
00432 DWORD bytes_recvd;
00433 DWORD the_flags = flags;
00434 int result = ::WSARecvFrom ((SOCKET) handle,
00435 (WSABUF*)buffers,
00436 buffer_count,
00437 &bytes_recvd,
00438 &the_flags,
00439 addr,
00440 addrlen,
00441 overlapped,
00442 func);
00443 if (result != 0) {
00444 ACE_OS::set_errno_to_wsa_last_error ();
00445 }
00446 flags = the_flags;
00447 number_of_bytes_recvd = static_cast<size_t> (bytes_recvd);
00448 return result;
00449 #else
00450 ACE_UNUSED_ARG (handle);
00451 ACE_UNUSED_ARG (buffers);
00452 ACE_UNUSED_ARG (buffer_count);
00453 ACE_UNUSED_ARG (number_of_bytes_recvd);
00454 ACE_UNUSED_ARG (flags);
00455 ACE_UNUSED_ARG (addr);
00456 ACE_UNUSED_ARG (addrlen);
00457 ACE_UNUSED_ARG (overlapped);
00458 ACE_UNUSED_ARG (func);
00459 ACE_NOTSUP_RETURN (-1);
00460 #endif
00461 }
00462
00463 ACE_INLINE ssize_t
00464 ACE_OS::recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags)
00465 {
00466 ACE_OS_TRACE ("ACE_OS::recvmsg");
00467 #if !defined (ACE_LACKS_RECVMSG)
00468 # if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
00469 DWORD bytes_received = 0;
00470
00471 int result = ::WSARecvFrom ((SOCKET) handle,
00472 (WSABUF *) msg->msg_iov,
00473 msg->msg_iovlen,
00474 &bytes_received,
00475 (DWORD *) &flags,
00476 msg->msg_name,
00477 &msg->msg_namelen,
00478 0,
00479 0);
00480
00481 if (result != 0)
00482 {
00483 ACE_OS::set_errno_to_wsa_last_error ();
00484 return -1;
00485 }
00486 else
00487 return bytes_received;
00488 # else
00489 ACE_SOCKCALL_RETURN (::recvmsg (handle, msg, flags), ssize_t, -1);
00490 # endif
00491 #else
00492 ACE_UNUSED_ARG (flags);
00493 ACE_UNUSED_ARG (msg);
00494 ACE_UNUSED_ARG (handle);
00495
00496 ACE_NOTSUP_RETURN (-1);
00497 #endif
00498 }
00499
00500 ACE_INLINE ssize_t
00501 ACE_OS::recvv (ACE_HANDLE handle,
00502 iovec *buffers,
00503 int n)
00504 {
00505 #if defined (ACE_HAS_WINSOCK2)
00506
00507 DWORD bytes_received = 0;
00508 int result = 1;
00509
00510
00511
00512
00513 # if (ACE_HAS_WINSOCK2 != 0)
00514 DWORD flags = 0;
00515 result = ::WSARecv ((SOCKET) handle,
00516 (WSABUF *) buffers,
00517 n,
00518 &bytes_received,
00519 &flags,
00520 0,
00521 0);
00522 # else
00523
00524
00525 for (int i = 0; i < n && result > 0; ++i)
00526 {
00527 char *chunkp = buffers[i].iov_base;
00528 int chunklen = buffers[i].iov_len;
00529 while (chunklen > 0 && result > 0)
00530 {
00531 result = ::recv ((SOCKET) handle, chunkp, chunklen, 0);
00532 if (result > 0)
00533 {
00534 chunkp += result;
00535 chunklen -= result;
00536 bytes_received += result;
00537 }
00538 }
00539 }
00540 # endif
00541
00542 if (result == SOCKET_ERROR)
00543 {
00544 ACE_OS::set_errno_to_wsa_last_error ();
00545 return -1;
00546 }
00547 else
00548 return (ssize_t) bytes_received;
00549 #else
00550 return ACE_OS::readv (handle, buffers, n);
00551 #endif
00552 }
00553
00554 ACE_INLINE ssize_t
00555 ACE_OS::send (ACE_HANDLE handle, const char *buf, size_t len, int flags)
00556 {
00557 ACE_OS_TRACE ("ACE_OS::send");
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568 #if defined (ACE_LACKS_SEND)
00569 ACE_UNUSED_ARG (handle);
00570 ACE_UNUSED_ARG (buf);
00571 ACE_UNUSED_ARG (len);
00572 ACE_UNUSED_ARG (flags);
00573 ACE_NOTSUP_RETURN (-1);
00574 #elif defined (ACE_WIN32)
00575 ACE_SOCKCALL_RETURN (::send ((ACE_SOCKET) handle,
00576 buf,
00577 static_cast<int> (len),
00578 flags), ssize_t, -1);
00579 #else
00580 ssize_t const ace_result_ = ::send ((ACE_SOCKET) handle, buf, len, flags);
00581
00582 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
00583
00584
00585
00586
00587
00588 if (ace_result_ == -1
00589 # if !defined (EAGAIN) || !defined (EWOULDBLOCK)
00590 && EAGAIN != EWOULDBLOCK
00591 # endif
00592 && errno == EAGAIN)
00593 {
00594 errno = EWOULDBLOCK;
00595 }
00596 # endif
00597
00598 return ace_result_;
00599 #endif
00600 }
00601
00602 ACE_INLINE ssize_t
00603 ACE_OS::sendmsg (ACE_HANDLE handle,
00604 const struct msghdr *msg,
00605 int flags)
00606 {
00607 ACE_OS_TRACE ("ACE_OS::sendmsg");
00608 #if !defined (ACE_LACKS_SENDMSG)
00609 # if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
00610 DWORD bytes_sent = 0;
00611 int result = ::WSASendTo ((SOCKET) handle,
00612 (WSABUF *) msg->msg_iov,
00613 msg->msg_iovlen,
00614 &bytes_sent,
00615 flags,
00616 msg->msg_name,
00617 msg->msg_namelen,
00618 0,
00619 0);
00620
00621 if (result != 0)
00622 {
00623 ACE_OS::set_errno_to_wsa_last_error ();
00624 return -1;
00625 }
00626 else
00627 return (ssize_t) bytes_sent;
00628 # elif defined (ACE_HAS_NONCONST_SENDMSG)
00629 ACE_SOCKCALL_RETURN (::sendmsg (handle,
00630 const_cast<struct msghdr *>(msg),
00631 flags), ssize_t, -1);
00632 # else
00633 ACE_SOCKCALL_RETURN (::sendmsg (handle, msg, flags), ssize_t, -1);
00634 # endif
00635 #else
00636 ACE_UNUSED_ARG (flags);
00637 ACE_UNUSED_ARG (msg);
00638 ACE_UNUSED_ARG (handle);
00639
00640 ACE_NOTSUP_RETURN (-1);
00641 #endif
00642 }
00643
00644 ACE_INLINE ssize_t
00645 ACE_OS::sendto (ACE_HANDLE handle,
00646 const char *buf,
00647 size_t len,
00648 int flags,
00649 const struct sockaddr *addr,
00650 int addrlen)
00651 {
00652 ACE_OS_TRACE ("ACE_OS::sendto");
00653 #if defined (ACE_LACKS_SENDTO)
00654 ACE_UNUSED_ARG (handle);
00655 ACE_UNUSED_ARG (buf);
00656 ACE_UNUSED_ARG (len);
00657 ACE_UNUSED_ARG (flags);
00658 ACE_UNUSED_ARG (addr);
00659 ACE_UNUSED_ARG (addrlen);
00660 ACE_NOTSUP_RETURN (-1);
00661 #elif defined (ACE_VXWORKS)
00662 ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle,
00663 const_cast <char *> (buf),
00664 len,
00665 flags,
00666 const_cast<struct sockaddr *> (addr),
00667 addrlen),
00668 ssize_t, -1);
00669 #elif defined (ACE_WIN32)
00670 ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle,
00671 buf,
00672 static_cast<int> (len),
00673 flags,
00674 const_cast<struct sockaddr *> (addr),
00675 addrlen),
00676 ssize_t, -1);
00677 #else
00678 ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle,
00679 buf,
00680 len,
00681 flags,
00682 const_cast<struct sockaddr *> (addr),
00683 addrlen),
00684 ssize_t, -1);
00685 #endif
00686 }
00687
00688 ACE_INLINE ssize_t
00689 ACE_OS::sendto (ACE_HANDLE handle,
00690 const iovec *buffers,
00691 int buffer_count,
00692 size_t &number_of_bytes_sent,
00693 int flags,
00694 const struct sockaddr *addr,
00695 int addrlen,
00696 ACE_OVERLAPPED *overlapped,
00697 ACE_OVERLAPPED_COMPLETION_FUNC func)
00698 {
00699 ACE_OS_TRACE ("ACE_OS::sendto");
00700 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
00701 DWORD bytes_sent = 0;
00702 int result = ::WSASendTo ((SOCKET) handle,
00703 (WSABUF*) buffers,
00704 buffer_count,
00705 &bytes_sent,
00706 flags,
00707 addr,
00708 addrlen,
00709 overlapped,
00710 func);
00711 if (result != 0) {
00712 ACE_OS::set_errno_to_wsa_last_error ();
00713 }
00714 number_of_bytes_sent = static_cast<size_t> (bytes_sent);
00715 return (ssize_t) result;
00716 #else
00717 ACE_UNUSED_ARG (overlapped);
00718 ACE_UNUSED_ARG (func);
00719
00720 number_of_bytes_sent = 0;
00721
00722 ssize_t result = 0;
00723
00724 for (int i = 0; i < buffer_count; ++i)
00725 {
00726 result = ACE_OS::sendto (handle,
00727 reinterpret_cast<char *> (
00728 buffers[i].iov_base),
00729 buffers[i].iov_len,
00730 flags,
00731 addr,
00732 addrlen);
00733 if (result == -1)
00734 break;
00735 number_of_bytes_sent += static_cast<size_t> (result);
00736 }
00737
00738 return result;
00739 #endif
00740 }
00741
00742 ACE_INLINE ssize_t
00743 ACE_OS::sendv (ACE_HANDLE handle,
00744 const iovec *buffers,
00745 int n)
00746 {
00747 #if defined (ACE_HAS_WINSOCK2)
00748 DWORD bytes_sent = 0;
00749 ssize_t result = 0;
00750
00751
00752
00753 # if (ACE_HAS_WINSOCK2 != 0) && !defined (ACE_DONT_USE_WSASEND)
00754 result = ::WSASend ((SOCKET) handle,
00755 (WSABUF *) buffers,
00756 n,
00757 &bytes_sent,
00758 0,
00759 0,
00760 0);
00761 if (result == SOCKET_ERROR)
00762 {
00763 ACE_OS::set_errno_to_wsa_last_error ();
00764 return -1;
00765 }
00766 # else
00767 for (int i = 0; i < n; ++i)
00768 {
00769 result = ::send ((SOCKET) handle,
00770 buffers[i].iov_base,
00771 buffers[i].iov_len,
00772 0);
00773
00774 if (result == SOCKET_ERROR)
00775 {
00776
00777
00778
00779
00780
00781 if (bytes_sent > 0)
00782 break;
00783 else
00784 {
00785 ACE_OS::set_errno_to_wsa_last_error ();
00786 return -1;
00787 }
00788 }
00789 else
00790 {
00791
00792 bytes_sent += result;
00793
00794
00795 if (result < (int)buffers[i].iov_len)
00796 break;
00797 }
00798 }
00799 # endif
00800
00801 return (ssize_t) bytes_sent;
00802
00803 #elif defined (ACE_HAS_SOCK_BUF_SIZE_MAX)
00804
00805
00806
00807 iovec local_iov[ACE_IOV_MAX];
00808 long total = 0;
00809 long new_total = 0;
00810 for (int i = 0; i < n; i++)
00811 {
00812 local_iov[i].iov_base = buffers[i].iov_base;
00813 local_iov[i].iov_len = buffers[i].iov_len;
00814
00815 new_total = total + buffers[i].iov_len;
00816 if (new_total >= ACE_HAS_SOCK_BUF_SIZE_MAX_VALUE)
00817 {
00818 local_iov[i].iov_len = ACE_HAS_SOCK_BUF_SIZE_MAX_VALUE - total;
00819 n = i+1;
00820 break;
00821 }
00822 total = new_total;
00823 }
00824 return ACE_OS::writev (handle, local_iov, n);
00825
00826 #else
00827 return ACE_OS::writev (handle, buffers, n);
00828 #endif
00829 }
00830
00831 ACE_INLINE int
00832 ACE_OS::setsockopt (ACE_HANDLE handle,
00833 int level,
00834 int optname,
00835 const char *optval,
00836 int optlen)
00837 {
00838 ACE_OS_TRACE ("ACE_OS::setsockopt");
00839 #if defined (ACE_LACKS_SETSOCKOPT)
00840 ACE_UNUSED_ARG (handle);
00841 ACE_UNUSED_ARG (level);
00842 ACE_UNUSED_ARG (optname);
00843 ACE_UNUSED_ARG (optval);
00844 ACE_UNUSED_ARG (optlen);
00845 ACE_NOTSUP_RETURN (-1);
00846 #else
00847 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) && defined(SO_REUSEPORT)
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858 if (level == SOL_SOCKET) {
00859 if (optname == SO_REUSEADDR) {
00860 return 0;
00861 }
00862 if (optname == SO_REUSEPORT) {
00863 optname = SO_REUSEADDR;
00864 }
00865 }
00866 #endif
00867
00868 int result;
00869 ACE_SOCKCALL (::setsockopt ((ACE_SOCKET) handle,
00870 level,
00871 optname,
00872 (ACE_SOCKOPT_TYPE1) optval,
00873 optlen),
00874 int,
00875 -1,
00876 result);
00877 #if defined (WSAEOPNOTSUPP)
00878 if (result == -1 && (errno == WSAEOPNOTSUPP || errno == WSAENOPROTOOPT))
00879 #else
00880 if (result == -1)
00881 #endif
00882 errno = ENOTSUP;
00883 return result;
00884 #endif
00885 }
00886
00887 ACE_INLINE int
00888 ACE_OS::shutdown (ACE_HANDLE handle, int how)
00889 {
00890 ACE_OS_TRACE ("ACE_OS::shutdown");
00891 #if defined (ACE_LACKS_SHUTDOWN)
00892 ACE_UNUSED_ARG (handle);
00893 ACE_UNUSED_ARG (how);
00894 ACE_NOTSUP_RETURN (-1);
00895 #else
00896 ACE_SOCKCALL_RETURN (::shutdown ((ACE_SOCKET) handle, how), int, -1);
00897 #endif
00898 }
00899
00900 ACE_INLINE ACE_HANDLE
00901 ACE_OS::socket (int domain,
00902 int type,
00903 int proto)
00904 {
00905 ACE_OS_TRACE ("ACE_OS::socket");
00906 #if defined (ACE_LACKS_SOCKET)
00907 ACE_UNUSED_ARG (domain);
00908 ACE_UNUSED_ARG (type);
00909 ACE_UNUSED_ARG (proto);
00910 ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
00911 #else
00912 ACE_SOCKCALL_RETURN (::socket (domain,
00913 type,
00914 proto),
00915 ACE_HANDLE,
00916 ACE_INVALID_HANDLE);
00917 #endif
00918 }
00919
00920 ACE_INLINE ACE_HANDLE
00921 ACE_OS::socket (int domain,
00922 int type,
00923 int proto,
00924 ACE_Protocol_Info *protocolinfo,
00925 ACE_SOCK_GROUP g,
00926 u_long flags)
00927 {
00928 ACE_OS_TRACE ("ACE_OS::socket");
00929
00930 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
00931 ACE_SOCKCALL_RETURN (::WSASocket (domain,
00932 type,
00933 proto,
00934 protocolinfo,
00935 g,
00936 flags),
00937 ACE_HANDLE,
00938 ACE_INVALID_HANDLE);
00939 #else
00940 ACE_UNUSED_ARG (protocolinfo);
00941 ACE_UNUSED_ARG (g);
00942 ACE_UNUSED_ARG (flags);
00943
00944 return ACE_OS::socket (domain,
00945 type,
00946 proto);
00947 #endif
00948 }
00949
00950 ACE_INLINE int
00951 ACE_OS::socketpair (int domain, int type,
00952 int protocol, ACE_HANDLE sv[2])
00953 {
00954 ACE_OS_TRACE ("ACE_OS::socketpair");
00955 #if defined (ACE_LACKS_SOCKETPAIR)
00956 ACE_UNUSED_ARG (domain);
00957 ACE_UNUSED_ARG (type);
00958 ACE_UNUSED_ARG (protocol);
00959 ACE_UNUSED_ARG (sv);
00960
00961 ACE_NOTSUP_RETURN (-1);
00962 #else
00963 ACE_OSCALL_RETURN (::socketpair (domain, type, protocol, sv),
00964 int, -1);
00965 #endif
00966 }
00967
00968 #if defined (__linux__) && defined (ACE_HAS_IPV6)
00969 ACE_INLINE unsigned int
00970 ACE_OS::if_nametoindex (const char *ifname)
00971 {
00972 ACE_OS_TRACE ("ACE_OS::if_nametoindex");
00973 ACE_OSCALL_RETURN (::if_nametoindex (ifname), int, 0);
00974 }
00975
00976 ACE_INLINE char *
00977 ACE_OS::if_indextoname (unsigned int ifindex, char *ifname)
00978 {
00979 ACE_OS_TRACE ("ACE_OS::if_indextoname");
00980 ACE_OSCALL_RETURN (::if_indextoname (ifindex, ifname), char *, 0);
00981 }
00982
00983 ACE_INLINE struct if_nameindex *
00984 ACE_OS::if_nameindex (void)
00985 {
00986 ACE_OS_TRACE ("ACE_OS::if_nameindex");
00987 ACE_OSCALL_RETURN (::if_nameindex (), struct if_nameindex *, 0);
00988 }
00989
00990 ACE_INLINE void
00991 ACE_OS::if_freenameindex (struct if_nameindex *ptr)
00992 {
00993 ACE_OS_TRACE ("ACE_OS::if_freenameindex");
00994 if (ptr != 0)
00995 ::if_freenameindex (ptr);
00996 }
00997 #endif
00998
00999 ACE_END_VERSIONED_NAMESPACE_DECL