| blob | 3b53035a777714c93bb3e897379cefca08f9603d |
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"
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
15 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
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 */
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.
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.
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;
64 if (addrlen == 0)
65 addrlen = &fake_addrlen;
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);
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*/
93 return ace_result;
95 #endif /* defined (ACE_WIN32) */
96 }
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 }
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.
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 }
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 }
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)
170 ACE_SOCKCALL_RETURN (::WSAEnumProtocols (protocols,
171 protocol_buffer,
172 buffer_length),
173 int,
174 SOCKET_ERROR);
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 }
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");
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);
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 }
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 }
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);
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 }
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 }
277 #if !defined(ACE_SOCKOPT_LEN)
278 #define ACE_SOCKOPT_LEN ACE_SOCKET_LEN
279 #endif
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 }
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 }
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");
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);
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*/
363 return ace_result_;
364 #endif /* ACE_LACKS_RECV */
365 }
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 }
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");
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 }
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);
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);
495 ACE_NOTSUP_RETURN (-1);
496 #endif /* ACE_LACKS_RECVMSG */
497 }
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)
506 DWORD bytes_received = 0;
507 int result = 1;
509 // Winsock 2 has WSARecv and can do this directly, but Winsock 1 needs
510 // to do the recvs piece-by-piece.
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 */
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 }
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");
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;
584 ACE_SOCKCALL_RETURN(send_partial_i(handle, buf, len, flags), ssize_t, -1);
585 }
586 else
587 return result;
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
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*/
612 return ace_result_;
613 #endif /* defined (ACE_WIN32) */
614 }
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);
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);
656 ACE_NOTSUP_RETURN (-1);
657 #endif /* ACE_LACKS_SENDMSG */
658 }
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 }
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);
744 number_of_bytes_sent = 0;
746 ssize_t result = 0;
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 }
762 return result;
763 #endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */
764 }
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;
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);
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;
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 */
836 return (ssize_t) bytes_sent;
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);
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;
865 // If the transfer isn't complete just drop out of the loop.
866 if (result < buffers[i].iov_len)
867 break;
868 }
869 }
871 return bytes_sent;
872 #elif defined (ACE_HAS_SOCK_BUF_SIZE_MAX)
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;
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);
895 #else
896 return ACE_OS::writev (handle, buffers, n);
897 #endif /* ACE_HAS_WINSOCK2 */
898 }
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 }
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 }
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 }
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");
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);
992 return ACE_OS::socket (domain,
993 type,
994 proto);
995 #endif /* ACE_HAS_WINSOCK2 */
996 }
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);
1009 ACE_NOTSUP_RETURN (-1);
1010 #else
1011 return ::socketpair (domain, type, protocol, sv);
1012 #endif /* ACE_LACKS_SOCKETPAIR */
1013 }
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 }
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 }
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 }
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 }
1065 ACE_END_VERSIONED_NAMESPACE_DECL