00001
00002
00003 #include "ace/ACE.h"
00004
00005 #include "ace/Basic_Types.h"
00006 #include "ace/Handle_Set.h"
00007 #include "ace/Auto_Ptr.h"
00008 #include "ace/SString.h"
00009 #include "ace/Version.h"
00010 #include "ace/Message_Block.h"
00011 #include "ace/Log_Msg.h"
00012 #include "ace/OS_NS_sys_select.h"
00013 #include "ace/OS_NS_string.h"
00014 #include "ace/OS_NS_strings.h"
00015 #include "ace/OS_NS_signal.h"
00016 #include "ace/OS_NS_stdio.h"
00017 #include "ace/OS_NS_sys_resource.h"
00018 #include "ace/OS_NS_sys_wait.h"
00019 #include "ace/OS_NS_sys_time.h"
00020 #include "ace/OS_NS_time.h"
00021 #include "ace/OS_NS_sys_uio.h"
00022 #include "ace/OS_NS_sys_stat.h"
00023 #include "ace/OS_NS_ctype.h"
00024 #include "ace/OS_NS_fcntl.h"
00025 #include "ace/OS_TLI.h"
00026 #include "ace/Truncate.h"
00027
00028 #if defined (ACE_VXWORKS) && (ACE_VXWORKS < 0x620)
00029 extern "C" int maxFiles;
00030 #endif
00031
00032 #if !defined (__ACE_INLINE__)
00033 #include "ace/ACE.inl"
00034 #endif
00035
00036 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
00037 # include "ace/OS_NS_poll.h"
00038 #endif
00039
00040
00041 ACE_RCSID (ace,
00042 ACE,
00043 "$Id: ACE.cpp 91066 2010-07-12 11:05:04Z johnnyw $")
00044
00045
00046
00047 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00048
00049 namespace ACE
00050 {
00051
00052
00053
00054
00055 size_t allocation_granularity_ = 0;
00056
00057
00058 size_t pagesize_ = 0;
00059
00060
00061
00062 char debug_;
00063 }
00064
00065
00066 int
00067 ACE::out_of_handles (int error)
00068 {
00069
00070 if (error == EMFILE ||
00071 #if defined (ACE_WIN32)
00072
00073 error == ENOBUFS ||
00074 #elif defined (HPUX)
00075
00076 error == EADDRNOTAVAIL ||
00077 #elif defined (linux)
00078
00079 error == ENOENT ||
00080
00081 error == EINVAL ||
00082
00083 error == EOPNOTSUPP ||
00084 #elif defined (sun)
00085
00086 error == ENOSR ||
00087
00088 error == ENOTSUP ||
00089 #elif defined (__FreeBSD__)
00090
00091
00092 error == EOPNOTSUPP ||
00093 error == ENOSYS ||
00094 #elif defined (__OpenBSD__)
00095
00096 error == EBADF ||
00097 #elif defined (__sgi)
00098 error == ENOTSUP ||
00099 #elif defined (DIGITAL_UNIX)
00100 error == ENOTSUP ||
00101 #endif
00102 error == ENFILE)
00103 return 1;
00104 else
00105 return 0;
00106 }
00107
00108 u_int
00109 ACE::major_version (void)
00110 {
00111 return ACE_MAJOR_VERSION;
00112 }
00113
00114 u_int
00115 ACE::minor_version (void)
00116 {
00117 return ACE_MINOR_VERSION;
00118 }
00119
00120 u_int
00121 ACE::beta_version (void)
00122 {
00123 return ACE_BETA_VERSION;
00124 }
00125
00126 const ACE_TCHAR *
00127 ACE::compiler_name (void)
00128 {
00129 #ifdef ACE_CC_NAME
00130 return ACE_CC_NAME;
00131 #else
00132 return ACE_TEXT ("");
00133 #endif
00134 }
00135
00136 u_int
00137 ACE::compiler_major_version (void)
00138 {
00139 #ifdef ACE_CC_MAJOR_VERSION
00140 return ACE_CC_MAJOR_VERSION;
00141 #else
00142 return 0;
00143 #endif
00144 }
00145
00146 u_int
00147 ACE::compiler_minor_version (void)
00148 {
00149 #ifdef ACE_CC_MINOR_VERSION
00150 return ACE_CC_MINOR_VERSION;
00151 #else
00152 return 0;
00153 #endif
00154 }
00155
00156 u_int
00157 ACE::compiler_beta_version (void)
00158 {
00159 #ifdef ACE_CC_BETA_VERSION
00160 return ACE_CC_BETA_VERSION;
00161 #else
00162 return 0;
00163 #endif
00164 }
00165
00166 ACE_TCHAR
00167 ACE::nibble2hex (u_int n)
00168 {
00169
00170 return ACE_TEXT ("0123456789abcdef")[n & 0x0f];
00171 }
00172
00173 bool
00174 ACE::debug (void)
00175 {
00176 static const char* debug = ACE_OS::getenv ("ACE_DEBUG");
00177 return (ACE::debug_ != 0) ? ACE::debug_ : (debug != 0 ? (*debug != '0') : false);
00178 }
00179
00180 void
00181 ACE::debug (bool onoff)
00182 {
00183 ACE::debug_ = onoff;
00184 }
00185
00186 int
00187 ACE::select (int width,
00188 ACE_Handle_Set *readfds,
00189 ACE_Handle_Set *writefds,
00190 ACE_Handle_Set *exceptfds,
00191 const ACE_Time_Value *timeout)
00192 {
00193 int result = ACE_OS::select (width,
00194 readfds ? readfds->fdset () : 0,
00195 writefds ? writefds->fdset () : 0,
00196 exceptfds ? exceptfds->fdset () : 0,
00197 timeout);
00198 if (result > 0)
00199 {
00200 # if !defined (ACE_WIN32)
00201
00202 if (readfds)
00203 readfds->sync ((ACE_HANDLE) width);
00204 if (writefds)
00205 writefds->sync ((ACE_HANDLE) width);
00206 if (exceptfds)
00207 exceptfds->sync ((ACE_HANDLE) width);
00208 #endif
00209 }
00210 return result;
00211 }
00212
00213 int
00214 ACE::select (int width,
00215 ACE_Handle_Set &readfds,
00216 const ACE_Time_Value *timeout)
00217 {
00218 int result = ACE_OS::select (width,
00219 readfds.fdset (),
00220 0,
00221 0,
00222 timeout);
00223
00224 #if !defined (ACE_WIN32)
00225 if (result > 0)
00226 readfds.sync ((ACE_HANDLE) width);
00227 #endif
00228 return result;
00229 }
00230
00231 int
00232 ACE::terminate_process (pid_t pid)
00233 {
00234 #if defined (ACE_HAS_PHARLAP)
00235 ACE_UNUSED_ARG (pid);
00236 ACE_NOTSUP_RETURN (-1);
00237 #elif defined (ACE_WIN32)
00238
00239 ACE_HANDLE process_handle =
00240 ::OpenProcess (PROCESS_TERMINATE,
00241 FALSE,
00242 pid);
00243
00244 if (process_handle == ACE_INVALID_HANDLE
00245 || process_handle == 0)
00246 return -1;
00247 else
00248 {
00249
00250 BOOL terminate_result =
00251 ::TerminateProcess (process_handle, 0);
00252
00253 ACE_OS::close (process_handle);
00254 return terminate_result ? 0 : -1;
00255 }
00256 #else
00257 return ACE_OS::kill (pid, 9);
00258 #endif
00259 }
00260
00261 int
00262 ACE::process_active (pid_t pid)
00263 {
00264 #if !defined(ACE_WIN32)
00265 if (ACE_OS::kill (pid, 0) == 0)
00266 return 1;
00267 else if (errno == ESRCH)
00268 return 0;
00269 else
00270 return -1;
00271 #else
00272
00273 ACE_HANDLE process_handle =
00274 ::OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, pid);
00275 if (process_handle == ACE_INVALID_HANDLE || process_handle == 0)
00276 return 0;
00277 else
00278 {
00279 DWORD status;
00280 int result = 1;
00281 if (::GetExitCodeProcess (process_handle,
00282 &status) == 0
00283 || status != STILL_ACTIVE)
00284 result = 0;
00285
00286 ::CloseHandle (process_handle);
00287 return result;
00288 }
00289 #endif
00290 }
00291
00292 const ACE_TCHAR *
00293 ACE::execname (const ACE_TCHAR *old_name)
00294 {
00295 #if defined (ACE_WIN32)
00296 const ACE_TCHAR *suffix = ACE_OS::strrchr (old_name, ACE_TEXT ('.'));
00297 if (suffix == 0 || ACE_OS::strcasecmp (suffix, ACE_TEXT (".exe")) != 0)
00298 {
00299 ACE_TCHAR *new_name = 0;
00300
00301 size_t size =
00302 ACE_OS::strlen (old_name)
00303 + ACE_OS::strlen (ACE_TEXT (".exe"))
00304 + 1;
00305
00306 ACE_NEW_RETURN (new_name,
00307 ACE_TCHAR[size],
00308 0);
00309 ACE_TCHAR *end = new_name;
00310
00311 end = ACE_OS::strecpy (new_name, old_name);
00312
00313
00314
00315 ACE_OS::strcpy (end - 1, ACE_TEXT (".exe"));
00316
00317 return new_name;
00318 }
00319 #endif
00320 return old_name;
00321 }
00322
00323 u_long
00324 ACE::hash_pjw (const char *str, size_t len)
00325 {
00326 u_long hash = 0;
00327
00328 for (size_t i = 0; i < len; i++)
00329 {
00330 const char temp = str[i];
00331 hash = (hash << 4) + (temp * 13);
00332
00333 u_long g = hash & 0xf0000000;
00334
00335 if (g)
00336 {
00337 hash ^= (g >> 24);
00338 hash ^= g;
00339 }
00340 }
00341
00342 return hash;
00343 }
00344
00345 u_long
00346 ACE::hash_pjw (const char *str)
00347 {
00348 return ACE::hash_pjw (str, ACE_OS::strlen (str));
00349 }
00350
00351 #if defined (ACE_HAS_WCHAR)
00352 u_long
00353 ACE::hash_pjw (const wchar_t *str, size_t len)
00354 {
00355 u_long hash = 0;
00356
00357 for (size_t i = 0; i < len; i++)
00358 {
00359
00360
00361 const wchar_t temp = str[i];
00362 hash = (hash << 4) + (temp * 13);
00363
00364 u_long g = hash & 0xf0000000;
00365
00366 if (g)
00367 {
00368 hash ^= (g >> 24);
00369 hash ^= g;
00370 }
00371 }
00372
00373 return hash;
00374 }
00375
00376 u_long
00377 ACE::hash_pjw (const wchar_t *str)
00378 {
00379 return ACE::hash_pjw (str, ACE_OS::strlen (str));
00380 }
00381 #endif
00382
00383 ACE_TCHAR *
00384 ACE::strenvdup (const ACE_TCHAR *str)
00385 {
00386 ACE_TRACE ("ACE::strenvdup");
00387
00388 return ACE_OS::strenvdup (str);
00389 }
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409 const ACE_TCHAR *
00410 ACE::basename (const ACE_TCHAR *pathname, ACE_TCHAR delim)
00411 {
00412 ACE_TRACE ("ACE::basename");
00413 const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim);
00414
00415 if (temp == 0)
00416 return pathname;
00417 else
00418 return temp + 1;
00419 }
00420
00421 const ACE_TCHAR *
00422 ACE::dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim)
00423 {
00424 ACE_TRACE ("ACE::dirname");
00425 static ACE_TCHAR return_dirname[MAXPATHLEN + 1];
00426
00427 const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim);
00428
00429 if (temp == 0)
00430 {
00431 return_dirname[0] = '.';
00432 return_dirname[1] = '\0';
00433
00434 return return_dirname;
00435 }
00436 else
00437 {
00438
00439
00440 size_t len = temp - pathname + 1;
00441 if (len > (sizeof return_dirname / sizeof (ACE_TCHAR)))
00442 len = sizeof return_dirname / sizeof (ACE_TCHAR);
00443
00444 ACE_OS::strsncpy (return_dirname,
00445 pathname,
00446 len);
00447 return return_dirname;
00448 }
00449 }
00450
00451 ssize_t
00452 ACE::recv (ACE_HANDLE handle,
00453 void *buf,
00454 size_t len,
00455 int flags,
00456 const ACE_Time_Value *timeout)
00457 {
00458 if (timeout == 0)
00459 return ACE_OS::recv (handle, (char *) buf, len, flags);
00460 else
00461 {
00462 int val = 0;
00463 if (ACE::enter_recv_timedwait (handle, timeout, val) ==-1)
00464 return -1;
00465 else
00466 {
00467 ssize_t bytes_transferred =
00468 ACE_OS::recv (handle, (char *) buf, len, flags);
00469 ACE::restore_non_blocking_mode (handle, val);
00470 return bytes_transferred;
00471 }
00472 }
00473 }
00474
00475 #if defined (ACE_HAS_TLI)
00476
00477 ssize_t
00478 ACE::t_rcv (ACE_HANDLE handle,
00479 void *buf,
00480 size_t len,
00481 int *flags,
00482 const ACE_Time_Value *timeout)
00483 {
00484 if (timeout == 0)
00485 return ACE_OS::t_rcv (handle, (char *) buf, len, flags);
00486 else
00487 {
00488 int val = 0;
00489 if (ACE::enter_recv_timedwait (handle, timeout, val) ==-1)
00490 return -1;
00491 else
00492 {
00493 ssize_t bytes_transferred =
00494 ACE_OS::t_rcv (handle, (char *) buf, len, flags);
00495 ACE::restore_non_blocking_mode (handle, val);
00496 return bytes_transferred;
00497 }
00498 }
00499 }
00500
00501 #endif
00502
00503 ssize_t
00504 ACE::recv (ACE_HANDLE handle,
00505 void *buf,
00506 size_t n,
00507 const ACE_Time_Value *timeout)
00508 {
00509 if (timeout == 0)
00510 return ACE::recv_i (handle, buf, n);
00511 else
00512 {
00513 int val = 0;
00514 if (ACE::enter_recv_timedwait (handle, timeout, val) == -1)
00515 return -1;
00516 else
00517 {
00518 ssize_t bytes_transferred = ACE::recv_i (handle, buf, n);
00519 ACE::restore_non_blocking_mode (handle, val);
00520 return bytes_transferred;
00521 }
00522 }
00523 }
00524
00525 ssize_t
00526 ACE::recvmsg (ACE_HANDLE handle,
00527 struct msghdr *msg,
00528 int flags,
00529 const ACE_Time_Value *timeout)
00530 {
00531 if (timeout == 0)
00532 return ACE_OS::recvmsg (handle, msg, flags);
00533 else
00534 {
00535 int val = 0;
00536 if (ACE::enter_recv_timedwait (handle, timeout, val) == -1)
00537 return -1;
00538 else
00539 {
00540 ssize_t bytes_transferred = ACE_OS::recvmsg (handle, msg, flags);
00541 ACE::restore_non_blocking_mode (handle, val);
00542 return bytes_transferred;
00543 }
00544 }
00545 }
00546
00547 ssize_t
00548 ACE::recvfrom (ACE_HANDLE handle,
00549 char *buf,
00550 int len,
00551 int flags,
00552 struct sockaddr *addr,
00553 int *addrlen,
00554 const ACE_Time_Value *timeout)
00555 {
00556 if (timeout == 0)
00557 return ACE_OS::recvfrom (handle, buf, len, flags, addr, addrlen);
00558 else
00559 {
00560 int val = 0;
00561 if (ACE::enter_recv_timedwait (handle, timeout, val) == -1)
00562 return -1;
00563 else
00564 {
00565 ssize_t bytes_transferred =
00566 ACE_OS::recvfrom (handle, buf, len, flags, addr, addrlen);
00567 ACE::restore_non_blocking_mode (handle, val);
00568 return bytes_transferred;
00569 }
00570 }
00571 }
00572
00573 ssize_t
00574 ACE::recv_n_i (ACE_HANDLE handle,
00575 void *buf,
00576 size_t len,
00577 int flags,
00578 size_t *bt)
00579 {
00580 size_t temp;
00581 size_t &bytes_transferred = bt == 0 ? temp : *bt;
00582 ssize_t n;
00583
00584 for (bytes_transferred = 0;
00585 bytes_transferred < len;
00586 bytes_transferred += n)
00587 {
00588
00589 n = ACE_OS::recv (handle,
00590 static_cast <char *> (buf) + bytes_transferred,
00591 len - bytes_transferred,
00592 flags);
00593
00594 if (n == 0)
00595 return 0;
00596
00597
00598 if (n == -1)
00599 {
00600
00601 if (errno == EWOULDBLOCK)
00602 {
00603
00604 int const result = ACE::handle_read_ready (handle, 0);
00605
00606
00607 if (result != -1)
00608 {
00609
00610 n = 0;
00611 continue;
00612 }
00613 }
00614
00615
00616 return -1;
00617 }
00618 }
00619
00620 return static_cast<ssize_t> (bytes_transferred);
00621 }
00622
00623 ssize_t
00624 ACE::recv_n_i (ACE_HANDLE handle,
00625 void *buf,
00626 size_t len,
00627 int flags,
00628 const ACE_Time_Value *timeout,
00629 size_t *bt)
00630 {
00631 size_t temp;
00632 size_t &bytes_transferred = bt == 0 ? temp : *bt;
00633 ssize_t n;
00634 ssize_t result = 0;
00635 int error = 0;
00636
00637 int val = 0;
00638 ACE::record_and_set_non_blocking_mode (handle, val);
00639
00640 for (bytes_transferred = 0;
00641 bytes_transferred < len;
00642 bytes_transferred += n)
00643 {
00644
00645
00646
00647 n = ACE_OS::recv (handle,
00648 static_cast <char *> (buf) + bytes_transferred,
00649 len - bytes_transferred,
00650 flags);
00651
00652
00653 if (n == 0 ||
00654 n == -1)
00655 {
00656
00657 if (n == -1 &&
00658 errno == EWOULDBLOCK)
00659 {
00660
00661 int const rtn = ACE::handle_read_ready (handle, timeout);
00662
00663
00664 if (rtn != -1)
00665 {
00666
00667
00668 n = 0;
00669 continue;
00670 }
00671 }
00672
00673
00674
00675 error = 1;
00676 result = n;
00677 break;
00678 }
00679 }
00680
00681 ACE::restore_non_blocking_mode (handle, val);
00682
00683 if (error)
00684 return result;
00685 else
00686 return static_cast<ssize_t> (bytes_transferred);
00687 }
00688
00689 #if defined (ACE_HAS_TLI)
00690
00691 ssize_t
00692 ACE::t_rcv_n_i (ACE_HANDLE handle,
00693 void *buf,
00694 size_t len,
00695 int *flags,
00696 size_t *bt)
00697 {
00698 size_t temp;
00699 size_t &bytes_transferred = bt == 0 ? temp : *bt;
00700 ssize_t n;
00701
00702 for (bytes_transferred = 0;
00703 bytes_transferred < len;
00704 bytes_transferred += n)
00705 {
00706
00707 n = ACE_OS::t_rcv (handle,
00708 (char *) buf + bytes_transferred,
00709 len - bytes_transferred,
00710 flags);
00711
00712 if (n == 0)
00713 return 0;
00714
00715
00716 if (n == -1)
00717 {
00718
00719 if (errno == EWOULDBLOCK)
00720 {
00721
00722 int const result = ACE::handle_read_ready (handle, 0);
00723
00724
00725 if (result != -1)
00726 {
00727
00728 n = 0;
00729 continue;
00730 }
00731 }
00732
00733
00734 return -1;
00735 }
00736 }
00737
00738 return bytes_transferred;
00739 }
00740
00741 ssize_t
00742 ACE::t_rcv_n_i (ACE_HANDLE handle,
00743 void *buf,
00744 size_t len,
00745 int *flags,
00746 const ACE_Time_Value *timeout,
00747 size_t *bt)
00748 {
00749 size_t temp;
00750 size_t &bytes_transferred = bt == 0 ? temp : *bt;
00751 ssize_t n;
00752 ssize_t result = 0;
00753 int error = 0;
00754
00755 int val = 0;
00756 ACE::record_and_set_non_blocking_mode (handle, val);
00757
00758 for (bytes_transferred = 0;
00759 bytes_transferred < len;
00760 bytes_transferred += n)
00761 {
00762
00763
00764
00765 n = ACE_OS::t_rcv (handle,
00766 (char *) buf + bytes_transferred,
00767 len - bytes_transferred,
00768 flags);
00769
00770
00771 if (n == 0 ||
00772 n == -1)
00773 {
00774
00775 if (n == -1 &&
00776 errno == EWOULDBLOCK)
00777 {
00778
00779 int const rtn = ACE::handle_read_ready (handle, timeout);
00780
00781
00782 if (rtn != -1)
00783 {
00784
00785
00786 n = 0;
00787 continue;
00788 }
00789 }
00790
00791
00792
00793 error = 1;
00794 result = n;
00795 break;
00796 }
00797 }
00798
00799 ACE::restore_non_blocking_mode (handle, val);
00800
00801 if (error)
00802 return result;
00803 else
00804 return bytes_transferred;
00805 }
00806
00807 #endif
00808
00809 ssize_t
00810 ACE::recv_n_i (ACE_HANDLE handle,
00811 void *buf,
00812 size_t len,
00813 size_t *bt)
00814 {
00815 size_t temp;
00816 size_t &bytes_transferred = bt == 0 ? temp : *bt;
00817 ssize_t n;
00818
00819 for (bytes_transferred = 0;
00820 bytes_transferred < len;
00821 bytes_transferred += n)
00822 {
00823
00824 n = ACE::recv_i (handle,
00825 static_cast <char *> (buf) + bytes_transferred,
00826 len - bytes_transferred);
00827
00828 if (n == 0)
00829 {
00830 return 0;
00831 }
00832
00833 if (n == -1)
00834 {
00835
00836 if (errno == EWOULDBLOCK)
00837 {
00838
00839 int const result = ACE::handle_read_ready (handle, 0);
00840
00841
00842 if (result != -1)
00843 {
00844
00845 n = 0;
00846 continue;
00847 }
00848 }
00849
00850
00851 return -1;
00852 }
00853 }
00854
00855 return static_cast<ssize_t> (bytes_transferred);
00856 }
00857
00858 ssize_t
00859 ACE::recv_n_i (ACE_HANDLE handle,
00860 void *buf,
00861 size_t len,
00862 const ACE_Time_Value *timeout,
00863 size_t *bt)
00864 {
00865 size_t temp;
00866 size_t &bytes_transferred = bt == 0 ? temp : *bt;
00867 ssize_t n;
00868 ssize_t result = 0;
00869 int error = 0;
00870
00871 int val = 0;
00872 ACE::record_and_set_non_blocking_mode (handle, val);
00873
00874 for (bytes_transferred = 0;
00875 bytes_transferred < len;
00876 bytes_transferred += n)
00877 {
00878
00879
00880
00881 n = ACE::recv_i (handle,
00882 static_cast <char *> (buf) + bytes_transferred,
00883 len - bytes_transferred);
00884
00885
00886 if (n == 0 ||
00887 n == -1)
00888 {
00889
00890 if (n == -1 &&
00891 errno == EWOULDBLOCK)
00892 {
00893
00894 int const rtn = ACE::handle_read_ready (handle, timeout);
00895
00896
00897 if (rtn != -1)
00898 {
00899
00900
00901 n = 0;
00902 continue;
00903 }
00904 }
00905
00906
00907
00908 error = 1;
00909 result = n;
00910 break;
00911 }
00912 }
00913
00914 ACE::restore_non_blocking_mode (handle, val);
00915
00916 if (error)
00917 return result;
00918 else
00919 return static_cast<ssize_t> (bytes_transferred);
00920 }
00921
00922
00923
00924
00925
00926
00927
00928 ssize_t
00929 ACE::recv (ACE_HANDLE handle, size_t n, ...)
00930 {
00931 va_list argp;
00932 int const total_tuples = static_cast<int> (n / 2);
00933 iovec *iovp = 0;
00934 #if defined (ACE_HAS_ALLOCA)
00935 iovp = (iovec *) alloca (total_tuples * sizeof (iovec));
00936 #else
00937 ACE_NEW_RETURN (iovp,
00938 iovec[total_tuples],
00939 -1);
00940 #endif
00941
00942 va_start (argp, n);
00943
00944 for (int i = 0; i < total_tuples; i++)
00945 {
00946 iovp[i].iov_base = va_arg (argp, char *);
00947 iovp[i].iov_len = va_arg (argp, int);
00948 }
00949
00950 ssize_t const result = ACE_OS::recvv (handle, iovp, total_tuples);
00951 #if !defined (ACE_HAS_ALLOCA)
00952 delete [] iovp;
00953 #endif
00954 va_end (argp);
00955 return result;
00956 }
00957
00958 ssize_t
00959 ACE::recvv (ACE_HANDLE handle,
00960 iovec *iov,
00961 int iovcnt,
00962 const ACE_Time_Value *timeout)
00963 {
00964 if (timeout == 0)
00965 return ACE_OS::recvv (handle, iov, iovcnt);
00966 else
00967 {
00968 int val = 0;
00969 if (ACE::enter_recv_timedwait (handle, timeout, val) == -1)
00970 return -1;
00971 else
00972 {
00973 ssize_t bytes_transferred = ACE_OS::recvv (handle, iov, iovcnt);
00974 ACE::restore_non_blocking_mode (handle, val);
00975 return bytes_transferred;
00976 }
00977 }
00978 }
00979
00980 ssize_t
00981 ACE::recvv_n_i (ACE_HANDLE handle,
00982 iovec *iov,
00983 int iovcnt,
00984 size_t *bt)
00985 {
00986 size_t temp;
00987 size_t &bytes_transferred = bt == 0 ? temp : *bt;
00988 bytes_transferred = 0;
00989
00990 for (int s = 0; s < iovcnt; )
00991 {
00992
00993 ssize_t n = ACE_OS::recvv (handle, iov + s, iovcnt - s);
00994
00995 if (n == 0)
00996 return 0;
00997
00998
00999 if (n == -1)
01000 {
01001
01002 if (errno == EWOULDBLOCK)
01003 {
01004
01005 int const result = ACE::handle_read_ready (handle, 0);
01006
01007
01008 if (result != -1)
01009 {
01010
01011 n = 0;
01012 continue;
01013 }
01014 }
01015
01016
01017 return -1;
01018 }
01019
01020 for (bytes_transferred += n;
01021 s < iovcnt
01022 && n >= static_cast<ssize_t> (iov[s].iov_len);
01023 s++)
01024 n -= iov[s].iov_len;
01025
01026 if (n != 0)
01027 {
01028 char *base = static_cast<char *> (iov[s].iov_base);
01029 iov[s].iov_base = base + n;
01030 iov[s].iov_len = iov[s].iov_len - n;
01031 }
01032 }
01033
01034 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01035 }
01036
01037 ssize_t
01038 ACE::recvv_n_i (ACE_HANDLE handle,
01039 iovec *iov,
01040 int iovcnt,
01041 const ACE_Time_Value *timeout,
01042 size_t *bt)
01043 {
01044 size_t temp;
01045 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01046 bytes_transferred = 0;
01047 ssize_t result = 0;
01048 int error = 0;
01049
01050 int val = 0;
01051 ACE::record_and_set_non_blocking_mode (handle, val);
01052
01053 for (int s = 0; s < iovcnt; )
01054 {
01055
01056
01057
01058 ssize_t n = ACE_OS::recvv (handle, iov + s, iovcnt - s);
01059
01060
01061 if (n == 0 || n == -1)
01062 {
01063
01064 if (n == -1 && errno == EWOULDBLOCK)
01065 {
01066
01067 int const rtn = ACE::handle_read_ready (handle, timeout);
01068
01069
01070 if (rtn != -1)
01071 {
01072
01073
01074 n = 0;
01075 continue;
01076 }
01077 }
01078
01079
01080
01081 error = 1;
01082 result = n;
01083 break;
01084 }
01085
01086 for (bytes_transferred += n;
01087 s < iovcnt
01088 && n >= static_cast<ssize_t> (iov[s].iov_len);
01089 s++)
01090 n -= iov[s].iov_len;
01091
01092 if (n != 0)
01093 {
01094 char *base = reinterpret_cast<char *> (iov[s].iov_base);
01095 iov[s].iov_base = base + n;
01096 iov[s].iov_len = iov[s].iov_len - n;
01097 }
01098 }
01099
01100 ACE::restore_non_blocking_mode (handle, val);
01101
01102 if (error)
01103 {
01104 return result;
01105 }
01106 else
01107 {
01108 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01109 }
01110 }
01111
01112 ssize_t
01113 ACE::recv_n (ACE_HANDLE handle,
01114 ACE_Message_Block *message_block,
01115 const ACE_Time_Value *timeout,
01116 size_t *bt)
01117 {
01118 size_t temp;
01119 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01120 bytes_transferred = 0;
01121
01122 iovec iov[ACE_IOV_MAX];
01123 int iovcnt = 0;
01124
01125 while (message_block != 0)
01126 {
01127
01128 const ACE_Message_Block *current_message_block = message_block;
01129
01130 while (current_message_block != 0)
01131 {
01132 size_t current_message_block_length =
01133 current_message_block->length ();
01134 char *this_rd_ptr = current_message_block->rd_ptr ();
01135
01136
01137 while (current_message_block_length > 0)
01138 {
01139 u_long const this_chunk_length =
01140 ACE_Utils::truncate_cast<u_long> (
01141 current_message_block_length);
01142
01143
01144 iov[iovcnt].iov_base = this_rd_ptr;
01145 iov[iovcnt].iov_len = this_chunk_length;
01146 current_message_block_length -= this_chunk_length;
01147 this_rd_ptr += this_chunk_length;
01148
01149
01150 ++iovcnt;
01151
01152
01153
01154
01155
01156 if (iovcnt == ACE_IOV_MAX)
01157 {
01158 size_t current_transfer = 0;
01159
01160 ssize_t const result = ACE::recvv_n (handle,
01161 iov,
01162 iovcnt,
01163 timeout,
01164 ¤t_transfer);
01165
01166
01167 bytes_transferred += current_transfer;
01168
01169
01170 if (result == -1 || result == 0)
01171 return result;
01172
01173
01174 iovcnt = 0;
01175 }
01176 }
01177
01178
01179 current_message_block = current_message_block->cont ();
01180 }
01181
01182
01183 message_block = message_block->next ();
01184 }
01185
01186
01187
01188 if (iovcnt != 0)
01189 {
01190 size_t current_transfer = 0;
01191
01192 ssize_t const result = ACE::recvv_n (handle,
01193 iov,
01194 iovcnt,
01195 timeout,
01196 ¤t_transfer);
01197
01198
01199 bytes_transferred += current_transfer;
01200
01201
01202 if (result == -1 || result == 0)
01203 {
01204 return result;
01205 }
01206 }
01207
01208
01209 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01210 }
01211
01212 ssize_t
01213 ACE::send (ACE_HANDLE handle,
01214 const void *buf,
01215 size_t n,
01216 int flags,
01217 const ACE_Time_Value *timeout)
01218 {
01219 if (timeout == 0)
01220 return ACE_OS::send (handle, (const char *) buf, n, flags);
01221 else
01222 {
01223 int val = 0;
01224 if (ACE::enter_send_timedwait (handle, timeout, val) == -1)
01225 return -1;
01226 else
01227 {
01228 ssize_t const bytes_transferred =
01229 ACE_OS::send (handle, (const char *) buf, n, flags);
01230 ACE::restore_non_blocking_mode (handle, val);
01231 return bytes_transferred;
01232 }
01233 }
01234 }
01235
01236 #if defined (ACE_HAS_TLI)
01237
01238 ssize_t
01239 ACE::t_snd (ACE_HANDLE handle,
01240 const void *buf,
01241 size_t n,
01242 int flags,
01243 const ACE_Time_Value *timeout)
01244 {
01245 if (timeout == 0)
01246 return ACE_OS::t_snd (handle, (const char *) buf, n, flags);
01247 else
01248 {
01249 int val = 0;
01250 if (ACE::enter_send_timedwait (handle, timeout, val) == -1)
01251 return -1;
01252 else
01253 {
01254 ssize_t const bytes_transferred =
01255 ACE_OS::t_snd (handle, (const char *) buf, n, flags);
01256 ACE::restore_non_blocking_mode (handle, val);
01257 return bytes_transferred;
01258 }
01259 }
01260 }
01261
01262 #endif
01263
01264 ssize_t
01265 ACE::send (ACE_HANDLE handle,
01266 const void *buf,
01267 size_t n,
01268 const ACE_Time_Value *timeout)
01269 {
01270 if (timeout == 0)
01271 return ACE::send_i (handle, buf, n);
01272 else
01273 {
01274 int val = 0;
01275 if (ACE::enter_send_timedwait (handle, timeout, val) == -1)
01276 return -1;
01277 else
01278 {
01279 ssize_t const bytes_transferred = ACE::send_i (handle, buf, n);
01280 ACE::restore_non_blocking_mode (handle, val);
01281 return bytes_transferred;
01282 }
01283 }
01284 }
01285
01286 ssize_t
01287 ACE::sendmsg (ACE_HANDLE handle,
01288 const struct msghdr *msg,
01289 int flags,
01290 const ACE_Time_Value *timeout)
01291 {
01292 if (timeout == 0)
01293 return ACE_OS::sendmsg (handle, msg, flags);
01294 else
01295 {
01296 int val = 0;
01297 if (ACE::enter_send_timedwait (handle, timeout, val) == -1)
01298 return -1;
01299 else
01300 {
01301 ssize_t const bytes_transferred =
01302 ACE_OS::sendmsg (handle, msg, flags);
01303 ACE::restore_non_blocking_mode (handle, val);
01304 return bytes_transferred;
01305 }
01306 }
01307 }
01308
01309 ssize_t
01310 ACE::sendto (ACE_HANDLE handle,
01311 const char *buf,
01312 int len,
01313 int flags,
01314 const struct sockaddr *addr,
01315 int addrlen,
01316 const ACE_Time_Value *timeout)
01317 {
01318 if (timeout == 0)
01319 return ACE_OS::sendto (handle, buf, len, flags, addr, addrlen);
01320 else
01321 {
01322 int val = 0;
01323 if (ACE::enter_send_timedwait (handle, timeout, val) == -1)
01324 return -1;
01325 else
01326 {
01327 ssize_t const bytes_transferred =
01328 ACE_OS::sendto (handle, buf, len, flags, addr, addrlen);
01329 ACE::restore_non_blocking_mode (handle, val);
01330 return bytes_transferred;
01331 }
01332 }
01333 }
01334
01335 ssize_t
01336 ACE::send_n_i (ACE_HANDLE handle,
01337 const void *buf,
01338 size_t len,
01339 int flags,
01340 size_t *bt)
01341 {
01342 size_t temp;
01343 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01344 ssize_t n;
01345
01346 for (bytes_transferred = 0;
01347 bytes_transferred < len;
01348 bytes_transferred += n)
01349 {
01350
01351 n = ACE_OS::send (handle,
01352 (char *) buf + bytes_transferred,
01353 len - bytes_transferred,
01354 flags);
01355
01356 if (n == 0)
01357 return 0;
01358
01359
01360 if (n == -1)
01361 {
01362
01363 #if defined (ACE_WIN32)
01364 if (errno == EWOULDBLOCK)
01365 #else
01366 if (errno == EWOULDBLOCK || errno == ENOBUFS)
01367 #endif
01368 {
01369
01370 int const result = ACE::handle_write_ready (handle, 0);
01371
01372
01373 if (result != -1)
01374 {
01375
01376 n = 0;
01377 continue;
01378 }
01379 }
01380
01381
01382 return -1;
01383 }
01384 }
01385
01386 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01387 }
01388
01389 ssize_t
01390 ACE::send_n_i (ACE_HANDLE handle,
01391 const void *buf,
01392 size_t len,
01393 int flags,
01394 const ACE_Time_Value *timeout,
01395 size_t *bt)
01396 {
01397 size_t temp;
01398 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01399 ssize_t n;
01400 ssize_t result = 0;
01401 int error = 0;
01402
01403 int val = 0;
01404 ACE::record_and_set_non_blocking_mode (handle, val);
01405
01406 for (bytes_transferred = 0;
01407 bytes_transferred < len;
01408 bytes_transferred += n)
01409 {
01410
01411
01412
01413 n = ACE_OS::send (handle,
01414 (char *) buf + bytes_transferred,
01415 len - bytes_transferred,
01416 flags);
01417
01418
01419 if (n == 0 ||
01420 n == -1)
01421 {
01422
01423 if (n == -1 && (errno == EWOULDBLOCK || errno == ENOBUFS))
01424 {
01425
01426 int const rtn = ACE::handle_write_ready (handle, timeout);
01427
01428
01429 if (rtn != -1)
01430 {
01431
01432
01433 n = 0;
01434 continue;
01435 }
01436 }
01437
01438
01439
01440 error = 1;
01441 result = n;
01442 break;
01443 }
01444 }
01445
01446 ACE::restore_non_blocking_mode (handle, val);
01447
01448 if (error)
01449 {
01450 return result;
01451 }
01452 else
01453 {
01454 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01455 }
01456 }
01457
01458 #if defined (ACE_HAS_TLI)
01459
01460 ssize_t
01461 ACE::t_snd_n_i (ACE_HANDLE handle,
01462 const void *buf,
01463 size_t len,
01464 int flags,
01465 size_t *bt)
01466 {
01467 size_t temp;
01468 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01469 ssize_t n;
01470
01471 for (bytes_transferred = 0;
01472 bytes_transferred < len;
01473 bytes_transferred += n)
01474 {
01475
01476 n = ACE_OS::t_snd (handle,
01477 (char *) buf + bytes_transferred,
01478 len - bytes_transferred,
01479 flags);
01480
01481 if (n == 0)
01482 return 0;
01483
01484
01485 if (n == -1)
01486 {
01487
01488 if (errno == EWOULDBLOCK || errno == ENOBUFS)
01489 {
01490
01491 int const result = ACE::handle_write_ready (handle, 0);
01492
01493
01494 if (result != -1)
01495 {
01496
01497 n = 0;
01498 continue;
01499 }
01500 }
01501
01502
01503 return -1;
01504 }
01505 }
01506
01507 return bytes_transferred;
01508 }
01509
01510 ssize_t
01511 ACE::t_snd_n_i (ACE_HANDLE handle,
01512 const void *buf,
01513 size_t len,
01514 int flags,
01515 const ACE_Time_Value *timeout,
01516 size_t *bt)
01517 {
01518 size_t temp;
01519 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01520 ssize_t n;
01521 ssize_t result = 0;
01522 int error = 0;
01523
01524 int val = 0;
01525 ACE::record_and_set_non_blocking_mode (handle, val);
01526
01527 for (bytes_transferred = 0;
01528 bytes_transferred < len;
01529 bytes_transferred += n)
01530 {
01531
01532
01533
01534 n = ACE_OS::t_snd (handle,
01535 (char *) buf + bytes_transferred,
01536 len - bytes_transferred,
01537 flags);
01538
01539
01540 if (n == 0 ||
01541 n == -1)
01542 {
01543
01544 if (n == -1 &&
01545 errno == EWOULDBLOCK || errno == ENOBUFS)
01546 {
01547
01548 int const rtn = ACE::handle_write_ready (handle, timeout);
01549
01550
01551 if (rtn != -1)
01552 {
01553
01554
01555 n = 0;
01556 continue;
01557 }
01558 }
01559
01560
01561
01562 error = 1;
01563 result = n;
01564 break;
01565 }
01566 }
01567
01568 ACE::restore_non_blocking_mode (handle, val);
01569
01570 if (error)
01571 return result;
01572 else
01573 return bytes_transferred;
01574 }
01575
01576 #endif
01577
01578 ssize_t
01579 ACE::send_n_i (ACE_HANDLE handle,
01580 const void *buf,
01581 size_t len,
01582 size_t *bt)
01583 {
01584 size_t temp;
01585 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01586 ssize_t n;
01587
01588 for (bytes_transferred = 0;
01589 bytes_transferred < len;
01590 bytes_transferred += n)
01591 {
01592
01593 n = ACE::send_i (handle,
01594 (char *) buf + bytes_transferred,
01595 len - bytes_transferred);
01596
01597 if (n == 0)
01598 {
01599 return 0;
01600 }
01601
01602
01603 if (n == -1)
01604 {
01605
01606 if (errno == EWOULDBLOCK || errno == ENOBUFS)
01607 {
01608
01609 int const result = ACE::handle_write_ready (handle, 0);
01610
01611
01612 if (result != -1)
01613 {
01614
01615 n = 0;
01616 continue;
01617 }
01618 }
01619
01620
01621 return -1;
01622 }
01623 }
01624
01625 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01626 }
01627
01628 ssize_t
01629 ACE::send_n_i (ACE_HANDLE handle,
01630 const void *buf,
01631 size_t len,
01632 const ACE_Time_Value *timeout,
01633 size_t *bt)
01634 {
01635 size_t temp;
01636 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01637 ssize_t n;
01638 ssize_t result = 0;
01639 int error = 0;
01640
01641 int val = 0;
01642 ACE::record_and_set_non_blocking_mode (handle, val);
01643
01644 for (bytes_transferred = 0;
01645 bytes_transferred < len;
01646 bytes_transferred += n)
01647 {
01648
01649
01650
01651 n = ACE::send_i (handle,
01652 (char *) buf + bytes_transferred,
01653 len - bytes_transferred);
01654
01655
01656 if (n == 0 ||
01657 n == -1)
01658 {
01659
01660 if (n == -1 &&
01661 (errno == EWOULDBLOCK || errno == ENOBUFS))
01662 {
01663
01664 int const rtn = ACE::handle_write_ready (handle, timeout);
01665
01666
01667 if (rtn != -1)
01668 {
01669
01670
01671 n = 0;
01672 continue;
01673 }
01674 }
01675
01676
01677
01678 error = 1;
01679 result = n;
01680 break;
01681 }
01682 }
01683
01684 ACE::restore_non_blocking_mode (handle, val);
01685
01686 if (error)
01687 {
01688 return result;
01689 }
01690 else
01691 {
01692 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01693 }
01694 }
01695
01696
01697
01698
01699
01700
01701 ssize_t
01702 ACE::send (ACE_HANDLE handle, size_t n, ...)
01703 {
01704 va_list argp;
01705 int total_tuples = static_cast<int> (n / 2);
01706 iovec *iovp;
01707 #if defined (ACE_HAS_ALLOCA)
01708 iovp = (iovec *) alloca (total_tuples * sizeof (iovec));
01709 #else
01710 ACE_NEW_RETURN (iovp,
01711 iovec[total_tuples],
01712 -1);
01713 #endif
01714
01715 va_start (argp, n);
01716
01717 for (int i = 0; i < total_tuples; i++)
01718 {
01719 iovp[i].iov_base = va_arg (argp, char *);
01720 iovp[i].iov_len = va_arg (argp, int);
01721 }
01722
01723 ssize_t result = ACE_OS::sendv (handle, iovp, total_tuples);
01724 #if !defined (ACE_HAS_ALLOCA)
01725 delete [] iovp;
01726 #endif
01727 va_end (argp);
01728 return result;
01729 }
01730
01731 ssize_t
01732 ACE::sendv (ACE_HANDLE handle,
01733 const iovec *iov,
01734 int iovcnt,
01735 const ACE_Time_Value *timeout)
01736 {
01737 if (timeout == 0)
01738 return ACE_OS::sendv (handle, iov, iovcnt);
01739 else
01740 {
01741 int val = 0;
01742 if (ACE::enter_send_timedwait (handle, timeout, val) == -1)
01743 return -1;
01744 else
01745 {
01746 ssize_t bytes_transferred = ACE_OS::sendv (handle, iov, iovcnt);
01747 ACE::restore_non_blocking_mode (handle, val);
01748 return bytes_transferred;
01749 }
01750 }
01751 }
01752
01753 ssize_t
01754 ACE::sendv_n_i (ACE_HANDLE handle,
01755 const iovec *i,
01756 int iovcnt,
01757 size_t *bt)
01758 {
01759 size_t temp;
01760 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01761 bytes_transferred = 0;
01762
01763 iovec *iov = const_cast<iovec *> (i);
01764
01765 for (int s = 0;
01766 s < iovcnt;
01767 )
01768 {
01769
01770 ssize_t n = ACE_OS::sendv (handle, iov + s, iovcnt - s);
01771
01772
01773 if (n == 0)
01774 return 0;
01775
01776
01777 if (n == -1)
01778 {
01779
01780 if (errno == EWOULDBLOCK || errno == ENOBUFS)
01781 {
01782
01783 int const result = ACE::handle_write_ready (handle, 0);
01784
01785
01786 if (result != -1)
01787 {
01788
01789 n = 0;
01790 continue;
01791 }
01792 }
01793
01794
01795 return -1;
01796 }
01797
01798 for (bytes_transferred += n;
01799 s < iovcnt
01800 && n >= static_cast<ssize_t> (iov[s].iov_len);
01801 s++)
01802 n -= iov[s].iov_len;
01803
01804 if (n != 0)
01805 {
01806 char *base = reinterpret_cast<char *> (iov[s].iov_base);
01807 iov[s].iov_base = base + n;
01808 iov[s].iov_len = iov[s].iov_len - n;
01809 }
01810 }
01811
01812 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01813 }
01814
01815 ssize_t
01816 ACE::sendv_n_i (ACE_HANDLE handle,
01817 const iovec *i,
01818 int iovcnt,
01819 const ACE_Time_Value *timeout,
01820 size_t *bt)
01821 {
01822 size_t temp;
01823 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01824 bytes_transferred = 0;
01825 ssize_t result = 0;
01826 int error = 0;
01827
01828 int val = 0;
01829 ACE::record_and_set_non_blocking_mode (handle, val);
01830
01831 iovec *iov = const_cast<iovec *> (i);
01832
01833 for (int s = 0;
01834 s < iovcnt;
01835 )
01836 {
01837
01838
01839
01840 ssize_t n = ACE_OS::sendv (handle, iov + s, iovcnt - s);
01841
01842
01843 if (n == 0 ||
01844 n == -1)
01845 {
01846
01847 if (n == -1 &&
01848 (errno == EWOULDBLOCK || errno == ENOBUFS))
01849 {
01850
01851 int const rtn = ACE::handle_write_ready (handle, timeout);
01852
01853
01854 if (rtn != -1)
01855 {
01856
01857
01858 n = 0;
01859 continue;
01860 }
01861 }
01862
01863
01864
01865 error = 1;
01866 result = n;
01867 break;
01868 }
01869
01870 for (bytes_transferred += n;
01871 s < iovcnt
01872 && n >= static_cast<ssize_t> (iov[s].iov_len);
01873 s++)
01874 n -= iov[s].iov_len;
01875
01876 if (n != 0)
01877 {
01878 char *base = reinterpret_cast<char *> (iov[s].iov_base);
01879 iov[s].iov_base = base + n;
01880 iov[s].iov_len = iov[s].iov_len - n;
01881 }
01882 }
01883
01884 ACE::restore_non_blocking_mode (handle, val);
01885
01886 if (error)
01887 {
01888 return result;
01889 }
01890 else
01891 {
01892 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01893 }
01894 }
01895
01896 ssize_t
01897 ACE::write_n (ACE_HANDLE handle,
01898 const ACE_Message_Block *message_block,
01899 size_t *bt)
01900 {
01901 size_t temp;
01902 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01903 bytes_transferred = 0;
01904
01905 iovec iov[ACE_IOV_MAX];
01906 int iovcnt = 0;
01907
01908 while (message_block != 0)
01909 {
01910
01911 const ACE_Message_Block *current_message_block = message_block;
01912
01913 while (current_message_block != 0)
01914 {
01915 size_t current_message_block_length =
01916 current_message_block->length ();
01917 char *this_block_ptr = current_message_block->rd_ptr ();
01918
01919
01920 while (current_message_block_length > 0)
01921 {
01922 u_long const this_chunk_length =
01923 ACE_Utils::truncate_cast<u_long> (
01924 current_message_block_length);
01925
01926
01927 iov[iovcnt].iov_base = this_block_ptr;
01928 iov[iovcnt].iov_len = this_chunk_length;
01929 current_message_block_length -= this_chunk_length;
01930 this_block_ptr += this_chunk_length;
01931
01932
01933 ++iovcnt;
01934
01935
01936
01937
01938
01939 if (iovcnt == ACE_IOV_MAX)
01940 {
01941 size_t current_transfer = 0;
01942
01943 ssize_t const result = ACE::writev_n (handle,
01944 iov,
01945 iovcnt,
01946 ¤t_transfer);
01947
01948
01949 bytes_transferred += current_transfer;
01950
01951
01952 if (result == -1 || result == 0)
01953 return result;
01954
01955
01956 iovcnt = 0;
01957 }
01958 }
01959
01960
01961 current_message_block = current_message_block->cont ();
01962 }
01963
01964
01965 message_block = message_block->next ();
01966 }
01967
01968
01969
01970 if (iovcnt != 0)
01971 {
01972 size_t current_transfer = 0;
01973
01974 ssize_t const result = ACE::writev_n (handle,
01975 iov,
01976 iovcnt,
01977 ¤t_transfer);
01978
01979
01980 bytes_transferred += current_transfer;
01981
01982
01983 if (result == -1 || result == 0)
01984 return result;
01985 }
01986
01987
01988 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
01989 }
01990
01991 ssize_t
01992 ACE::send_n (ACE_HANDLE handle,
01993 const ACE_Message_Block *message_block,
01994 const ACE_Time_Value *timeout,
01995 size_t *bt)
01996 {
01997 size_t temp;
01998 size_t &bytes_transferred = bt == 0 ? temp : *bt;
01999 bytes_transferred = 0;
02000
02001 iovec iov[ACE_IOV_MAX];
02002 int iovcnt = 0;
02003
02004 while (message_block != 0)
02005 {
02006
02007 const ACE_Message_Block *current_message_block = message_block;
02008
02009 while (current_message_block != 0)
02010 {
02011 char *this_block_ptr = current_message_block->rd_ptr ();
02012 size_t current_message_block_length =
02013 current_message_block->length ();
02014
02015
02016 while (current_message_block_length > 0)
02017 {
02018 u_long const this_chunk_length =
02019 ACE_Utils::truncate_cast<u_long> (
02020 current_message_block_length);
02021
02022
02023 iov[iovcnt].iov_base = this_block_ptr;
02024 iov[iovcnt].iov_len = this_chunk_length;
02025 current_message_block_length -= this_chunk_length;
02026 this_block_ptr += this_chunk_length;
02027
02028
02029 ++iovcnt;
02030
02031
02032
02033
02034
02035 if (iovcnt == ACE_IOV_MAX)
02036 {
02037 size_t current_transfer = 0;
02038
02039 ssize_t const result = ACE::sendv_n (handle,
02040 iov,
02041 iovcnt,
02042 timeout,
02043 ¤t_transfer);
02044
02045
02046 bytes_transferred += current_transfer;
02047
02048
02049 if (result == -1 || result == 0)
02050 return result;
02051
02052
02053 iovcnt = 0;
02054 }
02055 }
02056
02057
02058 current_message_block = current_message_block->cont ();
02059 }
02060
02061
02062 message_block = message_block->next ();
02063 }
02064
02065
02066
02067 if (iovcnt != 0)
02068 {
02069 size_t current_transfer = 0;
02070
02071 ssize_t const result = ACE::sendv_n (handle,
02072 iov,
02073 iovcnt,
02074 timeout,
02075 ¤t_transfer);
02076
02077
02078 bytes_transferred += current_transfer;
02079
02080
02081 if (result == -1 || result == 0)
02082 {
02083 return result;
02084 }
02085 }
02086
02087
02088 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
02089 }
02090
02091 ssize_t
02092 ACE::readv_n (ACE_HANDLE handle,
02093 iovec *iov,
02094 int iovcnt,
02095 size_t *bt)
02096 {
02097 size_t temp;
02098 size_t &bytes_transferred = bt == 0 ? temp : *bt;
02099 bytes_transferred = 0;
02100
02101 for (int s = 0;
02102 s < iovcnt;
02103 )
02104 {
02105 ssize_t n = ACE_OS::readv (handle,
02106 iov + s,
02107 iovcnt - s);
02108
02109 if (n == -1 || n == 0)
02110 return n;
02111
02112 for (bytes_transferred += n;
02113 s < iovcnt
02114 && n >= static_cast<ssize_t> (iov[s].iov_len);
02115 s++)
02116 n -= iov[s].iov_len;
02117
02118 if (n != 0)
02119 {
02120 char *base = reinterpret_cast<char *> (iov[s].iov_base);
02121 iov[s].iov_base = base + n;
02122 iov[s].iov_len = iov[s].iov_len - n;
02123 }
02124 }
02125
02126 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
02127 }
02128
02129 ssize_t
02130 ACE::writev_n (ACE_HANDLE handle,
02131 const iovec *i,
02132 int iovcnt,
02133 size_t *bt)
02134 {
02135 size_t temp;
02136 size_t &bytes_transferred = bt == 0 ? temp : *bt;
02137 bytes_transferred = 0;
02138
02139 iovec *iov = const_cast<iovec *> (i);
02140
02141 for (int s = 0;
02142 s < iovcnt;
02143 )
02144 {
02145 ssize_t n = ACE_OS::writev (handle,
02146 iov + s,
02147 iovcnt - s);
02148
02149 if (n == -1 || n == 0)
02150 {
02151 return n;
02152 }
02153
02154 for (bytes_transferred += n;
02155 s < iovcnt
02156 && n >= static_cast<ssize_t> (iov[s].iov_len);
02157 s++)
02158 n -= iov[s].iov_len;
02159
02160 if (n != 0)
02161 {
02162 char *base = reinterpret_cast<char *> (iov[s].iov_base);
02163 iov[s].iov_base = base + n;
02164 iov[s].iov_len = iov[s].iov_len - n;
02165 }
02166 }
02167
02168 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
02169 }
02170
02171 int
02172 ACE::handle_ready (ACE_HANDLE handle,
02173 const ACE_Time_Value *timeout,
02174 int read_ready,
02175 int write_ready,
02176 int exception_ready)
02177 {
02178 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
02179 ACE_UNUSED_ARG (write_ready);
02180 ACE_UNUSED_ARG (exception_ready);
02181
02182 struct pollfd fds;
02183
02184 fds.fd = handle;
02185 fds.events = read_ready ? POLLIN : POLLOUT;
02186 fds.revents = 0;
02187
02188 int result = ACE_OS::poll (&fds, 1, timeout);
02189 #else
02190 ACE_Handle_Set handle_set;
02191 handle_set.set_bit (handle);
02192
02193
02194 int select_width;
02195 # if defined (ACE_WIN32)
02196
02197
02198 select_width = 0;
02199 # else
02200 select_width = int (handle) + 1;
02201 # endif
02202 int result = ACE_OS::select (select_width,
02203 read_ready ? handle_set.fdset () : 0,
02204 write_ready ? handle_set.fdset () : 0,
02205 exception_ready ? handle_set.fdset () : 0,
02206 timeout);
02207
02208 #endif
02209
02210 switch (result)
02211 {
02212 case 0:
02213 errno = ETIME;
02214
02215 case -1:
02216 return -1;
02217 case 1:
02218
02219 default:
02220
02221 return result;
02222 }
02223 }
02224
02225 int
02226 ACE::enter_recv_timedwait (ACE_HANDLE handle,
02227 const ACE_Time_Value *timeout,
02228 int &val)
02229 {
02230 int result = ACE::handle_read_ready (handle,
02231 timeout);
02232
02233 if (result == -1)
02234 return -1;
02235
02236 ACE::record_and_set_non_blocking_mode (handle,
02237 val);
02238
02239 return result;
02240 }
02241
02242 int
02243 ACE::enter_send_timedwait (ACE_HANDLE handle,
02244 const ACE_Time_Value *timeout,
02245 int &val)
02246 {
02247 int result = ACE::handle_write_ready (handle,
02248 timeout);
02249
02250 if (result == -1)
02251 return -1;
02252
02253 ACE::record_and_set_non_blocking_mode (handle,
02254 val);
02255
02256 return result;
02257 }
02258
02259 void
02260 ACE::record_and_set_non_blocking_mode (ACE_HANDLE handle,
02261 int &val)
02262 {
02263
02264
02265 val = ACE::get_flags (handle);
02266
02267 if (ACE_BIT_DISABLED (val, ACE_NONBLOCK))
02268
02269
02270 ACE::set_flags (handle, ACE_NONBLOCK);
02271 }
02272
02273 void
02274 ACE::restore_non_blocking_mode (ACE_HANDLE handle,
02275 int val)
02276 {
02277 if (ACE_BIT_DISABLED (val,
02278 ACE_NONBLOCK))
02279 {
02280
02281 ACE_Errno_Guard error (errno);
02282
02283
02284 ACE::clr_flags (handle, ACE_NONBLOCK);
02285 }
02286 }
02287
02288
02289
02290
02291
02292
02293 size_t
02294 ACE::format_hexdump (const char *buffer,
02295 size_t size,
02296 ACE_TCHAR *obuf,
02297 size_t obuf_sz)
02298 {
02299 ACE_TRACE ("ACE::format_hexdump");
02300
02301 u_char c;
02302 ACE_TCHAR textver[16 + 1];
02303
02304
02305 size_t maxlen = (obuf_sz / 68) * 16;
02306
02307 if (size > maxlen)
02308 size = maxlen;
02309
02310 size_t i;
02311
02312 size_t const lines = size / 16;
02313 for (i = 0; i < lines; i++)
02314 {
02315 size_t j;
02316
02317 for (j = 0 ; j < 16; j++)
02318 {
02319 c = (u_char) buffer[(i << 4) + j];
02320 ACE_OS::sprintf (obuf,
02321 ACE_TEXT ("%02x "),
02322 c);
02323 obuf += 3;
02324 if (j == 7)
02325 {
02326 ACE_OS::sprintf (obuf,
02327 ACE_TEXT (" "));
02328 ++obuf;
02329 }
02330 textver[j] = ACE_OS::ace_isprint (c) ? c : '.';
02331 }
02332
02333 textver[j] = 0;
02334
02335 ACE_OS::sprintf (obuf,
02336 #if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
02337 ACE_TEXT (" %ls\n"),
02338 #else
02339 ACE_TEXT (" %s\n"),
02340 #endif
02341 textver);
02342
02343 while (*obuf != '\0')
02344 ++obuf;
02345 }
02346
02347 if (size % 16)
02348 {
02349 for (i = 0 ; i < size % 16; i++)
02350 {
02351 c = (u_char) buffer[size - size % 16 + i];
02352 ACE_OS::sprintf (obuf,
02353 ACE_TEXT ("%02x "),
02354 c);
02355 obuf += 3;
02356 if (i == 7)
02357 {
02358 ACE_OS::sprintf (obuf,
02359 ACE_TEXT (" "));
02360 ++obuf;
02361 }
02362 textver[i] = ACE_OS::ace_isprint (c) ? c : '.';
02363 }
02364
02365 for (i = size % 16; i < 16; i++)
02366 {
02367 ACE_OS::sprintf (obuf,
02368 ACE_TEXT (" "));
02369 obuf += 3;
02370 if (i == 7)
02371 {
02372 ACE_OS::sprintf (obuf,
02373 ACE_TEXT (" "));
02374 ++obuf;
02375 }
02376 textver[i] = ' ';
02377 }
02378
02379 textver[i] = 0;
02380 ACE_OS::sprintf (obuf,
02381 #if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
02382 ACE_TEXT (" %ls\n"),
02383 #else
02384 ACE_TEXT (" %s\n"),
02385 #endif
02386 textver);
02387 }
02388 return size;
02389 }
02390
02391
02392
02393
02394
02395 ACE_TCHAR *
02396 ACE::timestamp (ACE_TCHAR date_and_time[],
02397 size_t date_and_timelen,
02398 bool return_pointer_to_first_digit)
02399 {
02400 return ACE::timestamp (ACE_Time_Value::zero,
02401 date_and_time,
02402 date_and_timelen,
02403 return_pointer_to_first_digit);
02404 }
02405
02406
02407
02408
02409
02410 ACE_TCHAR *
02411 ACE::timestamp (const ACE_Time_Value& time_value,
02412 ACE_TCHAR date_and_time[],
02413 size_t date_and_timelen,
02414 bool return_pointer_to_first_digit)
02415 {
02416
02417
02418 if (date_and_timelen < 35)
02419 {
02420 errno = EINVAL;
02421 return 0;
02422 }
02423
02424 #if defined (WIN32)
02425 if (time_value == ACE_Time_Value::zero)
02426 {
02427
02428
02429 static const ACE_TCHAR *day_of_week_name[] =
02430 {
02431 ACE_TEXT ("Sun"),
02432 ACE_TEXT ("Mon"),
02433 ACE_TEXT ("Tue"),
02434 ACE_TEXT ("Wed"),
02435 ACE_TEXT ("Thu"),
02436 ACE_TEXT ("Fri"),
02437 ACE_TEXT ("Sat")
02438 };
02439
02440 static const ACE_TCHAR *month_name[] =
02441 {
02442 ACE_TEXT ("Jan"),
02443 ACE_TEXT ("Feb"),
02444 ACE_TEXT ("Mar"),
02445 ACE_TEXT ("Apr"),
02446 ACE_TEXT ("May"),
02447 ACE_TEXT ("Jun"),
02448 ACE_TEXT ("Jul"),
02449 ACE_TEXT ("Aug"),
02450 ACE_TEXT ("Sep"),
02451 ACE_TEXT ("Oct"),
02452 ACE_TEXT ("Nov"),
02453 ACE_TEXT ("Dec")
02454 };
02455
02456 SYSTEMTIME local;
02457 ::GetLocalTime (&local);
02458
02459 ACE_OS::sprintf (date_and_time,
02460 ACE_TEXT ("%3s %3s %2d %04d %02d:%02d:%02d.%06d"),
02461 day_of_week_name[local.wDayOfWeek],
02462 month_name[local.wMonth - 1],
02463 (int) local.wDay,
02464 (int) local.wYear,
02465 (int) local.wHour,
02466 (int) local.wMinute,
02467 (int) local.wSecond,
02468 (int) (local.wMilliseconds * 1000));
02469 return &date_and_time[15 + (return_pointer_to_first_digit != 0)];
02470 }
02471 #endif
02472 ACE_TCHAR timebuf[26];
02473 ACE_Time_Value cur_time =
02474 (time_value == ACE_Time_Value::zero) ?
02475 ACE_Time_Value (ACE_OS::gettimeofday ()) : time_value;
02476 time_t secs = cur_time.sec ();
02477
02478 ACE_OS::ctime_r (&secs,
02479 timebuf,
02480 sizeof timebuf / sizeof (ACE_TCHAR));
02481
02482 ACE_OS::strsncpy (date_and_time,
02483 timebuf,
02484 date_and_timelen);
02485 ACE_TCHAR yeartmp[5];
02486 ACE_OS::strsncpy (yeartmp,
02487 &date_and_time[20],
02488 5);
02489 ACE_TCHAR timetmp[9];
02490 ACE_OS::strsncpy (timetmp,
02491 &date_and_time[11],
02492 9);
02493 ACE_OS::sprintf (&date_and_time[11],
02494 # if defined (ACE_USES_WCHAR)
02495 ACE_TEXT ("%ls %ls.%06ld"),
02496 # else
02497 ACE_TEXT ("%s %s.%06ld"),
02498 # endif
02499 yeartmp,
02500 timetmp,
02501 cur_time.usec ());
02502 date_and_time[33] = '\0';
02503 return &date_and_time[15 + (return_pointer_to_first_digit != 0)];
02504 }
02505
02506
02507
02508 size_t
02509 ACE::round_to_pagesize (size_t len)
02510 {
02511 ACE_TRACE ("ACE::round_to_pagesize");
02512
02513 if (ACE::pagesize_ == 0)
02514 ACE::pagesize_ = ACE_OS::getpagesize ();
02515
02516 return (len + (ACE::pagesize_ - 1)) & ~(ACE::pagesize_ - 1);
02517 }
02518
02519 size_t
02520 ACE::round_to_allocation_granularity (size_t len)
02521 {
02522 ACE_TRACE ("ACE::round_to_allocation_granularity");
02523
02524 if (ACE::allocation_granularity_ == 0)
02525 ACE::allocation_granularity_ = ACE_OS::allocation_granularity ();
02526
02527 return (len + (ACE::allocation_granularity_ - 1)) & ~(ACE::allocation_granularity_ - 1);
02528 }
02529
02530 ACE_HANDLE
02531 ACE::handle_timed_complete (ACE_HANDLE h,
02532 const ACE_Time_Value *timeout,
02533 int is_tli)
02534 {
02535 ACE_TRACE ("ACE::handle_timed_complete");
02536
02537 #if !defined (ACE_WIN32) && defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
02538
02539 struct pollfd fds;
02540
02541 fds.fd = h;
02542 fds.events = POLLIN | POLLOUT;
02543 fds.revents = 0;
02544
02545 #else
02546 ACE_Handle_Set rd_handles;
02547 ACE_Handle_Set wr_handles;
02548 rd_handles.set_bit (h);
02549 wr_handles.set_bit (h);
02550 #endif
02551
02552 #if defined (ACE_WIN32)
02553
02554
02555
02556 ACE_Handle_Set ex_handles;
02557 ex_handles.set_bit (h);
02558 #endif
02559
02560 bool need_to_check = false;
02561 bool known_failure = false;
02562
02563 #if defined (ACE_WIN32)
02564 int n = ACE_OS::select (0,
02565 0,
02566 wr_handles,
02567 ex_handles,
02568 timeout);
02569 #else
02570 # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
02571
02572 int n = ACE_OS::poll (&fds, 1, timeout);
02573
02574 # else
02575 int n = 0;
02576 if (is_tli)
02577 n = ACE_OS::select (int (h) + 1,
02578 rd_handles,
02579 wr_handles,
02580 0,
02581 timeout);
02582 else
02583 n = ACE_OS::select (int (h) + 1,
02584 0,
02585 wr_handles,
02586 0,
02587 timeout);
02588 # endif
02589 #endif
02590
02591
02592
02593
02594 if (n <= 0)
02595 {
02596 if (n == 0 && timeout != 0)
02597 errno = ETIME;
02598 return ACE_INVALID_HANDLE;
02599 }
02600
02601
02602
02603
02604
02605
02606
02607
02608
02609 #if defined (ACE_WIN32)
02610 ACE_UNUSED_ARG (is_tli);
02611
02612
02613
02614
02615 if (ex_handles.is_set (h))
02616 {
02617 need_to_check = true;
02618 known_failure = true;
02619 }
02620 #else
02621 if (is_tli)
02622 # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
02623 need_to_check = (fds.revents & POLLIN) && !(fds.revents & POLLOUT);
02624 # else
02625 need_to_check = rd_handles.is_set (h) && !wr_handles.is_set (h);
02626 # endif
02627
02628 else
02629 # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
02630 need_to_check = (fds.revents & POLLIN);
02631 # else
02632 need_to_check = true;
02633 # endif
02634 #endif
02635
02636 if (need_to_check)
02637 {
02638 #if defined (SOL_SOCKET) && defined (SO_ERROR)
02639 int sock_err = 0;
02640 int sock_err_len = sizeof (sock_err);
02641 int sockopt_ret = ACE_OS::getsockopt (h, SOL_SOCKET, SO_ERROR,
02642 (char *)&sock_err, &sock_err_len);
02643 if (sockopt_ret < 0)
02644 {
02645 h = ACE_INVALID_HANDLE;
02646 }
02647
02648 if (sock_err != 0 || known_failure)
02649 {
02650 h = ACE_INVALID_HANDLE;
02651 errno = sock_err;
02652 }
02653 #else
02654 char dummy;
02655
02656
02657
02658 n = ACE::recv (h, &dummy, 1, MSG_PEEK);
02659
02660
02661
02662
02663 if (n <= 0)
02664 {
02665 if (n == 0)
02666 {
02667 errno = ECONNREFUSED;
02668 h = ACE_INVALID_HANDLE;
02669 }
02670 else if (errno != EWOULDBLOCK && errno != EAGAIN)
02671 h = ACE_INVALID_HANDLE;
02672 }
02673 #endif
02674 }
02675
02676
02677
02678
02679
02680 return h;
02681 }
02682
02683
02684
02685 int
02686 ACE::handle_timed_accept (ACE_HANDLE listener,
02687 ACE_Time_Value *timeout,
02688 bool restart)
02689 {
02690 ACE_TRACE ("ACE::handle_timed_accept");
02691
02692 if (listener == ACE_INVALID_HANDLE)
02693 return -1;
02694
02695 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
02696
02697 struct pollfd fds;
02698
02699 fds.fd = listener;
02700 fds.events = POLLIN;
02701 fds.revents = 0;
02702
02703 #else
02704
02705 ACE_Handle_Set rd_handle;
02706 rd_handle.set_bit (listener);
02707 #endif
02708
02709
02710
02711 for (;;)
02712 {
02713 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
02714
02715 int n = ACE_OS::poll (&fds, 1, timeout);
02716
02717 #else
02718 int select_width;
02719 # if defined (ACE_WIN32)
02720
02721
02722 select_width = 0;
02723 # else
02724 select_width = int (listener) + 1;
02725 # endif
02726 int n = ACE_OS::select (select_width,
02727 rd_handle, 0, 0,
02728 timeout);
02729 #endif
02730
02731 switch (n)
02732 {
02733 case -1:
02734 if (errno == EINTR && restart)
02735 continue;
02736 else
02737 return -1;
02738
02739 case 0:
02740 if (timeout != 0 && *timeout == ACE_Time_Value::zero)
02741 errno = EWOULDBLOCK;
02742 else
02743 errno = ETIMEDOUT;
02744 return -1;
02745
02746 case 1:
02747 return 0;
02748
02749 default:
02750 errno = EINVAL;
02751 return -1;
02752
02753 }
02754 }
02755 }
02756
02757
02758
02759
02760 int
02761 ACE::daemonize (const ACE_TCHAR pathname[],
02762 bool close_all_handles,
02763 const ACE_TCHAR program_name[])
02764 {
02765 ACE_TRACE ("ACE::daemonize");
02766 #if !defined (ACE_LACKS_FORK)
02767 pid_t pid = ACE_OS::fork ();
02768
02769 if (pid == -1)
02770 return -1;
02771 else if (pid != 0)
02772 ACE_OS::exit (0);
02773
02774
02775 ACE_OS::setsid ();
02776
02777 ACE_OS::signal (SIGHUP, SIG_IGN);
02778
02779 pid = ACE_OS::fork (program_name);
02780
02781 if (pid != 0)
02782 ACE_OS::exit (0);
02783
02784
02785
02786 if (pathname != 0)
02787
02788 ACE_OS::chdir (pathname);
02789
02790 ACE_OS::umask (0);
02791
02792
02793 if (close_all_handles)
02794 {
02795 for (int i = ACE::max_handles () - 1; i >= 0; i--)
02796 ACE_OS::close (i);
02797
02798 int fd = ACE_OS::open ("/dev/null", O_RDWR, 0);
02799 if (fd != -1)
02800 {
02801 ACE_OS::dup2 (fd, ACE_STDIN);
02802 ACE_OS::dup2 (fd, ACE_STDOUT);
02803 ACE_OS::dup2 (fd, ACE_STDERR);
02804
02805 if (fd > ACE_STDERR)
02806 ACE_OS::close (fd);
02807 }
02808 }
02809
02810 return 0;
02811 #else
02812 ACE_UNUSED_ARG (pathname);
02813 ACE_UNUSED_ARG (close_all_handles);
02814 ACE_UNUSED_ARG (program_name);
02815
02816 ACE_NOTSUP_RETURN (-1);
02817 #endif
02818 }
02819
02820 pid_t
02821 ACE::fork (const ACE_TCHAR *program_name,
02822 int avoid_zombies)
02823 {
02824 if (avoid_zombies == 0)
02825 return ACE_OS::fork (program_name);
02826 else
02827 {
02828
02829
02830
02831
02832
02833
02834
02835
02836
02837 pid_t pid = ACE_OS::fork ();
02838 if (pid == 0)
02839 {
02840
02841 switch (ACE_OS::fork (program_name))
02842 {
02843 case 0:
02844 return 0;
02845 case -1:
02846 ACE_OS::_exit (errno);
02847 default:
02848 ACE_OS::_exit (0);
02849 }
02850 }
02851
02852
02853 ACE_exitcode status;
02854 if (pid < 0 || ACE_OS::waitpid (pid, &status, 0) < 0)
02855 return -1;
02856
02857
02858 if (WIFEXITED ((status)))
02859 {
02860
02861 if (WEXITSTATUS ((status)) == 0)
02862 return 1;
02863 else
02864 errno = WEXITSTATUS ((status));
02865 }
02866 else
02867
02868 errno = EINTR;
02869
02870 return -1;
02871 }
02872 }
02873
02874 int
02875 ACE::max_handles (void)
02876 {
02877 ACE_TRACE ("ACE::max_handles");
02878 #if defined (RLIMIT_NOFILE) && !defined (ACE_LACKS_RLIMIT)
02879 rlimit rl;
02880 int const r = ACE_OS::getrlimit (RLIMIT_NOFILE, &rl);
02881 # if !defined (RLIM_INFINITY)
02882 if (r == 0)
02883 return rl.rlim_cur;
02884 # else
02885 if (r == 0 && rl.rlim_cur != RLIM_INFINITY)
02886 return rl.rlim_cur;
02887
02888 # endif
02889 #endif
02890
02891 #if defined (_SC_OPEN_MAX)
02892 return ACE_OS::sysconf (_SC_OPEN_MAX);
02893 #elif defined (ACE_VXWORKS) && (ACE_VXWORKS < 0x620)
02894 return maxFiles;
02895 #elif defined (FD_SETSIZE)
02896 return FD_SETSIZE;
02897 #else
02898 ACE_NOTSUP_RETURN (-1);
02899 #endif
02900 }
02901
02902
02903
02904
02905
02906
02907 int
02908 ACE::set_handle_limit (int new_limit,
02909 int increase_limit_only)
02910 {
02911 ACE_TRACE ("ACE::set_handle_limit");
02912 int cur_limit = ACE::max_handles ();
02913 int max_limit = cur_limit;
02914
02915 if (cur_limit == -1)
02916 return -1;
02917
02918 #if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE)
02919 struct rlimit rl;
02920
02921 ACE_OS::memset ((void *) &rl, 0, sizeof rl);
02922 int r = ACE_OS::getrlimit (RLIMIT_NOFILE, &rl);
02923 if (r == 0)
02924 max_limit = rl.rlim_max;
02925 #endif
02926
02927 if (new_limit == -1)
02928 new_limit = max_limit;
02929
02930 if (new_limit < 0)
02931 {
02932 errno = EINVAL;
02933 return -1;
02934 }
02935 else if (new_limit > cur_limit)
02936 {
02937
02938 #if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE)
02939 rl.rlim_cur = new_limit;
02940 return ACE_OS::setrlimit (RLIMIT_NOFILE, &rl);
02941 #elif defined (ACE_LACKS_RLIMIT_NOFILE)
02942 return 0;
02943 #else
02944
02945 ACE_NOTSUP_RETURN (-1);
02946 #endif
02947 }
02948 else if (increase_limit_only == 0)
02949 {
02950
02951 #if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE)
02952 rl.rlim_cur = new_limit;
02953 return ACE_OS::setrlimit (RLIMIT_NOFILE, &rl);
02954 #else
02955
02956
02957
02958 return 0;
02959 #endif
02960 }
02961
02962 return 0;
02963 }
02964
02965
02966 u_long
02967 ACE::gcd (u_long x, u_long y)
02968 {
02969 while (y != 0)
02970 {
02971 u_long r = x % y;
02972 x = y;
02973 y = r;
02974 }
02975
02976 return x;
02977 }
02978
02979
02980
02981 u_long
02982 ACE::minimum_frame_size (u_long period1, u_long period2)
02983 {
02984
02985
02986 if (0 == period1)
02987 {
02988 return period2;
02989 }
02990 if (0 == period2)
02991 {
02992 return period1;
02993 }
02994
02995
02996 u_long greatest_common_divisor = ACE::gcd (period1, period2);
02997
02998
02999 if (greatest_common_divisor == 1)
03000 {
03001
03002 return period1 * period2;
03003 }
03004 else if (greatest_common_divisor == period1)
03005 {
03006
03007 return period2;
03008 }
03009 else if (greatest_common_divisor == period2)
03010 {
03011
03012 return period1;
03013 }
03014 else
03015 {
03016
03017
03018
03019 return (period1 * period2) / greatest_common_divisor;
03020 }
03021 }
03022
03023
03024 u_long
03025 ACE::is_prime (const u_long n,
03026 const u_long min_factor,
03027 const u_long max_factor)
03028 {
03029 if (n > 3)
03030 for (u_long factor = min_factor;
03031 factor <= max_factor;
03032 ++factor)
03033 if (n / factor * factor == n)
03034 return factor;
03035
03036 return 0;
03037 }
03038
03039 const ACE_TCHAR *
03040 ACE::sock_error (int error)
03041 {
03042 #if defined (ACE_WIN32)
03043 static ACE_TCHAR unknown_msg[64];
03044
03045 switch (error)
03046 {
03047 case WSAVERNOTSUPPORTED:
03048 return ACE_TEXT ("version of WinSock not supported");
03049
03050 case WSASYSNOTREADY:
03051 return ACE_TEXT ("WinSock not present or not responding");
03052
03053 case WSAEINVAL:
03054 return ACE_TEXT ("app version not supported by DLL");
03055
03056 case WSAHOST_NOT_FOUND:
03057 return ACE_TEXT ("Authoritive: Host not found");
03058
03059 case WSATRY_AGAIN:
03060 return ACE_TEXT ("Non-authoritive: host not found or server failure");
03061
03062 case WSANO_RECOVERY:
03063 return ACE_TEXT ("Non-recoverable: refused or not implemented");
03064
03065 case WSANO_DATA:
03066 return ACE_TEXT ("Valid name, no data record for type");
03067
03068
03069
03070
03071
03072 case WSANOTINITIALISED:
03073 return ACE_TEXT ("WSA Startup not initialized");
03074
03075 case WSAENETDOWN:
03076 return ACE_TEXT ("Network subsystem failed");
03077
03078 case WSAEINPROGRESS:
03079 return ACE_TEXT ("Blocking operation in progress");
03080
03081 case WSAEINTR:
03082 return ACE_TEXT ("Blocking call cancelled");
03083
03084 case WSAEAFNOSUPPORT:
03085 return ACE_TEXT ("address family not supported");
03086
03087 case WSAEMFILE:
03088 return ACE_TEXT ("no file handles available");
03089
03090 case WSAENOBUFS:
03091 return ACE_TEXT ("no buffer space available");
03092
03093 case WSAEPROTONOSUPPORT:
03094 return ACE_TEXT ("specified protocol not supported");
03095
03096 case WSAEPROTOTYPE:
03097 return ACE_TEXT ("protocol wrong type for this socket");
03098
03099 case WSAESOCKTNOSUPPORT:
03100 return ACE_TEXT ("socket type not supported for address family");
03101
03102 case WSAENOTSOCK:
03103 return ACE_TEXT ("handle is not a socket");
03104
03105 case WSAEWOULDBLOCK:
03106 return ACE_TEXT ("resource temporarily unavailable");
03107
03108 case WSAEADDRINUSE:
03109 return ACE_TEXT ("address already in use");
03110
03111 case WSAECONNABORTED:
03112 return ACE_TEXT ("connection aborted");
03113
03114 case WSAECONNRESET:
03115 return ACE_TEXT ("connection reset");
03116
03117 case WSAENOTCONN:
03118 return ACE_TEXT ("not connected");
03119
03120 case WSAETIMEDOUT:
03121 return ACE_TEXT ("connection timed out");
03122
03123 case WSAECONNREFUSED:
03124 return ACE_TEXT ("connection refused");
03125
03126 case WSAEHOSTDOWN:
03127 return ACE_TEXT ("host down");
03128
03129 case WSAEHOSTUNREACH:
03130 return ACE_TEXT ("host unreachable");
03131
03132 case WSAEADDRNOTAVAIL:
03133 return ACE_TEXT ("address not available");
03134
03135 case WSAEISCONN:
03136 return ACE_TEXT ("socket is already connected");
03137
03138 case WSAENETRESET:
03139 return ACE_TEXT ("network dropped connection on reset");
03140
03141 case WSAEMSGSIZE:
03142 return ACE_TEXT ("message too long");
03143
03144 case WSAENETUNREACH:
03145 return ACE_TEXT ("network is unreachable");
03146
03147 case WSAEFAULT:
03148 return ACE_TEXT ("bad address");
03149
03150 case WSAEDISCON:
03151 return ACE_TEXT ("graceful shutdown in progress");
03152
03153 case WSAEACCES:
03154 return ACE_TEXT ("permission denied");
03155
03156 case WSAESHUTDOWN:
03157 return ACE_TEXT ("cannot send after socket shutdown");
03158
03159 case WSAEPROCLIM:
03160 return ACE_TEXT ("too many processes");
03161
03162 case WSAEALREADY:
03163 return ACE_TEXT ("operation already in progress");
03164
03165 case WSAEPFNOSUPPORT:
03166 return ACE_TEXT ("protocol family not supported");
03167
03168 case WSAENOPROTOOPT:
03169 return ACE_TEXT ("bad protocol option");
03170
03171 case WSATYPE_NOT_FOUND:
03172 return ACE_TEXT ("class type not found");
03173
03174 case WSAEOPNOTSUPP:
03175 return ACE_TEXT ("operation not supported");
03176
03177 case WSAEDESTADDRREQ:
03178 return ACE_TEXT ("destination address required");
03179
03180 default:
03181 ACE_OS::sprintf (unknown_msg, ACE_TEXT ("unknown error: %d"), error);
03182 return unknown_msg;
03183
03184 }
03185 #else
03186 ACE_UNUSED_ARG (error);
03187 ACE_NOTSUP_RETURN (0);
03188 #endif
03189 }
03190
03191 bool
03192 ACE::is_sock_error (int error)
03193 {
03194 #if defined (ACE_WIN32)
03195 switch (error)
03196 {
03197 case WSAVERNOTSUPPORTED:
03198 case WSASYSNOTREADY:
03199 case WSAEINVAL:
03200 case WSAHOST_NOT_FOUND:
03201 case WSATRY_AGAIN:
03202 case WSANO_RECOVERY:
03203 case WSANO_DATA:
03204
03205
03206
03207 case WSANOTINITIALISED:
03208 case WSAENETDOWN:
03209 case WSAEINPROGRESS:
03210 case WSAEINTR:
03211 case WSAEAFNOSUPPORT:
03212 case WSAEMFILE:
03213 case WSAENOBUFS:
03214 case WSAEPROTONOSUPPORT:
03215 case WSAEPROTOTYPE:
03216 case WSAESOCKTNOSUPPORT:
03217 case WSAENOTSOCK:
03218 case WSAEWOULDBLOCK:
03219 case WSAEADDRINUSE:
03220 case WSAECONNABORTED:
03221 case WSAECONNRESET:
03222 case WSAENOTCONN:
03223 case WSAETIMEDOUT:
03224 case WSAECONNREFUSED:
03225 case WSAEHOSTDOWN:
03226 case WSAEHOSTUNREACH:
03227 case WSAEADDRNOTAVAIL:
03228 case WSAEISCONN:
03229 case WSAENETRESET:
03230 case WSAEMSGSIZE:
03231 case WSAENETUNREACH:
03232 case WSAEFAULT:
03233 case WSAEDISCON:
03234 case WSAEACCES:
03235 case WSAESHUTDOWN:
03236 case WSAEPROCLIM:
03237 case WSAEALREADY:
03238 case WSAEPFNOSUPPORT:
03239 case WSAENOPROTOOPT:
03240 case WSATYPE_NOT_FOUND:
03241 case WSAEOPNOTSUPP:
03242 return true;
03243 }
03244 #else
03245 ACE_UNUSED_ARG (error);
03246 #endif
03247 return false;
03248 }
03249
03250 char *
03251 ACE::strndup (const char *str, size_t n)
03252 {
03253 const char *t = str;
03254 size_t len;
03255
03256
03257
03258
03259 for (len = 0;
03260 len < n && *t++ != '\0';
03261 len++)
03262 continue;
03263
03264 char *s;
03265 ACE_ALLOCATOR_RETURN (s,
03266 (char *) ACE_OS::malloc (len + 1),
03267 0);
03268 return ACE_OS::strsncpy (s, str, len + 1);
03269 }
03270
03271 #if defined (ACE_HAS_WCHAR)
03272 wchar_t *
03273 ACE::strndup (const wchar_t *str, size_t n)
03274 {
03275 const wchar_t *t = str;
03276 size_t len;
03277
03278
03279
03280
03281 for (len = 0;
03282 len < n && *t++ != '\0';
03283 len++)
03284 continue;
03285
03286 wchar_t *s;
03287 ACE_ALLOCATOR_RETURN (s,
03288 static_cast<wchar_t *> (
03289 ACE_OS::malloc ((len + 1) * sizeof (wchar_t))),
03290 0);
03291 return ACE_OS::strsncpy (s, str, len + 1);
03292 }
03293 #endif
03294
03295 char *
03296 ACE::strnnew (const char *str, size_t n)
03297 {
03298 const char *t = str;
03299 size_t len;
03300
03301
03302
03303
03304 for (len = 0;
03305 len < n && *t++ != L'\0';
03306 len++)
03307 continue;
03308
03309 char *s;
03310 ACE_NEW_RETURN (s,
03311 char[len + 1],
03312 0);
03313 return ACE_OS::strsncpy (s, str, len + 1);
03314 }
03315
03316 #if defined (ACE_HAS_WCHAR)
03317 wchar_t *
03318 ACE::strnnew (const wchar_t *str, size_t n)
03319 {
03320 const wchar_t *t = str;
03321 size_t len;
03322
03323
03324
03325
03326 for (len = 0;
03327 len < n && *t++ != ACE_TEXT_WIDE ('\0');
03328 len++)
03329 continue;
03330
03331 wchar_t *s;
03332 ACE_NEW_RETURN (s,
03333 wchar_t[len + 1],
03334 0);
03335 return ACE_OS::strsncpy (s, str, len + 1);
03336 }
03337 #endif
03338
03339 const char *
03340 ACE::strend (const char *s)
03341 {
03342 while (*s++ != '\0')
03343 continue;
03344
03345 return s;
03346 }
03347
03348 #if defined ACE_HAS_WCHAR
03349 const wchar_t *
03350 ACE::strend (const wchar_t *s)
03351 {
03352 while (*s++ != ACE_TEXT_WIDE ('\0'))
03353 continue;
03354
03355 return s;
03356 }
03357 #endif
03358
03359 char *
03360 ACE::strnew (const char *s)
03361 {
03362 if (s == 0)
03363 return 0;
03364 char *t = 0;
03365 ACE_NEW_RETURN (t,
03366 char [ACE_OS::strlen (s) + 1],
03367 0);
03368 if (t == 0)
03369 return 0;
03370 else
03371 return ACE_OS::strcpy (t, s);
03372 }
03373
03374 #if defined (ACE_HAS_WCHAR)
03375 wchar_t *
03376 ACE::strnew (const wchar_t *s)
03377 {
03378 if (s == 0)
03379 return 0;
03380 wchar_t *t = 0;
03381 ACE_NEW_RETURN (t,
03382 wchar_t[ACE_OS::strlen (s) + 1],
03383 0);
03384 if (t == 0)
03385 return 0;
03386 else
03387 return ACE_OS::strcpy (t, s);
03388 }
03389 #endif
03390
03391
03392 namespace
03393 {
03394
03395 inline bool equal_char (char a, char b, bool case_sensitive)
03396 {
03397 if (case_sensitive)
03398 return a == b;
03399 return ACE_OS::ace_tolower (a) == ACE_OS::ace_tolower (b);
03400 }
03401
03402
03403
03404 inline bool equal_class (char s, const char *&p, bool case_sensitive)
03405 {
03406 ++p;
03407 bool negate = false;
03408 if (*p == '!')
03409 {
03410 negate = true;
03411 ++p;
03412 }
03413
03414 for (bool first = true; *p && (first || *p != ']'); ++p)
03415 {
03416 if (!first && *p == '-' && p[1] != ']')
03417 {
03418 if (!p[1] || p[1] <= p[-1])
03419 {
03420 continue;
03421 }
03422
03423
03424
03425
03426 for (char range = p[-1] + 1; range <= p[1]; ++range)
03427 {
03428 if (equal_char (s, range, case_sensitive))
03429 {
03430 while (*++p != ']') {}
03431 return !negate;
03432 }
03433 }
03434 ++p;
03435 }
03436 else if (equal_char (s, *p, case_sensitive))
03437 {
03438 while (*++p != ']') {}
03439 return !negate;
03440 }
03441 first = false;
03442 }
03443 return negate;
03444 }
03445 }
03446
03447 bool
03448 ACE::wild_match(const char *str, const char *pat, bool case_sensitive,
03449 bool character_classes)
03450 {
03451 if (str == pat)
03452 return true;
03453 if (pat == 0 || str == 0)
03454 return false;
03455
03456 bool star = false, escape = false;
03457 const char *s = str;
03458 const char *p = pat;
03459 while (*s != '\0')
03460 {
03461 if (!escape && *p == '\\')
03462 {
03463 ++p;
03464 escape = true;
03465 }
03466 else if (!escape && *p == '*')
03467 {
03468 star = true;
03469 pat = p;
03470 while (*++pat == '*') {}
03471
03472 if (*pat == '\0')
03473 return true;
03474 p = pat;
03475 }
03476 else if (!escape && *p == '?')
03477 {
03478 ++s;
03479 ++p;
03480 }
03481 else if (!escape && character_classes && *p == '[')
03482 {
03483 if (equal_class (*s, p, case_sensitive))
03484 {
03485 ++p;
03486 }
03487 else
03488 {
03489 if (!star)
03490 return false;
03491 p = pat;
03492 }
03493 ++s;
03494 }
03495 else if (!equal_char (*s, *p, case_sensitive))
03496 {
03497 if (!star)
03498 return false;
03499 ++s;
03500 p = pat;
03501 escape = false;
03502 }
03503 else
03504 {
03505 ++s;
03506 ++p;
03507 escape = false;
03508 }
03509 }
03510 if (*p == '*')
03511 while (*++p == '*') {}
03512
03513 return *p == '\0';
03514 }
03515
03516
03517 ACE_END_VERSIONED_NAMESPACE_DECL