ACE/ace/OS_NS_unistd.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_sys_utsname.h"
   3 #include "ace/OS_NS_string.h"
   4 #include "ace/OS_NS_errno.h"
   5 #include "ace/OS_NS_macros.h"
   6 #include "ace/OS_NS_fcntl.h"
   7 #include "ace/Default_Constants.h"
   8 #include "ace/OS_Memory.h"
   9 #include "ace/Truncate.h"
  10
  11 #if defined (ACE_HAS_CLOCK_GETTIME)
  12 # include "ace/os_include/os_time.h"
  13 #endif /* ACE_HAS_CLOCK_GETTIME */
  14
  15 #if defined (ACE_LACKS_ACCESS)
  16 #  include "ace/OS_NS_stdio.h"
  17 #endif /* ACE_LACKS_ACCESS */
  18
  19 #if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x690)
  20 #  if defined (__RTP__)
  21 #    include "ace/os_include/os_strings.h"
  22 #  else
  23 #    include "ace/os_include/os_string.h"
  24 #  endif
  25 #endif
  26
  27 #ifdef ACE_MQX
  28 #  include "ace/MQX_Filesystem.h"
  29 #endif
  30
  31 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  32
  33 ACE_INLINE int
  34 ACE_OS::access (const char *path, int amode)
  35 {
  36   ACE_OS_TRACE ("ACE_OS::access");
  37 #if defined (ACE_LACKS_ACCESS)
  38     ACE_UNUSED_ARG (path);
  39     ACE_UNUSED_ARG (amode);
  40     ACE_NOTSUP_RETURN (-1);
  41 #elif defined(ACE_WIN32)
  42   // Windows doesn't support checking X_OK(6)
  43 #  if defined (ACE_ACCESS_EQUIVALENT)
  44      return ACE_ACCESS_EQUIVALENT (path, amode & 6);
  45 #  else
  46      return ::access (path, amode & 6);
  47 #  endif
  48 #else
  49   return ::access (path, amode);
  50 #endif /* ACE_LACKS_ACCESS */
  51 }
  52
  53
  54 #if defined (ACE_HAS_WCHAR)
  55 ACE_INLINE int
  56 ACE_OS::access (const wchar_t *path, int amode)
  57 {
  58 #if defined (ACE_WIN32)
  59   return ::_waccess (path, amode);
  60 #else /* ACE_WIN32 */
  61   return ACE_OS::access (ACE_Wide_To_Ascii (path).char_rep (), amode);
  62 #endif /* ACE_WIN32 */
  63 }
  64 #endif /* ACE_HAS_WCHAR */
  65
  66 ACE_INLINE u_int
  67 ACE_OS::alarm (u_int secs)
  68 {
  69   ACE_OS_TRACE ("ACE_OS::alarm");
  70 #if defined (ACE_LACKS_ALARM)
  71   ACE_UNUSED_ARG (secs);
  72   ACE_NOTSUP_RETURN (0);
  73 #else
  74   return ::alarm (secs);
  75 #endif /* ACE_LACKS_ALARM */
  76 }
  77
  78 ACE_INLINE long
  79 ACE_OS::getpagesize ()
  80 {
  81   ACE_OS_TRACE ("ACE_OS::getpagesize");
  82 #if defined (ACE_WIN32)
  83   SYSTEM_INFO sys_info;
  84   ::GetSystemInfo (&sys_info);
  85   return (long) sys_info.dwPageSize;
  86 #elif defined (_SC_PAGESIZE)
  87   return ::sysconf (_SC_PAGESIZE);
  88 #elif defined (ACE_HAS_GETPAGESIZE)
  89   return ::getpagesize ();
  90 #else
  91   // Use the default set in config.h
  92   return ACE_PAGE_SIZE;
  93 #endif /* ACE_WIN32 */
  94 }
  95
  96 ACE_INLINE long
  97 ACE_OS::allocation_granularity ()
  98 {
  99 #if defined (ACE_WIN32)
 100   SYSTEM_INFO sys_info;
 101   ::GetSystemInfo (&sys_info);
 102   return sys_info.dwAllocationGranularity;
 103 #else
 104   return ACE_OS::getpagesize ();
 105 #endif /* ACE_WIN32 */
 106 }
 107
 108 ACE_INLINE int
 109 ACE_OS::chdir (const char *path)
 110 {
 111   ACE_OS_TRACE ("ACE_OS::chdir");
 112 #if defined (ACE_CHDIR_EQUIVALENT)
 113   return ACE_CHDIR_EQUIVALENT (path);
 114 #else
 115   return ::chdir (path);
 116 #endif /* ACE_CHDIR_EQUIVALENT */
 117 }
 118
 119 #if defined (ACE_HAS_WCHAR)
 120 ACE_INLINE int
 121 ACE_OS::chdir (const wchar_t *path)
 122 {
 123 #if defined (ACE_WIN32)
 124   return ::_wchdir (path);
 125 #else /* ACE_WIN32 */
 126   return ACE_OS::chdir (ACE_Wide_To_Ascii (path).char_rep ());
 127 #endif /* ACE_WIN32 */
 128 }
 129 #endif /* ACE_HAS_WCHAR */
 130
 131 ACE_INLINE int
 132 ACE_OS::rmdir (const char *path)
 133 {
 134 #if defined (ACE_RMDIR_EQUIVALENT)
 135   return ACE_RMDIR_EQUIVALENT (path);
 136 #else
 137   return ::rmdir (path);
 138 #endif /* ACE_WIN32 */
 139 }
 140
 141 #if defined (ACE_HAS_WCHAR)
 142 ACE_INLINE int
 143 ACE_OS::rmdir (const wchar_t *path)
 144 {
 145 #if defined (ACE_WIN32)
 146   return ::_wrmdir (path);
 147 #else
 148   ACE_Wide_To_Ascii n_path (path);
 149   return ACE_OS::rmdir (n_path.char_rep ());
 150 #endif /* ACE_WIN32 */
 151 }
 152 #endif /* ACE_HAS_WCHAR */
 153
 154 // @todo: which 4 and why???  dhinton
 155 // NOTE: The following four function definitions must appear before
 156 // ACE_OS::sema_init ().
 157
 158 ACE_INLINE int
 159 ACE_OS::close (ACE_HANDLE handle)
 160 {
 161   ACE_OS_TRACE ("ACE_OS::close");
 162 #if defined (ACE_WIN32)
 163   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (handle), ace_result_), int, -1);
 164 #elif defined (ACE_MQX)
 165   return MQX_Filesystem::inst ().close (handle);
 166 #else
 167   return ::close (handle);
 168 #endif /* ACE_WIN32 */
 169 }
 170
 171 ACE_INLINE ACE_HANDLE
 172 ACE_OS::dup (ACE_HANDLE handle)
 173 {
 174   ACE_OS_TRACE ("ACE_OS::dup");
 175 #if defined (ACE_LACKS_DUP)
 176   ACE_UNUSED_ARG (handle);
 177   ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
 178 #elif defined (ACE_WIN32)
 179   ACE_HANDLE new_fd;
 180   if (::DuplicateHandle(::GetCurrentProcess (),
 181                         handle,
 182                         ::GetCurrentProcess(),
 183                         &new_fd,
 184                         0,
 185                         TRUE,
 186                         DUPLICATE_SAME_ACCESS))
 187     return new_fd;
 188   else
 189     ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
 190   /* NOTREACHED */
 191 #else
 192   return ::dup (handle);
 193 #endif /* ACE_LACKS_DUP */
 194 }
 195
 196 ACE_INLINE ACE_HANDLE
 197 ACE_OS::dup(ACE_HANDLE handle, pid_t pid)
 198 {
 199   ACE_OS_TRACE("ACE_OS::dup");
 200 #if defined (ACE_LACKS_DUP)
 201   ACE_UNUSED_ARG (handle);
 202   ACE_UNUSED_ARG (pid);
 203   ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
 204 #elif defined (ACE_WIN32)
 205   ACE_HANDLE new_fd;
 206   ACE_HANDLE hTargetProcess = ::OpenProcess (PROCESS_DUP_HANDLE,
 207                                              FALSE,
 208                                              pid);
 209   if(::DuplicateHandle(::GetCurrentProcess (),
 210                        handle,
 211                        hTargetProcess,
 212                        &new_fd,
 213                        0,
 214                        TRUE,
 215                        DUPLICATE_SAME_ACCESS))
 216     {
 217       ::CloseHandle (hTargetProcess);
 218       return new_fd;
 219     }
 220   else
 221     ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
 222   /*NOTREACHED*/
 223 #else
 224   ACE_UNUSED_ARG (pid);
 225   return ::dup(handle);
 226 #endif /* ACE_LACKS_DUP */
 227 }
 228
 229 ACE_INLINE int
 230 ACE_OS::dup2 (ACE_HANDLE oldhandle, ACE_HANDLE newhandle)
 231 {
 232   ACE_OS_TRACE ("ACE_OS::dup2");
 233 #if defined (ACE_LACKS_DUP2)
 234   // msvcrt has _dup2 ?!
 235   ACE_UNUSED_ARG (oldhandle);
 236   ACE_UNUSED_ARG (newhandle);
 237   ACE_NOTSUP_RETURN (-1);
 238 #else
 239   return ::dup2 (oldhandle, newhandle);
 240 #endif /* ACE_LACKS_DUP2 */
 241 }
 242
 243 ACE_INLINE int
 244 ACE_OS::execv (const char *path,
 245                char *const argv[])
 246 {
 247   ACE_OS_TRACE ("ACE_OS::execv");
 248 #if defined (ACE_LACKS_EXEC)
 249   ACE_UNUSED_ARG (path);
 250   ACE_UNUSED_ARG (argv);
 251
 252   ACE_NOTSUP_RETURN (-1);
 253 #elif defined (ACE_WIN32)
 254 # if defined (__BORLANDC__)
 255   return ::execv (path, argv);
 256 # elif defined (__MINGW32__)
 257   return ::_execv (path, (char *const *) argv);
 258 # else
 259   // Why this odd-looking code? If execv() returns at all, it's an error.
 260   // Windows defines this as returning an intptr_t rather than a simple int,
 261   // and the conversion triggers compile warnings. So just return -1 if
 262   // the call returns.
 263   ::_execv (path, (const char *const *) argv);
 264   return -1;
 265 # endif /* __BORLANDC__ */
 266 #else
 267   return ::execv (path, argv);
 268 #endif /* ACE_LACKS_EXEC */
 269 }
 270
 271 ACE_INLINE int
 272 ACE_OS::execve (const char *path,
 273                 char *const argv[],
 274                 char *const envp[])
 275 {
 276   ACE_OS_TRACE ("ACE_OS::execve");
 277 #if defined (ACE_LACKS_EXEC)
 278   ACE_UNUSED_ARG (path);
 279   ACE_UNUSED_ARG (argv);
 280   ACE_UNUSED_ARG (envp);
 281
 282   ACE_NOTSUP_RETURN (-1);
 283 #elif defined (ACE_WIN32)
 284 # if defined (__BORLANDC__)
 285   return ::execve (path, argv, envp);
 286 # elif defined (__MINGW32__)
 287   return ::_execve (path, (char *const *) argv, (char *const *) envp);
 288 # else
 289   // Why this odd-looking code? If execv() returns at all, it's an error.
 290   // Windows defines this as returning an intptr_t rather than a simple int,
 291   // and the conversion triggers compile warnings. So just return -1 if
 292   // the call returns.
 293   ::_execve (path, (const char *const *) argv, (const char *const *) envp);
 294   return -1;
 295 # endif /* __BORLANDC__ */
 296 #else
 297   return ::execve (path, argv, envp);
 298 #endif /* ACE_LACKS_EXEC */
 299 }
 300
 301 ACE_INLINE int
 302 ACE_OS::execvp (const char *file,
 303                 char *const argv[])
 304 {
 305   ACE_OS_TRACE ("ACE_OS::execvp");
 306 #if defined (ACE_LACKS_EXEC) || defined (ACE_LACKS_EXECVP)
 307   ACE_UNUSED_ARG (file);
 308   ACE_UNUSED_ARG (argv);
 309
 310   ACE_NOTSUP_RETURN (-1);
 311 #elif defined (ACE_WIN32)
 312 # if defined (__BORLANDC__)
 313   return ::execvp (file, argv);
 314 # elif defined (__MINGW32__)
 315   return ::_execvp (file, (char *const *) argv);
 316 # else
 317   // Why this odd-looking code? If execv() returns at all, it's an error.
 318   // Windows defines this as returning an intptr_t rather than a simple int,
 319   // and the conversion triggers compile warnings. So just return -1 if
 320   // the call returns.
 321   ::_execvp (file, (const char *const *) argv);
 322   return -1;
 323 # endif /* __BORLANDC__ */
 324 #else
 325   return ::execvp (file, argv);
 326 #endif /* ACE_LACKS_EXEC */
 327 }
 328
 329 ACE_INLINE pid_t
 330 ACE_OS::fork ()
 331 {
 332   ACE_OS_TRACE ("ACE_OS::fork");
 333 #if defined (ACE_LACKS_FORK)
 334   ACE_NOTSUP_RETURN (pid_t (-1));
 335 #else
 336   return ::fork ();
 337 #endif /* ACE_LACKS_FORK */
 338 }
 339
 340 ACE_INLINE int
 341 ACE_OS::fsync (ACE_HANDLE handle)
 342 {
 343   ACE_OS_TRACE ("ACE_OS::fsync");
 344 # if defined (ACE_LACKS_FSYNC)
 345   ACE_UNUSED_ARG (handle);
 346   ACE_NOTSUP_RETURN (-1);
 347 # elif defined (ACE_WIN32)
 348   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FlushFileBuffers (handle), ace_result_), int, -1);
 349 # else
 350   return ::fsync (handle);
 351 # endif /* ACE_LACKS_FSYNC */
 352 }
 353
 354 ACE_INLINE int
 355 ACE_OS::ftruncate (ACE_HANDLE handle, ACE_OFF_T offset)
 356 {
 357   ACE_OS_TRACE ("ACE_OS::ftruncate");
 358 #if defined (ACE_WIN32)
 359   LARGE_INTEGER loff;
 360   loff.QuadPart = offset;
 361   if (::SetFilePointerEx (handle, loff, 0, FILE_BEGIN))
 362     ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetEndOfFile (handle), ace_result_), int, -1);
 363   else
 364     ACE_FAIL_RETURN (-1);
 365 #elif defined (ACE_LACKS_FTRUNCATE)
 366   ACE_NOTSUP_RETURN (-1);
 367 #else
 368   return ::ftruncate (handle, offset);
 369 #endif /* ACE_WIN32 */
 370 }
 371
 372 ACE_INLINE char *
 373 ACE_OS::getcwd (char *buf, size_t size)
 374 {
 375   ACE_OS_TRACE ("ACE_OS::getcwd");
 376 #if defined (ACE_GETCWD_EQUIVALENT)
 377   return ACE_GETCWD_EQUIVALENT (buf, static_cast<int> (size));
 378 #elif defined (ACE_WIN32)
 379   return ::getcwd (buf, static_cast<int> (size));
 380 #else
 381   return ::getcwd (buf, size);
 382 #endif /* ACE_LACKS_GETCWD */
 383 }
 384
 385 #if defined (ACE_HAS_WCHAR)
 386 ACE_INLINE wchar_t *
 387 ACE_OS::getcwd (wchar_t *buf, size_t size)
 388 {
 389 #  if defined (ACE_WIN32)
 390   return ::_wgetcwd (buf, static_cast<int> (size));
 391 #  else
 392   char *narrow_buf = new char[size];
 393   char *result = 0;
 394   result = ACE_OS::getcwd (narrow_buf, size);
 395   ACE_Ascii_To_Wide wide_buf (result);
 396   delete [] narrow_buf;
 397   if (result != 0)
 398     ACE_OS::strsncpy (buf, wide_buf.wchar_rep (), size);
 399   return result == 0 ? 0 : buf;
 400 #  endif /* ACE_WIN32 */
 401 }
 402 #endif /* ACE_HAS_WCHAR */
 403
 404 ACE_INLINE gid_t
 405 ACE_OS::getgid ()
 406 {
 407   ACE_OS_TRACE ("ACE_OS::getgid");
 408 #if defined (ACE_LACKS_GETGID)
 409   ACE_NOTSUP_RETURN (static_cast<gid_t> (-1));
 410 # else
 411   return ::getgid ();
 412 # endif /* ACE_LACKS_GETGID */
 413 }
 414
 415 ACE_INLINE gid_t
 416 ACE_OS::getegid ()
 417 {
 418   ACE_OS_TRACE ("ACE_OS::getegid");
 419 #if defined (ACE_LACKS_GETEGID)
 420   ACE_NOTSUP_RETURN (static_cast<gid_t> (-1));
 421 # else
 422   return ::getegid ();
 423 # endif /* ACE_LACKS_GETEGID */
 424 }
 425
 426 ACE_INLINE int
 427 ACE_OS::getopt (int argc, char *const *argv, const char *optstring)
 428 {
 429   ACE_OS_TRACE ("ACE_OS::getopt");
 430 #if defined (ACE_LACKS_GETOPT)
 431   ACE_UNUSED_ARG (argc);
 432   ACE_UNUSED_ARG (argv);
 433   ACE_UNUSED_ARG (optstring);
 434   ACE_NOTSUP_RETURN (-1);
 435 # else
 436   return ::getopt (argc, argv, optstring);
 437 # endif /* ACE_LACKS_GETOPT */
 438 }
 439
 440 ACE_INLINE pid_t
 441 ACE_OS::getpgid (pid_t pid)
 442 {
 443   ACE_OS_TRACE ("ACE_OS::getpgid");
 444 #if defined (ACE_LACKS_GETPGID)
 445   ACE_UNUSED_ARG (pid);
 446   ACE_NOTSUP_RETURN (-1);
 447 #elif defined (ACE_LINUX) && __GLIBC__ > 1 && __GLIBC_MINOR__ >= 0
 448   // getpgid() is from SVR4, which appears to be the reason why GLIBC
 449   // doesn't enable its prototype by default.
 450   // Rather than create our own extern prototype, just use the one
 451   // that is visible (ugh).
 452   return ::__getpgid (pid);
 453 #else
 454   return ::getpgid (pid);
 455 #endif /* ACE_LACKS_GETPGID */
 456 }
 457
 458 ACE_INLINE pid_t
 459 ACE_OS::getpid ()
 460 {
 461   // ACE_OS_TRACE ("ACE_OS::getpid");
 462 #if defined (ACE_LACKS_GETPID)
 463   ACE_NOTSUP_RETURN (-1);
 464 #elif defined (ACE_WIN32)
 465   return ::GetCurrentProcessId ();
 466 #else
 467   return ::getpid ();
 468 #endif /* ACE_LACKS_GETPID */
 469 }
 470
 471 ACE_INLINE pid_t
 472 ACE_OS::getppid ()
 473 {
 474   ACE_OS_TRACE ("ACE_OS::getppid");
 475 #if defined (ACE_LACKS_GETPPID)
 476   ACE_NOTSUP_RETURN (-1);
 477 #else
 478   return ::getppid ();
 479 #endif /* ACE_LACKS_GETPPID */
 480 }
 481
 482 ACE_INLINE uid_t
 483 ACE_OS::getuid ()
 484 {
 485   ACE_OS_TRACE ("ACE_OS::getuid");
 486 #if defined (ACE_LACKS_GETUID)
 487   ACE_NOTSUP_RETURN (static_cast<uid_t> (-1));
 488 # else
 489   return ::getuid ();
 490 # endif /* ACE_LACKS_GETUID*/
 491 }
 492
 493 ACE_INLINE uid_t
 494 ACE_OS::geteuid ()
 495 {
 496   ACE_OS_TRACE ("ACE_OS::geteuid");
 497 #if defined (ACE_LACKS_GETEUID)
 498   ACE_NOTSUP_RETURN (static_cast<uid_t> (-1));
 499 # else
 500   return ::geteuid ();
 501 # endif /* ACE_LACKS_GETEUID */
 502 }
 503
 504 ACE_INLINE int
 505 ACE_OS::hostname (char name[], size_t maxnamelen)
 506 {
 507   ACE_OS_TRACE ("ACE_OS::hostname");
 508 #if defined (ACE_VXWORKS)
 509   return ::gethostname (name, maxnamelen);
 510 #elif defined (ACE_WIN32)
 511   if (::gethostname (name, ACE_Utils::truncate_cast<int> (maxnamelen)) == 0)
 512   {
 513     return 0;
 514   }
 515   else
 516   {
 517     ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::GetComputerNameA (name,
 518                                             LPDWORD (&maxnamelen)),
 519                                             ace_result_), int, -1);
 520   }
 521 #elif defined (ACE_MQX)
 522   const int enet_device = 0;
 523   IPCFG_IP_ADDRESS_DATA ip_data;
 524   if (ipcfg_get_ip (enet_device, &ip_data))
 525   {
 526     ACE_OS::snprintf(name, maxnamelen, "%d.%d.%d.%d", IPBYTES(ip_data.ip));
 527     return 0;
 528   }
 529   return -1;
 530 #elif defined (ACE_LACKS_GETHOSTNAME)
 531   ACE_NOTSUP_RETURN (-1);
 532 #else /* ACE_VXWORKS */
 533   ACE_utsname host_info;
 534
 535   if (ACE_OS::uname (&host_info) == -1)
 536     return -1;
 537   else
 538     {
 539       ACE_OS::strsncpy (name, host_info.nodename, maxnamelen);
 540       return 0;
 541     }
 542 #endif /* ACE_VXWORKS */
 543 }
 544
 545 #if defined (ACE_HAS_WCHAR)
 546 ACE_INLINE int
 547 ACE_OS::hostname (wchar_t name[], size_t maxnamelen)
 548 {
 549 #if defined (ACE_WIN32)
 550   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (GetComputerNameW (name,
 551                                                         LPDWORD (&maxnamelen)),
 552                                           ace_result_), int, -1);
 553 #else /* ACE_WIN32 */
 554   // Emulate using the char version
 555   char *char_name = 0;
 556
 557   ACE_NEW_RETURN (char_name, char[maxnamelen], -1);
 558
 559   int result = ACE_OS::hostname(char_name, maxnamelen);
 560   ACE_OS::strcpy (name, ACE_Ascii_To_Wide (char_name).wchar_rep ());
 561
 562   delete [] char_name;
 563   return result;
 564 #endif /* ACE_WIN32  */
 565 }
 566 #endif /* ACE_HAS_WCHAR */
 567
 568 ACE_INLINE int
 569 ACE_OS::isatty (int handle)
 570 {
 571   ACE_OS_TRACE ("ACE_OS::isatty");
 572 #if defined (ACE_LACKS_ISATTY)
 573   ACE_UNUSED_ARG (handle);
 574   return 0;
 575 # elif defined (ACE_WIN32)
 576   return ::_isatty (handle);
 577 # else
 578   return ::isatty (handle);
 579 # endif /* ACE_LACKS_ISATTY */
 580 }
 581
 582 #if defined (ACE_WIN32)
 583 ACE_INLINE int
 584 ACE_OS::isatty (ACE_HANDLE handle)
 585 {
 586 #if defined (ACE_LACKS_ISATTY)
 587   ACE_UNUSED_ARG (handle);
 588   return 0;
 589 #else
 590   int const fd = ::_open_osfhandle (intptr_t (handle), 0);
 591   int status = 0;
 592   if (fd != -1)
 593     {
 594       status = ::_isatty (fd);
 595       ::_close (fd);
 596     }
 597   return status;
 598 #endif /* ACE_LACKS_ISATTY */
 599 }
 600
 601 #endif /* ACE_WIN32 */
 602
 603 ACE_INLINE ACE_OFF_T
 604 ACE_OS::lseek (ACE_HANDLE handle, ACE_OFF_T offset, int whence)
 605 {
 606   ACE_OS_TRACE ("ACE_OS::lseek");
 607 #if defined (ACE_WIN32)
 608 # if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END
 609   //#error Windows NT is evil AND rude!
 610   switch (whence)
 611     {
 612     case SEEK_SET:
 613       whence = FILE_BEGIN;
 614       break;
 615     case SEEK_CUR:
 616       whence = FILE_CURRENT;
 617       break;
 618     case SEEK_END:
 619       whence = FILE_END;
 620       break;
 621     default:
 622       errno = EINVAL;
 623       return static_cast<ACE_OFF_T> (-1); // rather safe than sorry
 624     }
 625 # endif  /* SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END */
 626   LONG low_offset = ACE_LOW_PART(offset);
 627   LONG high_offset = ACE_HIGH_PART(offset);
 628   DWORD const result =
 629     ::SetFilePointer (handle, low_offset, &high_offset, whence);
 630   if (result == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
 631     ACE_FAIL_RETURN (static_cast<ACE_OFF_T> (-1));
 632   else
 633     return result;
 634 #elif defined (ACE_MQX)
 635   switch (whence)
 636     {
 637     case SEEK_SET:
 638       whence = IO_SEEK_SET;
 639       break;
 640     case SEEK_CUR:
 641       whence = IO_SEEK_CUR;
 642       break;
 643     case SEEK_END:
 644       whence = IO_SEEK_END;
 645       break;
 646     default:
 647       errno = EINVAL;
 648       return static_cast<ACE_OFF_T> (-1);
 649     }
 650   return static_cast<ACE_OFF_T> (MQX_Filesystem::inst ().lseek (handle, offset, whence));
 651 #else
 652   return ::lseek (handle, offset, whence);
 653 #endif /* ACE_WIN32 */
 654 }
 655
 656 #if defined (ACE_HAS_LLSEEK) || defined (ACE_HAS_LSEEK64)
 657 ACE_INLINE ACE_LOFF_T
 658 ACE_OS::llseek (ACE_HANDLE handle, ACE_LOFF_T offset, int whence)
 659 {
 660   ACE_OS_TRACE ("ACE_OS::llseek");
 661
 662 #if ACE_SIZEOF_LONG == 8
 663   /* The native lseek is 64 bit.  Use it. */
 664   return ACE_OS::lseek (handle, offset, whence);
 665 #elif defined (ACE_HAS_LLSEEK) && defined (ACE_HAS_LSEEK64)
 666 # error Either ACE_HAS_LSEEK64 and ACE_HAS_LLSEEK should be defined, not both!
 667 #elif defined (ACE_HAS_LSEEK64)
 668   return ::lseek64 (handle, offset, whence);
 669 #elif defined (ACE_HAS_LLSEEK)
 670 # if defined (ACE_WIN32)
 671   LARGE_INTEGER distance, new_file_pointer;
 672
 673   distance.QuadPart = offset;
 674
 675   return
 676     (::SetFilePointerEx (handle, distance, &new_file_pointer, whence)
 677      ? new_file_pointer.QuadPart
 678      : static_cast<ACE_LOFF_T> (-1));
 679 # else
 680     return ::llseek (handle, offset, whence);
 681 # endif /* WIN32 */
 682 #endif
 683 }
 684 #endif /* ACE_HAS_LLSEEK || ACE_HAS_LSEEK64 */
 685
 686 ACE_INLINE ssize_t
 687 ACE_OS::read (ACE_HANDLE handle, void *buf, size_t len)
 688 {
 689   ACE_OS_TRACE ("ACE_OS::read");
 690 #if defined (ACE_WIN32)
 691   DWORD ok_len;
 692   if (::ReadFile (handle, buf, static_cast<DWORD> (len), &ok_len, 0))
 693     return (ssize_t) ok_len;
 694   else
 695     ACE_FAIL_RETURN (-1);
 696
 697 #elif defined (ACE_MQX)
 698   return MQX_Filesystem::inst ().read (handle, reinterpret_cast<unsigned char *> (buf), len);
 699
 700 #else
 701
 702   ssize_t result;
 703
 704 # if defined (ACE_HAS_CHARPTR_SOCKOPT)
 705   ACE_OSCALL (::read (handle, static_cast <char *> (buf), len), ssize_t, result);
 706 # else
 707   ACE_OSCALL (::read (handle, buf, len), ssize_t, result);
 708 # endif /* ACE_HAS_CHARPTR_SOCKOPT */
 709
 710 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
 711   // Optimize this code out if we can detect that EAGAIN ==
 712   // EWOULDBLOCK at compile time.  If we cannot detect equality at
 713   // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor
 714   // macros) perform the check at run-time.  The goal is to avoid two
 715   // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK.
 716   if (result == -1
 717 #  if !defined (EAGAIN) || !defined (EWOULDBLOCK)
 718       && EAGAIN != EWOULDBLOCK
 719 #  endif  /* !EAGAIN || !EWOULDBLOCK */
 720       && errno == EAGAIN)
 721     {
 722       errno = EWOULDBLOCK;
 723     }
 724 # endif /* EAGAIN != EWOULDBLOCK*/
 725
 726   return result;
 727 #endif /* ACE_WIN32 */
 728 }
 729
 730 ACE_INLINE ssize_t
 731 ACE_OS::read (ACE_HANDLE handle, void *buf, size_t len,
 732               ACE_OVERLAPPED *overlapped)
 733 {
 734   ACE_OS_TRACE ("ACE_OS::read");
 735 #if defined (ACE_WIN32)
 736   DWORD ok_len;
 737   DWORD short_len = static_cast<DWORD> (len);
 738   if (::ReadFile (handle, buf, short_len, &ok_len, overlapped))
 739     return (ssize_t) ok_len;
 740   else
 741     ACE_FAIL_RETURN (-1);
 742 #else
 743   ACE_UNUSED_ARG (overlapped);
 744   return ACE_OS::read (handle, buf, len);
 745 #endif /* ACE_WIN32 */
 746 }
 747
 748 ACE_INLINE ssize_t
 749 ACE_OS::readlink (const char *path, char *buf, size_t bufsiz)
 750 {
 751   ACE_OS_TRACE ("ACE_OS::readlink");
 752 # if defined (ACE_LACKS_READLINK)
 753   ACE_UNUSED_ARG (path);
 754   ACE_UNUSED_ARG (buf);
 755   ACE_UNUSED_ARG (bufsiz);
 756   ACE_NOTSUP_RETURN (-1);
 757 # elif defined(ACE_HAS_NONCONST_READLINK)
 758   return ::readlink (const_cast <char *>(path), buf, bufsiz);
 759 # else
 760   return ::readlink (path, buf, bufsiz);
 761 # endif /* ACE_LACKS_READLINK */
 762 }
 763
 764 ACE_INLINE int
 765 ACE_OS::pipe (ACE_HANDLE fds[])
 766 {
 767   ACE_OS_TRACE ("ACE_OS::pipe");
 768 # if defined (ACE_LACKS_PIPE)
 769   ACE_UNUSED_ARG (fds);
 770   ACE_NOTSUP_RETURN (-1);
 771 # elif defined (ACE_WIN32)
 772   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL
 773                         (::CreatePipe (&fds[0], &fds[1], 0, 0),
 774                          ace_result_), int, -1);
 775 # else
 776   return ::pipe (fds);
 777 # endif /* ACE_LACKS_PIPE */
 778 }
 779
 780 ACE_INLINE void *
 781 ACE_OS::sbrk (intptr_t brk)
 782 {
 783 #if defined (ACE_LACKS_SBRK)
 784   ACE_UNUSED_ARG (brk);
 785   ACE_NOTSUP_RETURN (0);
 786 #else
 787   return ::sbrk (brk);
 788 #endif /* ACE_LACKS_SBRK */
 789 }
 790
 791 ACE_INLINE int
 792 ACE_OS::setgid (gid_t gid)
 793 {
 794   ACE_OS_TRACE ("ACE_OS::setgid");
 795 #if defined (ACE_LACKS_SETGID)
 796   ACE_UNUSED_ARG (gid);
 797   ACE_NOTSUP_RETURN (-1);
 798 # else
 799   return ::setgid (gid);
 800 # endif /* ACE_LACKS_SETGID */
 801 }
 802
 803 ACE_INLINE int
 804 ACE_OS::setegid (gid_t gid)
 805 {
 806   ACE_OS_TRACE ("ACE_OS::setegid");
 807 #if defined (ACE_LACKS_SETEGID)
 808   ACE_UNUSED_ARG (gid);
 809   ACE_NOTSUP_RETURN (-1);
 810 # else
 811   return ::setegid (gid);
 812 # endif /* ACE_LACKS_SETEGID */
 813 }
 814
 815 ACE_INLINE int
 816 ACE_OS::setpgid (pid_t pid, pid_t pgid)
 817 {
 818   ACE_OS_TRACE ("ACE_OS::setpgid");
 819 #if defined (ACE_LACKS_SETPGID)
 820   ACE_UNUSED_ARG (pid);
 821   ACE_UNUSED_ARG (pgid);
 822   ACE_NOTSUP_RETURN (-1);
 823 #else
 824   return ::setpgid (pid, pgid);
 825 #endif /* ACE_LACKS_SETPGID */
 826 }
 827
 828 ACE_INLINE int
 829 ACE_OS::setregid (gid_t rgid, gid_t egid)
 830 {
 831   ACE_OS_TRACE ("ACE_OS::setregid");
 832 #if defined (ACE_LACKS_SETREGID)
 833   ACE_UNUSED_ARG (rgid);
 834   ACE_UNUSED_ARG (egid);
 835   ACE_NOTSUP_RETURN (-1);
 836 #else
 837   return ::setregid (rgid, egid);
 838 #endif /* ACE_LACKS_SETREGID */
 839 }
 840
 841 ACE_INLINE int
 842 ACE_OS::setreuid (uid_t ruid, uid_t euid)
 843 {
 844   ACE_OS_TRACE ("ACE_OS::setreuid");
 845 #if defined (ACE_LACKS_SETREUID)
 846   ACE_UNUSED_ARG (ruid);
 847   ACE_UNUSED_ARG (euid);
 848   ACE_NOTSUP_RETURN (-1);
 849 #else
 850   return ::setreuid (ruid, euid);
 851 #endif /* ACE_LACKS_SETREUID */
 852 }
 853
 854 ACE_INLINE pid_t
 855 ACE_OS::setsid ()
 856 {
 857   ACE_OS_TRACE ("ACE_OS::setsid");
 858 #if defined (ACE_LACKS_SETSID)
 859   ACE_NOTSUP_RETURN (-1);
 860 #else
 861   return ::setsid ();
 862 # endif /* ACE_LACKS_SETSID */
 863 }
 864
 865 ACE_INLINE int
 866 ACE_OS::setuid (uid_t uid)
 867 {
 868   ACE_OS_TRACE ("ACE_OS::setuid");
 869 #if defined (ACE_LACKS_SETUID)
 870   ACE_UNUSED_ARG (uid);
 871   ACE_NOTSUP_RETURN (-1);
 872 # else
 873   return ::setuid (uid);
 874 # endif /* ACE_LACKS_SETUID */
 875 }
 876
 877 ACE_INLINE int
 878 ACE_OS::seteuid (uid_t uid)
 879 {
 880   ACE_OS_TRACE ("ACE_OS::seteuid");
 881 #if defined (ACE_LACKS_SETEUID)
 882   ACE_UNUSED_ARG (uid);
 883   ACE_NOTSUP_RETURN (-1);
 884 # else
 885   return ::seteuid (uid);
 886 # endif /* ACE_LACKS_SETEUID */
 887 }
 888
 889 ACE_INLINE int
 890 ACE_OS::sleep (u_int seconds)
 891 {
 892   ACE_OS_TRACE ("ACE_OS::sleep");
 893 #if defined (ACE_HAS_CLOCK_GETTIME)
 894   struct timespec rqtp;
 895   // Initializer doesn't work with Green Hills 1.8.7
 896   rqtp.tv_sec = seconds;
 897   rqtp.tv_nsec = 0L;
 898   //FUZZ: disable check_for_lack_ACE_OS
 899   return ::nanosleep (&rqtp, 0);
 900   //FUZZ: enable check_for_lack_ACE_OS
 901 #elif defined (ACE_LACKS_SLEEP)
 902   ACE_UNUSED_ARG (seconds);
 903   ACE_NOTSUP_RETURN (-1);
 904 #elif defined (ACE_WIN32)
 905   ::Sleep (seconds * ACE_ONE_SECOND_IN_MSECS);
 906   return 0;
 907 #elif defined (ACE_MQX)
 908   _time_delay (seconds * ACE_ONE_SECOND_IN_MSECS);
 909   return 0;
 910 #else
 911   return ::sleep (seconds);
 912 #endif /* ACE_WIN32 */
 913 }
 914
 915 ACE_INLINE int
 916 ACE_OS::sleep (const ACE_Time_Value &tv)
 917 {
 918   ACE_OS_TRACE ("ACE_OS::sleep");
 919 #if defined (ACE_WIN32)
 920   ::Sleep (tv.msec ());
 921   return 0;
 922 #elif defined (ACE_MQX)
 923   _time_delay (tv.msec ());
 924   return 0;
 925 #elif defined (ACE_HAS_CLOCK_GETTIME)
 926   timespec_t rqtp = tv;
 927   //FUZZ: disable check_for_lack_ACE_OS
 928   return ::nanosleep (&rqtp, 0);
 929   //FUZZ: enable check_for_lack_ACE_OS
 930 #else
 931 # if defined (ACE_HAS_NONCONST_SELECT_TIMEVAL)
 932   // Copy the timeval, because this platform doesn't declare the timeval
 933   // as a pointer to const.
 934   timeval tv_copy = tv;
 935   //FUZZ: disable check_for_lack_ACE_OS
 936   return ::select (0, 0, 0, 0, &tv_copy);
 937   //FUZZ: enable check_for_lack_ACE_OS
 938 # else  /* ! ACE_HAS_NONCONST_SELECT_TIMEVAL */
 939   const timeval *tvp = tv;
 940   //FUZZ: disable check_for_lack_ACE_OS
 941   return ::select (0, 0, 0, 0, tvp);
 942   //FUZZ: enable check_for_lack_ACE_OS
 943 # endif /* ACE_HAS_NONCONST_SELECT_TIMEVAL */
 944 #endif /* ACE_WIN32 */
 945 }
 946
 947 ACE_INLINE void
 948 ACE_OS::swab (const void *src,
 949               void *dest,
 950               ssize_t length)
 951 {
 952 #if defined (ACE_LACKS_SWAB)
 953   // ------------------------------------------------------------
 954   // The following copyright notice applies to the swab()
 955   // implementation within this "ACE_LACKS_SWAB" block of code.
 956   // ------------------------------------------------------------
 957   /*
 958     Copyright (c) 1994-2006  Red Hat, Inc. All rights reserved.
 959
 960     This copyrighted material is made available to anyone wishing to
 961     use, modify, copy, or redistribute it subject to the terms and
 962     conditions of the BSD License.   This program is distributed in
 963     the hope that it will be useful, but WITHOUT ANY WARRANTY
 964     expressed or implied, including the implied warranties of
 965     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  A copy of
 966     this license is available at
 967     http://www.opensource.org/licenses. Any Red Hat trademarks that
 968     are incorporated in the source code or documentation are not
 969     subject to the BSD License and may only be used or replicated with
 970     the express permission of Red Hat, Inc.
 971   */
 972
 973   const char *from = static_cast<const char*> (src);
 974   char *to = static_cast<char *> (dest);
 975   ssize_t ptr = 0;
 976   for (ptr = 1; ptr < length; ptr += 2)
 977     {
 978       char p = from[ptr];
 979       char q = from[ptr-1];
 980       to[ptr-1] = p;
 981       to[ptr  ] = q;
 982     }
 983   if (ptr == length) /* I.e., if length is odd, */
 984     to[ptr-1] = 0;   /* then pad with a NUL. */
 985 #elif defined (ACE_HAS_NONCONST_SWAB)
 986   const char *tmp = static_cast<const char*> (src);
 987   char *from = const_cast<char *> (tmp);
 988   char *to = static_cast<char *> (dest);
 989 #  if defined (ACE_HAS_INT_SWAB)
 990   int ilength = ACE_Utils::truncate_cast<int> (length);
 991 #    if defined (ACE_SWAB_EQUIVALENT)
 992   ACE_SWAB_EQUIVALENT (from, to, ilength);
 993 #    else
 994   ::swab (from, to, ilength);
 995 #    endif
 996 #  else
 997   ::swab (from, to, length);
 998 #  endif /* ACE_HAS_INT_SWAB */
 999 #elif defined (ACE_HAS_CONST_CHAR_SWAB)
1000   const char *from = static_cast<const char*> (src);
1001   char *to = static_cast<char *> (dest);
1002   ::swab (from, to, length);
1003 #else
1004   ::swab (src, dest, length);
1005 #endif /* ACE_LACKS_SWAB */
1006
1007 }
1008
1009 ACE_INLINE long
1010 ACE_OS::sysconf (int name)
1011 {
1012   ACE_OS_TRACE ("ACE_OS::sysconf");
1013 #if defined (ACE_LACKS_SYSCONF)
1014   ACE_UNUSED_ARG (name);
1015   ACE_NOTSUP_RETURN (-1);
1016 #else
1017   return ::sysconf (name);
1018 #endif /* ACE_LACKS_SYSCONF */
1019 }
1020
1021 ACE_INLINE long
1022 ACE_OS::sysinfo (int /*cmd*/, char * /*buf*/, long /*count*/)
1023 {
1024   ACE_OS_TRACE ("ACE_OS::sysinfo");
1025   ACE_NOTSUP_RETURN (0);
1026 }
1027
1028 ACE_INLINE int
1029 ACE_OS::truncate (const ACE_TCHAR *filename,
1030                   ACE_OFF_T offset)
1031 {
1032   ACE_OS_TRACE ("ACE_OS::truncate");
1033 #if defined (ACE_WIN32)
1034   ACE_HANDLE handle = ACE_OS::open (filename, O_WRONLY, ACE_DEFAULT_FILE_PERMS);
1035
1036   LARGE_INTEGER loffset;
1037   loffset.QuadPart = offset;
1038
1039   if (handle == ACE_INVALID_HANDLE)
1040     {
1041       ACE_FAIL_RETURN (-1);
1042     }
1043   else if (::SetFilePointerEx (handle, loffset, 0, FILE_BEGIN))
1044     {
1045       BOOL result = ::SetEndOfFile (handle);
1046       ::CloseHandle (handle);
1047       ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (result, ace_result_), int, -1);
1048     }
1049   else
1050     {
1051       ::CloseHandle (handle);
1052       ACE_FAIL_RETURN (-1);
1053     }
1054   /* NOTREACHED */
1055 #elif !defined (ACE_LACKS_TRUNCATE)
1056   return ::truncate (ACE_TEXT_ALWAYS_CHAR (filename), offset);
1057 #else
1058   ACE_UNUSED_ARG (filename);
1059   ACE_UNUSED_ARG (offset);
1060   ACE_NOTSUP_RETURN (-1);
1061 #endif /* ACE_WIN32 */
1062 }
1063
1064 ACE_INLINE useconds_t
1065 ACE_OS::ualarm (useconds_t usecs, useconds_t interval)
1066 {
1067   ACE_OS_TRACE ("ACE_OS::ualarm");
1068
1069 #if defined (ACE_HAS_UALARM)
1070   return ::ualarm (usecs, interval);
1071 #elif !defined (ACE_LACKS_UNIX_SIGNALS) && !defined (ACE_LACKS_ALARM)
1072   ACE_UNUSED_ARG (interval);
1073 # if defined (ACE_VXWORKS) && ACE_VXWORKS >= 0x690 && defined (_WRS_CONFIG_LP64)
1074   return ::alarm (static_cast<unsigned int> (usecs * ACE_ONE_SECOND_IN_USECS));
1075 # else
1076   return ::alarm (usecs * ACE_ONE_SECOND_IN_USECS);
1077 #endif
1078 #else
1079   ACE_UNUSED_ARG (usecs);
1080   ACE_UNUSED_ARG (interval);
1081   ACE_NOTSUP_RETURN (0);
1082 #endif /* ACE_HAS_UALARM */
1083 }
1084
1085 ACE_INLINE useconds_t
1086 ACE_OS::ualarm (const ACE_Time_Value &tv,
1087                 const ACE_Time_Value &tv_interval)
1088 {
1089   ACE_OS_TRACE ("ACE_OS::ualarm");
1090
1091 #if defined (ACE_HAS_UALARM)
1092   useconds_t usecs = (tv.sec () * ACE_ONE_SECOND_IN_USECS) + tv.usec ();
1093   useconds_t interval =
1094     (tv_interval.sec () * ACE_ONE_SECOND_IN_USECS) + tv_interval.usec ();
1095   return ::ualarm (usecs, interval);
1096 #elif !defined (ACE_LACKS_UNIX_SIGNALS) && !defined (ACE_LACKS_ALARM)
1097   ACE_UNUSED_ARG (tv_interval);
1098 # if defined (ACE_VXWORKS) && ACE_VXWORKS >= 0x690 && defined (_WRS_CONFIG_LP64)
1099   return ::alarm (static_cast<unsigned int> (tv.sec ()));
1100 # else
1101   return ::alarm (tv.sec ());
1102 # endif
1103 #else
1104   ACE_UNUSED_ARG (tv_interval);
1105   ACE_UNUSED_ARG (tv);
1106   ACE_NOTSUP_RETURN (0);
1107 #endif /* ACE_HAS_UALARM */
1108 }
1109
1110 ACE_INLINE int
1111 ACE_OS::unlink (const char *path)
1112 {
1113   ACE_OS_TRACE ("ACE_OS::unlink");
1114 #if defined (ACE_LACKS_UNLINK)
1115   ACE_UNUSED_ARG (path);
1116   ACE_NOTSUP_RETURN (-1);
1117 #elif defined (ACE_UNLINK_EQUIVALENT)
1118   return ACE_UNLINK_EQUIVALENT (path);
1119 #else
1120   return ::unlink (path);
1121 #endif /* ACE_LACKS_UNLINK */
1122 }
1123
1124 #if defined (ACE_HAS_WCHAR)
1125 ACE_INLINE int
1126 ACE_OS::unlink (const wchar_t *path)
1127 {
1128   ACE_OS_TRACE ("ACE_OS::unlink");
1129 # if defined (ACE_WIN32)
1130   return ::_wunlink (path);
1131 # else
1132   ACE_Wide_To_Ascii npath (path);
1133   return ACE_OS::unlink (npath.char_rep ());
1134 # endif /* ACE_WIN32 */
1135 }
1136 #endif /* ACE_HAS_WCHAR */
1137
1138 ACE_INLINE ssize_t
1139 ACE_OS::write (ACE_HANDLE handle, const void *buf, size_t nbyte)
1140 {
1141   ACE_OS_TRACE ("ACE_OS::write");
1142 #if defined (ACE_WIN32)
1143   DWORD bytes_written; // This is set to 0 byte WriteFile.
1144
1145   // Strictly correctly, we should loop writing all the data if more
1146   // than a DWORD length can hold.
1147   DWORD short_nbyte = static_cast<DWORD> (nbyte);
1148   if (::WriteFile (handle, buf, short_nbyte, &bytes_written, 0))
1149     return (ssize_t) bytes_written;
1150   else
1151     ACE_FAIL_RETURN (-1);
1152 #elif defined (ACE_MQX)
1153   return MQX_Filesystem::inst ().write (handle, reinterpret_cast<const unsigned char *> (buf), nbyte);
1154 #else
1155 # if defined (ACE_HAS_CHARPTR_SOCKOPT)
1156   return ::write (handle, static_cast <char *> (const_cast <void *> (buf)), nbyte);
1157 # else
1158   return ::write (handle, buf, nbyte);
1159 # endif /* ACE_HAS_CHARPTR_SOCKOPT */
1160 #endif /* ACE_WIN32 */
1161 }
1162
1163 ACE_INLINE ssize_t
1164 ACE_OS::write (ACE_HANDLE handle,
1165                const void *buf,
1166                size_t nbyte,
1167                ACE_OVERLAPPED *overlapped)
1168 {
1169   ACE_OS_TRACE ("ACE_OS::write");
1170 #if defined (ACE_WIN32)
1171   DWORD bytes_written; // This is set to 0 byte WriteFile.
1172
1173   DWORD short_nbyte = static_cast<DWORD> (nbyte);
1174   if (::WriteFile (handle, buf, short_nbyte, &bytes_written, overlapped))
1175     return (ssize_t) bytes_written;
1176   else
1177     ACE_FAIL_RETURN (-1);
1178 #else
1179   ACE_UNUSED_ARG (overlapped);
1180   return ACE_OS::write (handle, buf, nbyte);
1181 #endif /* ACE_WIN32 */
1182 }
1183
1184 ACE_END_VERSIONED_NAMESPACE_DECL