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