undoing accidental deletion

1 files changed, 1193 insertions, 0 deletions

diff --git a/ACE/ace/OS_NS_unistd.inl b/ACE/ace/OS_NS_unistd.inl
new file mode 100644
index 00000000000..62bb81d6be5
--- /dev/null
+++ b/ACE/ace/OS_NS_unistd.inl
@@ -0,0 +1,1193 @@
+// -*- C++ -*-
+//
+// $Id$
+
+#include "ace/OS_NS_sys_utsname.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_NS_errno.h"
+#include "ace/OS_NS_macros.h"
+#include "ace/OS_NS_fcntl.h"
+#include "ace/Default_Constants.h"
+#include "ace/OS_Memory.h"
+#include "ace/Truncate.h"
+
+#if defined (ACE_HAS_CLOCK_GETTIME)
+# include "ace/os_include/os_time.h"
+#endif /* ACE_HAS_CLOCK_GETTIME */
+
+#if defined (ACE_LACKS_ACCESS)
+#  include "ace/OS_NS_stdio.h"
+#endif /* ACE_LACKS_ACCESS */
+
+#if defined (ACE_VXWORKS) || defined (ACE_HAS_WINCE)
+#  include "ace/os_include/os_unistd.h"
+#  if defined (ACE_VXWORKS) && ((ACE_VXWORKS >= 0x620) && (ACE_VXWORKS <= 0x660))
+#    if defined (__RTP__)
+#      include "ace/os_include/os_strings.h"
+#    else
+#      include "ace/os_include/os_string.h"
+#    endif
+#  endif
+#endif /* VXWORKS || ACE_HAS_WINCE */
+
+ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ACE_INLINE int
+ACE_OS::access (const char *path, int amode)
+{
+  ACE_OS_TRACE ("ACE_OS::access");
+#if defined (ACE_LACKS_ACCESS)
+#  if defined (ACE_HAS_WINCE) || defined (ACE_VXWORKS)
+  // @@ WINCE: There should be a Win32 API that can do this.
+  // Hard coded read access here.
+  ACE_UNUSED_ARG (amode);
+  FILE* handle = ACE_OS::fopen (ACE_TEXT_CHAR_TO_TCHAR(path),
+                                ACE_TEXT ("r"));
+  if (handle != 0)
+    {
+      ACE_OS::fclose (handle);
+      return 0;
+    }
+  return (-1);
+#  else
+    ACE_UNUSED_ARG (path);
+    ACE_UNUSED_ARG (amode);
+    ACE_NOTSUP_RETURN (-1);
+#  endif  // ACE_HAS_WINCE
+#elif defined(ACE_WIN32)
+  // Windows doesn't support checking X_OK(6)
+  ACE_OSCALL_RETURN (::access (path, amode & 6), int, -1);
+#else
+  ACE_OSCALL_RETURN (::access (path, amode), int, -1);
+#endif /* ACE_LACKS_ACCESS */
+}
+
+
+#if defined (ACE_HAS_WCHAR)
+ACE_INLINE int
+ACE_OS::access (const wchar_t *path, int amode)
+{
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+  ACE_OSCALL_RETURN (::_waccess (path, amode), int, -1);
+#else /* ACE_WIN32 && !ACE_HAS_WINCE */
+  return ACE_OS::access (ACE_Wide_To_Ascii (path).char_rep (), amode);
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE */
+}
+#endif /* ACE_HAS_WCHAR */
+
+ACE_INLINE u_int
+ACE_OS::alarm (u_int secs)
+{
+  ACE_OS_TRACE ("ACE_OS::alarm");
+#if defined (ACE_LACKS_ALARM)
+  ACE_UNUSED_ARG (secs);
+  ACE_NOTSUP_RETURN (0);
+#else
+  return ::alarm (secs);
+#endif /* ACE_LACKS_ALARM */
+}
+
+ACE_INLINE long
+ACE_OS::getpagesize (void)
+{
+  ACE_OS_TRACE ("ACE_OS::getpagesize");
+#if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
+  SYSTEM_INFO sys_info;
+  ::GetSystemInfo (&sys_info);
+  return (long) sys_info.dwPageSize;
+#elif defined (_SC_PAGESIZE) && !defined (ACE_HAS_NOTSUP_SC_PAGESIZE)
+  return ::sysconf (_SC_PAGESIZE);
+#elif defined (ACE_HAS_GETPAGESIZE)
+  return ::getpagesize ();
+#else
+  // Use the default set in config.h
+  return ACE_PAGE_SIZE;
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE long
+ACE_OS::allocation_granularity (void)
+{
+#if defined (ACE_WIN32)
+  SYSTEM_INFO sys_info;
+  ::GetSystemInfo (&sys_info);
+  return sys_info.dwAllocationGranularity;
+#else
+  return ACE_OS::getpagesize ();
+#endif /* ACE_WIN32 */
+}
+
+#if !defined (ACE_LACKS_CHDIR)
+ACE_INLINE int
+ACE_OS::chdir (const char *path)
+{
+  ACE_OS_TRACE ("ACE_OS::chdir");
+#if defined (ACE_HAS_NONCONST_CHDIR)
+  ACE_OSCALL_RETURN (::chdir (const_cast<char *> (path)), int, -1);
+#elif defined (ACE_HAS_WINCE)
+  ACE_UNUSED_ARG (path);
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::chdir (path), int, -1);
+#endif /* ACE_HAS_NONCONST_CHDIR */
+}
+
+#if defined (ACE_HAS_WCHAR)
+ACE_INLINE int
+ACE_OS::chdir (const wchar_t *path)
+{
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+  ACE_OSCALL_RETURN (::_wchdir (path), int, -1);
+#else /* ACE_WIN32 */
+  return ACE_OS::chdir (ACE_Wide_To_Ascii (path).char_rep ());
+#endif /* ACE_WIN32 */
+}
+#endif /* ACE_HAS_WCHAR */
+#endif /* ACE_LACKS_CHDIR */
+
+ACE_INLINE int
+ACE_OS::rmdir (const char *path)
+{
+#if defined (ACE_HAS_WINCE)
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::RemoveDirectory (ACE_TEXT_CHAR_TO_TCHAR (path)),
+                                          ace_result_),
+                        int, -1);
+#else
+  ACE_OSCALL_RETURN (::rmdir (path), int, -1);
+#endif /* ACE_WIN32 */
+}
+
+#if defined (ACE_HAS_WCHAR)
+ACE_INLINE int
+ACE_OS::rmdir (const wchar_t *path)
+{
+#if defined (ACE_HAS_WINCE)
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::RemoveDirectoryW (path),
+                                          ace_result_),
+                        int, -1);
+#elif defined (ACE_WIN32)
+  ACE_OSCALL_RETURN (::_wrmdir (path), int, -1);
+#else
+  ACE_Wide_To_Ascii n_path (path);
+  return ACE_OS::rmdir (n_path.char_rep ());
+#endif /* ACE_HAS_WINCE */
+}
+#endif /* ACE_HAS_WCHAR */
+
+// @todo: which 4 and why???  dhinton
+// NOTE: The following four function definitions must appear before
+// ACE_OS::sema_init ().
+
+ACE_INLINE int
+ACE_OS::close (ACE_HANDLE handle)
+{
+  ACE_OS_TRACE ("ACE_OS::close");
+#if defined (ACE_WIN32)
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (handle), ace_result_), int, -1);
+#else
+  ACE_OSCALL_RETURN (::close (handle), int, -1);
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE ACE_HANDLE
+ACE_OS::dup (ACE_HANDLE handle)
+{
+  ACE_OS_TRACE ("ACE_OS::dup");
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+  ACE_HANDLE new_fd;
+  if (::DuplicateHandle(::GetCurrentProcess (),
+                        handle,
+                        ::GetCurrentProcess(),
+                        &new_fd,
+                        0,
+                        TRUE,
+                        DUPLICATE_SAME_ACCESS))
+    return new_fd;
+  else
+    ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
+  /* NOTREACHED */
+#elif defined (ACE_LACKS_DUP)
+  ACE_UNUSED_ARG (handle);
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_HAS_WINCE)
+  ACE_UNUSED_ARG (handle);
+  ACE_NOTSUP_RETURN (0);
+#else
+  ACE_OSCALL_RETURN (::dup (handle), ACE_HANDLE, ACE_INVALID_HANDLE);
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE */
+}
+
+ACE_INLINE int
+ACE_OS::dup2 (ACE_HANDLE oldhandle, ACE_HANDLE newhandle)
+{
+  ACE_OS_TRACE ("ACE_OS::dup2");
+#if defined (ACE_LACKS_DUP2)
+  // msvcrt has _dup2 ?!
+  ACE_UNUSED_ARG (oldhandle);
+  ACE_UNUSED_ARG (newhandle);
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::dup2 (oldhandle, newhandle), int, -1);
+#endif /* ACE_LACKS_DUP2 */
+}
+
+ACE_INLINE int
+ACE_OS::execv (const char *path,
+               char *const argv[])
+{
+  ACE_OS_TRACE ("ACE_OS::execv");
+#if defined (ACE_LACKS_EXEC)
+  ACE_UNUSED_ARG (path);
+  ACE_UNUSED_ARG (argv);
+
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_WIN32)
+# if defined (__BORLANDC__) /* VSB */
+  return ::execv (path, argv);
+# elif defined (__MINGW32__)
+  return ::_execv (path, (char *const *) argv);
+# else
+  // Why this odd-looking code? If execv() returns at all, it's an error.
+  // Windows defines this as returning an intptr_t rather than a simple int,
+  // and the conversion triggers compile warnings. So just return -1 if
+  // the call returns.
+  ::_execv (path, (const char *const *) argv);
+  return -1;
+# endif /* __BORLANDC__ */
+#else
+  ACE_OSCALL_RETURN (::execv (path, argv), int, -1);
+#endif /* ACE_LACKS_EXEC */
+}
+
+ACE_INLINE int
+ACE_OS::execve (const char *path,
+                char *const argv[],
+                char *const envp[])
+{
+  ACE_OS_TRACE ("ACE_OS::execve");
+#if defined (ACE_LACKS_EXEC)
+  ACE_UNUSED_ARG (path);
+  ACE_UNUSED_ARG (argv);
+  ACE_UNUSED_ARG (envp);
+
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_WIN32)
+# if defined (__BORLANDC__) /* VSB */
+  return ::execve (path, argv, envp);
+# elif defined (__MINGW32__)
+  return ::_execve (path, (char *const *) argv, (char *const *) envp);
+# else
+  // Why this odd-looking code? If execv() returns at all, it's an error.
+  // Windows defines this as returning an intptr_t rather than a simple int,
+  // and the conversion triggers compile warnings. So just return -1 if
+  // the call returns.
+  ::_execve (path, (const char *const *) argv, (const char *const *) envp);
+  return -1;
+# endif /* __BORLANDC__ */
+#else
+  ACE_OSCALL_RETURN (::execve (path, argv, envp), int, -1);
+#endif /* ACE_LACKS_EXEC */
+}
+
+ACE_INLINE int
+ACE_OS::execvp (const char *file,
+                char *const argv[])
+{
+  ACE_OS_TRACE ("ACE_OS::execvp");
+#if defined (ACE_LACKS_EXEC)
+  ACE_UNUSED_ARG (file);
+  ACE_UNUSED_ARG (argv);
+
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_WIN32)
+# if defined (__BORLANDC__) /* VSB */
+  return ::execvp (file, argv);
+# elif defined (__MINGW32__)
+  return ::_execvp (file, (char *const *) argv);
+# else
+  // Why this odd-looking code? If execv() returns at all, it's an error.
+  // Windows defines this as returning an intptr_t rather than a simple int,
+  // and the conversion triggers compile warnings. So just return -1 if
+  // the call returns.
+  ::_execvp (file, (const char *const *) argv);
+  return -1;
+# endif /* __BORLANDC__ */
+#else
+  ACE_OSCALL_RETURN (::execvp (file, argv), int, -1);
+#endif /* ACE_LACKS_EXEC */
+}
+
+ACE_INLINE pid_t
+ACE_OS::fork (void)
+{
+  ACE_OS_TRACE ("ACE_OS::fork");
+#if defined (ACE_LACKS_FORK)
+  ACE_NOTSUP_RETURN (pid_t (-1));
+#else
+  ACE_OSCALL_RETURN (::fork (), pid_t, -1);
+#endif /* ACE_LACKS_FORK */
+}
+
+ACE_INLINE int
+ACE_OS::fsync (ACE_HANDLE handle)
+{
+  ACE_OS_TRACE ("ACE_OS::fsync");
+# if defined (ACE_LACKS_FSYNC)
+  ACE_UNUSED_ARG (handle);
+  ACE_NOTSUP_RETURN (-1);
+# elif defined (ACE_WIN32)
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FlushFileBuffers (handle), ace_result_), int, -1);
+# else
+  ACE_OSCALL_RETURN (::fsync (handle), int, -1);
+# endif /* ACE_LACKS_FSYNC */
+}
+
+ACE_INLINE int
+ACE_OS::ftruncate (ACE_HANDLE handle, ACE_OFF_T offset)
+{
+  ACE_OS_TRACE ("ACE_OS::ftruncate");
+#if defined (ACE_WIN32)
+#  if !defined (ACE_LACKS_WIN32_SETFILEPOINTEREX)
+  LARGE_INTEGER loff;
+  loff.QuadPart = offset;
+  if (::SetFilePointerEx (handle, loff, 0, FILE_BEGIN))
+#  else
+  if (::SetFilePointer (handle,
+                        offset,
+                        0,
+                        FILE_BEGIN) != INVALID_SET_FILE_POINTER)
+#  endif
+    ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetEndOfFile (handle), ace_result_), int, -1);
+  else
+    ACE_FAIL_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::ftruncate (handle, offset), int, -1);
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE char *
+ACE_OS::getcwd (char *buf, size_t size)
+{
+  ACE_OS_TRACE ("ACE_OS::getcwd");
+#if defined (ACE_LACKS_GETCWD)
+  ACE_UNUSED_ARG (buf);
+  ACE_UNUSED_ARG (size);
+  ACE_NOTSUP_RETURN (0);
+#elif defined (ACE_WIN32)
+  return ::getcwd (buf, static_cast<int> (size));
+#else
+  ACE_OSCALL_RETURN (::getcwd (buf, size), char *, 0);
+#endif /* ACE_LACKS_GETCWD */
+}
+
+#if defined (ACE_HAS_WCHAR)
+ACE_INLINE wchar_t *
+ACE_OS::getcwd (wchar_t *buf, size_t size)
+{
+#  if defined (ACE_HAS_WINCE)
+  ACE_UNUSED_ARG (buf);
+  ACE_UNUSED_ARG (size);
+  ACE_NOTSUP_RETURN (0);
+#  elif defined (ACE_WIN32)
+  return ::_wgetcwd (buf, static_cast<int> (size));
+#  else
+  char *narrow_buf = new char[size];
+  char *result = 0;
+  result = ACE_OS::getcwd (narrow_buf, size);
+  ACE_Ascii_To_Wide wide_buf (result);
+  delete [] narrow_buf;
+  if (result != 0)
+    ACE_OS::strsncpy (buf, wide_buf.wchar_rep (), size);
+  return result == 0 ? 0 : buf;
+#  endif /* ACE_WIN32 */
+}
+#endif /* ACE_HAS_WCHAR */
+
+ACE_INLINE gid_t
+ACE_OS::getgid (void)
+{
+  ACE_OS_TRACE ("ACE_OS::getgid");
+#if defined (ACE_LACKS_GETGID)
+  ACE_NOTSUP_RETURN (static_cast<gid_t> (-1));
+# else
+  ACE_OSCALL_RETURN (::getgid (), gid_t, static_cast<gid_t> (-1));
+# endif /* ACE_LACKS_GETGID */
+}
+
+ACE_INLINE gid_t
+ACE_OS::getegid (void)
+{
+  ACE_OS_TRACE ("ACE_OS::getegid");
+#if defined (ACE_LACKS_GETEGID)
+  ACE_NOTSUP_RETURN (static_cast<gid_t> (-1));
+# else
+  ACE_OSCALL_RETURN (::getegid (), gid_t, static_cast<gid_t> (-1));
+# endif /* ACE_LACKS_GETEGID */
+}
+
+ACE_INLINE int
+ACE_OS::getopt (int argc, char *const *argv, const char *optstring)
+{
+  ACE_OS_TRACE ("ACE_OS::getopt");
+#if defined (ACE_LACKS_GETOPT)
+  ACE_UNUSED_ARG (argc);
+  ACE_UNUSED_ARG (argv);
+  ACE_UNUSED_ARG (optstring);
+  ACE_NOTSUP_RETURN (-1);
+# else
+  ACE_OSCALL_RETURN (::getopt (argc, argv, optstring), int, -1);
+# endif /* ACE_LACKS_GETOPT */
+}
+
+ACE_INLINE pid_t
+ACE_OS::getpgid (pid_t pid)
+{
+  ACE_OS_TRACE ("ACE_OS::getpgid");
+#if defined (ACE_LACKS_GETPGID)
+  ACE_UNUSED_ARG (pid);
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (linux) && __GLIBC__ > 1 && __GLIBC_MINOR__ >= 0
+  // getpgid() is from SVR4, which appears to be the reason why GLIBC
+  // doesn't enable its prototype by default.
+  // Rather than create our own extern prototype, just use the one
+  // that is visible (ugh).
+  ACE_OSCALL_RETURN (::__getpgid (pid), pid_t, -1);
+#else
+  ACE_OSCALL_RETURN (::getpgid (pid), pid_t, -1);
+#endif /* ACE_LACKS_GETPGID */
+}
+
+ACE_INLINE pid_t
+ACE_OS::getpid (void)
+{
+  // ACE_OS_TRACE ("ACE_OS::getpid");
+#if defined (ACE_LACKS_GETPID)
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_WIN32)
+  return ::GetCurrentProcessId ();
+#else
+  ACE_OSCALL_RETURN (::getpid (), int, -1);
+#endif /* ACE_LACKS_GETPID */
+}
+
+ACE_INLINE pid_t
+ACE_OS::getppid (void)
+{
+  ACE_OS_TRACE ("ACE_OS::getppid");
+#if defined (ACE_LACKS_GETPPID)
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::getppid (), pid_t, -1);
+#endif /* ACE_LACKS_GETPPID */
+}
+
+ACE_INLINE uid_t
+ACE_OS::getuid (void)
+{
+  ACE_OS_TRACE ("ACE_OS::getuid");
+#if defined (ACE_LACKS_GETUID)
+  ACE_NOTSUP_RETURN (static_cast<uid_t> (-1));
+# else
+  ACE_OSCALL_RETURN (::getuid (), uid_t, static_cast<uid_t> (-1));
+# endif /* ACE_LACKS_GETUID*/
+}
+
+ACE_INLINE uid_t
+ACE_OS::geteuid (void)
+{
+  ACE_OS_TRACE ("ACE_OS::geteuid");
+#if defined (ACE_LACKS_GETEUID)
+  ACE_NOTSUP_RETURN (static_cast<uid_t> (-1));
+# else
+  ACE_OSCALL_RETURN (::geteuid (), uid_t, (uid_t) -1);
+# endif /* ACE_LACKS_GETEUID */
+}
+
+ACE_INLINE int
+ACE_OS::hostname (char name[], size_t maxnamelen)
+{
+  ACE_OS_TRACE ("ACE_OS::hostname");
+#if defined (ACE_HAS_PHARLAP)
+  // PharLap only can do net stuff with the RT version.
+#   if defined (ACE_HAS_PHARLAP_RT)
+  // @@This is not at all reliable... requires ethernet and BOOTP to be used.
+  // A more reliable way is to go thru the devices w/ EtsTCPGetDeviceCfg until
+  // a legit IP address is found, then get its name w/ gethostbyaddr.
+  ACE_SOCKCALL_RETURN (gethostname (name, maxnamelen), int, SOCKET_ERROR);
+#   else
+  ACE_UNUSED_ARG (name);
+  ACE_UNUSED_ARG (maxnamelen);
+  ACE_NOTSUP_RETURN (-1);
+#   endif /* ACE_HAS_PHARLAP_RT */
+#elif defined (ACE_VXWORKS) || defined (ACE_HAS_WINCE)
+  ACE_OSCALL_RETURN (::gethostname (name, maxnamelen), int, -1);
+#elif defined (ACE_WIN32)
+  if (::gethostname (name, ACE_Utils::truncate_cast<int> (maxnamelen)) == 0)
+  {
+    return 0;
+  }
+  else
+  {
+    ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::GetComputerNameA (name,
+                                            LPDWORD (&maxnamelen)),
+                                            ace_result_), int, -1);
+  }
+#else /* ACE_HAS_PHARLAP */
+  ACE_utsname host_info;
+
+  if (ACE_OS::uname (&host_info) == -1)
+    return -1;
+  else
+    {
+      ACE_OS::strsncpy (name, host_info.nodename, maxnamelen);
+      return 0;
+    }
+#endif /* ACE_HAS_PHARLAP */
+}
+
+#if defined (ACE_HAS_WCHAR)
+ACE_INLINE int
+ACE_OS::hostname (wchar_t name[], size_t maxnamelen)
+{
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (GetComputerNameW (name,
+                                                        LPDWORD (&maxnamelen)),
+                                          ace_result_), int, -1);
+#else /* ACE_WIN32 && !ACE_HAS_WINCE */
+  // Emulate using the char version
+  char *char_name = 0;
+  int result = 0;
+
+  ACE_NEW_RETURN (char_name, char[maxnamelen], -1);
+
+  result = ACE_OS::hostname(char_name, maxnamelen);
+  ACE_OS::strcpy (name, ACE_Ascii_To_Wide (char_name).wchar_rep ());
+
+  delete [] char_name;
+  return result;
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE */
+}
+#endif /* ACE_HAS_WCHAR */
+
+ACE_INLINE int
+ACE_OS::isatty (int handle)
+{
+  ACE_OS_TRACE ("ACE_OS::isatty");
+#if defined (ACE_LACKS_ISATTY)
+  ACE_UNUSED_ARG (handle);
+  return 0;
+# elif defined (ACE_WIN32)
+  return ::_isatty (handle);
+# else
+  ACE_OSCALL_RETURN (::isatty (handle), int, -1);
+# endif /* ACE_LACKS_ISATTY */
+}
+
+#if defined (ACE_WIN32)
+ACE_INLINE int
+ACE_OS::isatty (ACE_HANDLE handle)
+{
+#if defined (ACE_LACKS_ISATTY)
+  ACE_UNUSED_ARG (handle);
+  return 0;
+#else
+  int fd = ::_open_osfhandle (intptr_t (handle), 0);
+  int status = ::_isatty (fd);
+  ::_close (fd);
+  return status;
+#endif /* ACE_LACKS_ISATTY */
+}
+
+#endif /* ACE_WIN32 */
+
+ACE_INLINE ACE_OFF_T
+ACE_OS::lseek (ACE_HANDLE handle, ACE_OFF_T offset, int whence)
+{
+  ACE_OS_TRACE ("ACE_OS::lseek");
+#if defined (ACE_WIN32)
+# if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END
+  //#error Windows NT is evil AND rude!
+  switch (whence)
+    {
+    case SEEK_SET:
+      whence = FILE_BEGIN;
+      break;
+    case SEEK_CUR:
+      whence = FILE_CURRENT;
+      break;
+    case SEEK_END:
+      whence = FILE_END;
+      break;
+    default:
+      errno = EINVAL;
+      return static_cast<ACE_OFF_T> (-1); // rather safe than sorry
+    }
+# endif  /* SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END */
+  LONG low_offset = ACE_LOW_PART(offset);
+  LONG high_offset = ACE_HIGH_PART(offset);
+  DWORD const result =
+    ::SetFilePointer (handle, low_offset, &high_offset, whence);
+  if (result == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
+    ACE_FAIL_RETURN (static_cast<ACE_OFF_T> (-1));
+  else
+    return result;
+#else
+  ACE_OSCALL_RETURN (::lseek (handle, offset, whence), ACE_OFF_T, -1);
+#endif /* ACE_WIN32 */
+}
+
+#if defined (ACE_HAS_LLSEEK) || defined (ACE_HAS_LSEEK64)
+ACE_INLINE ACE_LOFF_T
+ACE_OS::llseek (ACE_HANDLE handle, ACE_LOFF_T offset, int whence)
+{
+  ACE_OS_TRACE ("ACE_OS::llseek");
+
+#if ACE_SIZEOF_LONG == 8
+  /* The native lseek is 64 bit.  Use it. */
+  return ACE_OS::lseek (handle, offset, whence);
+#elif defined (ACE_HAS_LLSEEK) && defined (ACE_HAS_LSEEK64)
+# error Either ACE_HAS_LSEEK64 and ACE_HAS_LLSEEK should be defined, not both!
+#elif defined (ACE_HAS_LSEEK64)
+  ACE_OSCALL_RETURN (::lseek64 (handle, offset, whence), ACE_LOFF_T, -1);
+#elif defined (ACE_HAS_LLSEEK)
+# if defined (ACE_WIN32)
+#  ifndef ACE_LACKS_WIN32_SETFILEPOINTEREX
+  LARGE_INTEGER distance, new_file_pointer;
+
+  distance.QuadPart = offset;
+
+  return
+    (::SetFilePointerEx (handle, distance, &new_file_pointer, whence)
+     ? new_file_pointer.QuadPart
+     : static_cast<ACE_LOFF_T> (-1));
+#  else
+  LARGE_INTEGER l_offset;
+  l_offset.QuadPart = offset;
+  LONG low_offset = l_offset.LowPart;
+  LONG high_offset = l_offset.HighPart;
+
+  l_offset.LowPart = ::SetFilePointer (handle,
+                                       low_offset,
+                                       &high_offset,
+                                       whence);
+  if (l_offset.LowPart == INVALID_SET_FILE_POINTER &&
+      GetLastError () != NO_ERROR)
+    return static_cast<ACE_LOFF_T> (-1);
+  l_offset.HighPart = high_offset;
+  return l_offset.QuadPart;
+#  endif  /* ACE_LACKS_WIN32_SETFILEPOINTEREX */
+# else
+    ACE_OSCALL_RETURN (::llseek (handle, offset, whence), ACE_LOFF_T, -1);
+# endif /* WIN32 */
+#endif
+}
+#endif /* ACE_HAS_LLSEEK || ACE_HAS_LSEEK64 */
+
+ACE_INLINE ssize_t
+ACE_OS::read (ACE_HANDLE handle, void *buf, size_t len)
+{
+  ACE_OS_TRACE ("ACE_OS::read");
+#if defined (ACE_WIN32)
+  DWORD ok_len;
+  if (::ReadFile (handle, buf, static_cast<DWORD> (len), &ok_len, 0))
+    return (ssize_t) ok_len;
+  else
+    ACE_FAIL_RETURN (-1);
+#else
+
+  ssize_t result;
+
+# if defined (ACE_HAS_CHARPTR_SOCKOPT)
+  ACE_OSCALL (::read (handle, static_cast <char *> (buf), len), ssize_t, -1, result);
+# else
+  ACE_OSCALL (::read (handle, buf, len), ssize_t, -1, result);
+# endif /* ACE_HAS_CHARPTR_SOCKOPT */
+
+# if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
+  // Optimize this code out if we can detect that EAGAIN ==
+  // EWOULDBLOCK at compile time.  If we cannot detect equality at
+  // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor
+  // macros) perform the check at run-time.  The goal is to avoid two
+  // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK.
+  if (result == -1
+#  if !defined (EAGAIN) || !defined (EWOULDBLOCK)
+      && EAGAIN != EWOULDBLOCK
+#  endif  /* !EAGAIN || !EWOULDBLOCK */
+      && errno == EAGAIN)
+    {
+      errno = EWOULDBLOCK;
+    }
+# endif /* EAGAIN != EWOULDBLOCK*/
+
+  return result;
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE ssize_t
+ACE_OS::read (ACE_HANDLE handle, void *buf, size_t len,
+              ACE_OVERLAPPED *overlapped)
+{
+  ACE_OS_TRACE ("ACE_OS::read");
+  overlapped = overlapped;
+#if defined (ACE_WIN32)
+  DWORD ok_len;
+  DWORD short_len = static_cast<DWORD> (len);
+  if (::ReadFile (handle, buf, short_len, &ok_len, overlapped))
+    return (ssize_t) ok_len;
+  else
+    ACE_FAIL_RETURN (-1);
+#else
+  return ACE_OS::read (handle, buf, len);
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE ssize_t
+ACE_OS::readlink (const char *path, char *buf, size_t bufsiz)
+{
+  ACE_OS_TRACE ("ACE_OS::readlink");
+# if defined (ACE_LACKS_READLINK)
+  ACE_UNUSED_ARG (path);
+  ACE_UNUSED_ARG (buf);
+  ACE_UNUSED_ARG (bufsiz);
+  ACE_NOTSUP_RETURN (-1);
+# else
+#   if !defined(ACE_HAS_NONCONST_READLINK)
+      ACE_OSCALL_RETURN (::readlink (path, buf, bufsiz), ssize_t, -1);
+#   else
+      ACE_OSCALL_RETURN (
+        ::readlink (const_cast <char *>(path), buf, bufsiz), ssize_t, -1);
+#   endif
+# endif /* ACE_LACKS_READLINK */
+}
+
+ACE_INLINE int
+ACE_OS::pipe (ACE_HANDLE fds[])
+{
+  ACE_OS_TRACE ("ACE_OS::pipe");
+# if defined (ACE_LACKS_PIPE)
+  ACE_UNUSED_ARG (fds);
+  ACE_NOTSUP_RETURN (-1);
+# elif defined (ACE_WIN32)
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL
+                        (::CreatePipe (&fds[0], &fds[1], 0, 0),
+                         ace_result_), int, -1);
+# else
+  ACE_OSCALL_RETURN (::pipe (fds), int, -1);
+# endif /* ACE_LACKS_PIPE */
+}
+
+ACE_INLINE void *
+ACE_OS::sbrk (intptr_t brk)
+{
+#if defined (ACE_LACKS_SBRK)
+  ACE_UNUSED_ARG (brk);
+  ACE_NOTSUP_RETURN (0);
+#else
+  ACE_OSCALL_RETURN (::sbrk (brk), void *, 0);
+#endif /* ACE_LACKS_SBRK */
+}
+
+ACE_INLINE int
+ACE_OS::setgid (gid_t gid)
+{
+  ACE_OS_TRACE ("ACE_OS::setgid");
+#if defined (ACE_LACKS_SETGID)
+  ACE_UNUSED_ARG (gid);
+  ACE_NOTSUP_RETURN (-1);
+# else
+  ACE_OSCALL_RETURN (::setgid (gid), int,  -1);
+# endif /* ACE_LACKS_SETGID */
+}
+
+ACE_INLINE int
+ACE_OS::setegid (gid_t gid)
+{
+  ACE_OS_TRACE ("ACE_OS::setegid");
+#if defined (ACE_LACKS_SETEGID)
+  ACE_UNUSED_ARG (gid);
+  ACE_NOTSUP_RETURN (-1);
+# else
+  ACE_OSCALL_RETURN (::setegid (gid), int,  -1);
+# endif /* ACE_LACKS_SETEGID */
+}
+
+ACE_INLINE int
+ACE_OS::setpgid (pid_t pid, pid_t pgid)
+{
+  ACE_OS_TRACE ("ACE_OS::setpgid");
+#if defined (ACE_LACKS_SETPGID)
+  ACE_UNUSED_ARG (pid);
+  ACE_UNUSED_ARG (pgid);
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::setpgid (pid, pgid), int, -1);
+#endif /* ACE_LACKS_SETPGID */
+}
+
+ACE_INLINE int
+ACE_OS::setregid (gid_t rgid, gid_t egid)
+{
+  ACE_OS_TRACE ("ACE_OS::setregid");
+#if defined (ACE_LACKS_SETREGID)
+  ACE_UNUSED_ARG (rgid);
+  ACE_UNUSED_ARG (egid);
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::setregid (rgid, egid), int, -1);
+#endif /* ACE_LACKS_SETREGID */
+}
+
+ACE_INLINE int
+ACE_OS::setreuid (uid_t ruid, uid_t euid)
+{
+  ACE_OS_TRACE ("ACE_OS::setreuid");
+#if defined (ACE_LACKS_SETREUID)
+  ACE_UNUSED_ARG (ruid);
+  ACE_UNUSED_ARG (euid);
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::setreuid (ruid, euid), int, -1);
+#endif /* ACE_LACKS_SETREUID */
+}
+
+ACE_INLINE pid_t
+ACE_OS::setsid (void)
+{
+  ACE_OS_TRACE ("ACE_OS::setsid");
+#if defined (ACE_LACKS_SETSID)
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::setsid (), int, -1);
+# endif /* ACE_LACKS_SETSID */
+}
+
+ACE_INLINE int
+ACE_OS::setuid (uid_t uid)
+{
+  ACE_OS_TRACE ("ACE_OS::setuid");
+#if defined (ACE_LACKS_SETUID)
+  ACE_UNUSED_ARG (uid);
+  ACE_NOTSUP_RETURN (-1);
+# else
+  ACE_OSCALL_RETURN (::setuid (uid), int,  -1);
+# endif /* ACE_LACKS_SETUID */
+}
+
+ACE_INLINE int
+ACE_OS::seteuid (uid_t uid)
+{
+  ACE_OS_TRACE ("ACE_OS::seteuid");
+#if defined (ACE_LACKS_SETEUID)
+  ACE_UNUSED_ARG (uid);
+  ACE_NOTSUP_RETURN (-1);
+# else
+  ACE_OSCALL_RETURN (::seteuid (uid), int,  -1);
+# endif /* ACE_LACKS_SETEUID */
+}
+
+ACE_INLINE int
+ACE_OS::sleep (u_int seconds)
+{
+  ACE_OS_TRACE ("ACE_OS::sleep");
+#if defined (ACE_WIN32)
+  ::Sleep (seconds * ACE_ONE_SECOND_IN_MSECS);
+  return 0;
+#elif defined (ACE_HAS_CLOCK_GETTIME)
+  struct timespec rqtp;
+  // Initializer doesn't work with Green Hills 1.8.7
+  rqtp.tv_sec = seconds;
+  rqtp.tv_nsec = 0L;
+  //FUZZ: disable check_for_lack_ACE_OS
+  ACE_OSCALL_RETURN (::nanosleep (&rqtp, 0), int, -1);
+  //FUZZ: enable check_for_lack_ACE_OS
+#else
+  ACE_OSCALL_RETURN (::sleep (seconds), int, -1);
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE int
+ACE_OS::sleep (const ACE_Time_Value &tv)
+{
+  ACE_OS_TRACE ("ACE_OS::sleep");
+#if defined (ACE_WIN32)
+  ::Sleep (tv.msec ());
+  return 0;
+#elif defined (ACE_HAS_CLOCK_GETTIME)
+  timespec_t rqtp = tv;
+  //FUZZ: disable check_for_lack_ACE_OS
+  ACE_OSCALL_RETURN (::nanosleep (&rqtp, 0), int, -1);
+  //FUZZ: enable check_for_lack_ACE_OS
+#else
+# if defined (ACE_HAS_NONCONST_SELECT_TIMEVAL)
+  // Copy the timeval, because this platform doesn't declare the timeval
+  // as a pointer to const.
+  timeval tv_copy = tv;
+#  if defined(ACE_TANDEM_T1248_PTHREADS)
+     ACE_OSCALL_RETURN (::spt_select (0, 0, 0, 0, &tv_copy), int, -1);
+#  else
+     //FUZZ: disable check_for_lack_ACE_OS
+     ACE_OSCALL_RETURN (::select (0, 0, 0, 0, &tv_copy), int, -1);
+     //FUZZ: enable check_for_lack_ACE_OS
+#  endif
+# else  /* ! ACE_HAS_NONCONST_SELECT_TIMEVAL */
+  const timeval *tvp = tv;
+  //FUZZ: disable check_for_lack_ACE_OS
+  ACE_OSCALL_RETURN (::select (0, 0, 0, 0, tvp), int, -1);
+  //FUZZ: enable check_for_lack_ACE_OS
+# endif /* ACE_HAS_NONCONST_SELECT_TIMEVAL */
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE void
+ACE_OS::swab (const void *src,
+              void *dest,
+              ssize_t length)
+{
+#if defined (ACE_LACKS_SWAB)
+  // ------------------------------------------------------------
+  // The following copyright notice applies to the swab()
+  // implementation within this "ACE_LACKS_SWAB" block of code.
+  // ------------------------------------------------------------
+  /*
+    Copyright (c) 1994-2006  Red Hat, Inc. All rights reserved.
+
+    This copyrighted material is made available to anyone wishing to
+    use, modify, copy, or redistribute it subject to the terms and
+    conditions of the BSD License.   This program is distributed in
+    the hope that it will be useful, but WITHOUT ANY WARRANTY
+    expressed or implied, including the implied warranties of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  A copy of
+    this license is available at
+    http://www.opensource.org/licenses. Any Red Hat trademarks that
+    are incorporated in the source code or documentation are not
+    subject to the BSD License and may only be used or replicated with
+    the express permission of Red Hat, Inc.
+  */
+
+  const char *from = static_cast<const char*> (src);
+  char *to = static_cast<char *> (dest);
+  ssize_t ptr = 0;
+  for (ptr = 1; ptr < length; ptr += 2)
+    {
+      char p = from[ptr];
+      char q = from[ptr-1];
+      to[ptr-1] = p;
+      to[ptr  ] = q;
+    }
+  if (ptr == length) /* I.e., if length is odd, */
+    to[ptr-1] = 0;   /* then pad with a NUL. */
+#elif defined (ACE_HAS_NONCONST_SWAB)
+  const char *tmp = static_cast<const char*> (src);
+  char *from = const_cast<char *> (tmp);
+  char *to = static_cast<char *> (dest);
+  ::swab (from, to, length);
+#elif defined (ACE_HAS_CONST_CHAR_SWAB)
+  const char *from = static_cast<const char*> (src);
+  char *to = static_cast<char *> (dest);
+  ::swab (from, to, length);
+#else
+  ::swab (src, dest, length);
+#endif /* ACE_LACKS_SWAB */
+
+}
+
+ACE_INLINE long
+ACE_OS::sysconf (int name)
+{
+  ACE_OS_TRACE ("ACE_OS::sysconf");
+#if defined (ACE_LACKS_SYSCONF)
+  ACE_UNUSED_ARG (name);
+  ACE_NOTSUP_RETURN (-1);
+#else
+  ACE_OSCALL_RETURN (::sysconf (name), long, -1);
+#endif /* ACE_LACKS_SYSCONF */
+}
+
+ACE_INLINE long
+ACE_OS::sysinfo (int cmd, char *buf, long count)
+{
+  ACE_OS_TRACE ("ACE_OS::sysinfo");
+#if defined (ACE_HAS_SYSINFO)
+  ACE_OSCALL_RETURN (::sysinfo (cmd, buf, count), long, -1);
+#else
+  ACE_UNUSED_ARG (cmd);
+  ACE_UNUSED_ARG (buf);
+  ACE_UNUSED_ARG (count);
+
+  ACE_NOTSUP_RETURN (0);
+#endif /* ACE_HAS_SYSINFO */
+}
+
+ACE_INLINE int
+ACE_OS::truncate (const ACE_TCHAR *filename,
+                  ACE_OFF_T offset)
+{
+  ACE_OS_TRACE ("ACE_OS::truncate");
+#if defined (ACE_WIN32)
+  ACE_HANDLE handle = ACE_OS::open (filename,
+                                    O_WRONLY,
+                                    ACE_DEFAULT_FILE_PERMS);
+
+#  if !defined (ACE_LACKS_WIN32_SETFILEPOINTEREX)
+  LARGE_INTEGER loffset;
+  loffset.QuadPart = offset;
+#else
+  LONG low_offset = ACE_LOW_PART(offset);
+  LONG high_offset = ACE_HIGH_PART(offset);
+#endif
+
+  if (handle == ACE_INVALID_HANDLE)
+    ACE_FAIL_RETURN (-1);
+
+#  if !defined (ACE_LACKS_WIN32_SETFILEPOINTEREX)
+  else if (::SetFilePointerEx (handle,
+                               loffset,
+                               0,
+                               FILE_BEGIN))
+#  else
+  else if (::SetFilePointer (handle,
+                             low_offset,
+                             &high_offset,
+                             FILE_BEGIN) != INVALID_SET_FILE_POINTER
+           || GetLastError () == NO_ERROR)
+#  endif /* ACE_LACKS_WIN32_SETFILEPOINTEREX */
+    {
+      BOOL result = ::SetEndOfFile (handle);
+      ::CloseHandle (handle);
+      ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (result, ace_result_), int, -1);
+    }
+  else
+    {
+      ::CloseHandle (handle);
+      ACE_FAIL_RETURN (-1);
+    }
+  /* NOTREACHED */
+#elif !defined (ACE_LACKS_TRUNCATE)
+  ACE_OSCALL_RETURN
+    (::truncate (ACE_TEXT_ALWAYS_CHAR (filename), offset), int, -1);
+#else
+  ACE_UNUSED_ARG (filename);
+  ACE_UNUSED_ARG (offset);
+  ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE useconds_t
+ACE_OS::ualarm (useconds_t usecs, useconds_t interval)
+{
+  ACE_OS_TRACE ("ACE_OS::ualarm");
+
+#if defined (ACE_HAS_UALARM)
+  return ::ualarm (usecs, interval);
+#elif !defined (ACE_LACKS_UNIX_SIGNALS)
+  ACE_UNUSED_ARG (interval);
+  return ::alarm (usecs * ACE_ONE_SECOND_IN_USECS);
+#else
+  ACE_UNUSED_ARG (usecs);
+  ACE_UNUSED_ARG (interval);
+  ACE_NOTSUP_RETURN (0);
+#endif /* ACE_HAS_UALARM */
+}
+
+ACE_INLINE useconds_t
+ACE_OS::ualarm (const ACE_Time_Value &tv,
+                const ACE_Time_Value &tv_interval)
+{
+  ACE_OS_TRACE ("ACE_OS::ualarm");
+
+#if defined (ACE_HAS_UALARM)
+  useconds_t usecs = (tv.sec () * ACE_ONE_SECOND_IN_USECS) + tv.usec ();
+  useconds_t interval =
+    (tv_interval.sec () * ACE_ONE_SECOND_IN_USECS) + tv_interval.usec ();
+  return ::ualarm (usecs, interval);
+#elif !defined (ACE_LACKS_UNIX_SIGNALS)
+  ACE_UNUSED_ARG (tv_interval);
+  return ::alarm (tv.sec ());
+#else
+  ACE_UNUSED_ARG (tv_interval);
+  ACE_UNUSED_ARG (tv);
+  ACE_NOTSUP_RETURN (0);
+#endif /* ACE_HAS_UALARM */
+}
+
+ACE_INLINE int
+ACE_OS::unlink (const char *path)
+{
+  ACE_OS_TRACE ("ACE_OS::unlink");
+# if defined (ACE_HAS_NONCONST_UNLINK)
+  ACE_OSCALL_RETURN (::unlink (const_cast<char *> (path)), int, -1);
+# elif defined (ACE_HAS_WINCE)
+  // @@ The problem is, DeleteFile is not actually equals to unlink. ;(
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::DeleteFile (ACE_TEXT_CHAR_TO_TCHAR (path)), ace_result_),
+                        int, -1);
+# elif defined (ACE_LACKS_UNLINK)
+  ACE_UNUSED_ARG (path);
+  ACE_NOTSUP_RETURN (-1);
+# else
+  ACE_OSCALL_RETURN (::unlink (path), int, -1);
+# endif /* ACE_HAS_NONCONST_UNLINK */
+}
+
+#if defined (ACE_HAS_WCHAR)
+ACE_INLINE int
+ACE_OS::unlink (const wchar_t *path)
+{
+  ACE_OS_TRACE ("ACE_OS::unlink");
+# if defined (ACE_HAS_WINCE)
+  // @@ The problem is, DeleteFile is not actually equals to unlink. ;(
+  ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::DeleteFileW (path), ace_result_),
+                        int, -1);
+# elif defined (ACE_WIN32)
+  ACE_OSCALL_RETURN (::_wunlink (path), int, -1);
+# else
+  ACE_Wide_To_Ascii npath (path);
+  return ACE_OS::unlink (npath.char_rep ());
+# endif /* ACE_HAS_WINCE */
+}
+#endif /* ACE_HAS_WCHAR */
+
+ACE_INLINE ssize_t
+ACE_OS::write (ACE_HANDLE handle, const void *buf, size_t nbyte)
+{
+  ACE_OS_TRACE ("ACE_OS::write");
+#if defined (ACE_WIN32)
+  DWORD bytes_written; // This is set to 0 byte WriteFile.
+
+  // Strictly correctly, we should loop writing all the data if more
+  // than a DWORD length can hold.
+  DWORD short_nbyte = static_cast<DWORD> (nbyte);
+  if (::WriteFile (handle, buf, short_nbyte, &bytes_written, 0))
+    return (ssize_t) bytes_written;
+  else
+    ACE_FAIL_RETURN (-1);
+#else
+# if defined (ACE_HAS_CHARPTR_SOCKOPT)
+  ACE_OSCALL_RETURN (::write (handle, static_cast <char *> (const_cast <void *> (buf)), nbyte), ssize_t, -1);
+# else
+  ACE_OSCALL_RETURN (::write (handle, buf, nbyte), ssize_t, -1);
+# endif /* ACE_HAS_CHARPTR_SOCKOPT */
+#endif /* ACE_WIN32 */
+}
+
+ACE_INLINE ssize_t
+ACE_OS::write (ACE_HANDLE handle,
+               const void *buf,
+               size_t nbyte,
+               ACE_OVERLAPPED *overlapped)
+{
+  ACE_OS_TRACE ("ACE_OS::write");
+  overlapped = overlapped;
+#if defined (ACE_WIN32)
+  DWORD bytes_written; // This is set to 0 byte WriteFile.
+
+  DWORD short_nbyte = static_cast<DWORD> (nbyte);
+  if (::WriteFile (handle, buf, short_nbyte, &bytes_written, overlapped))
+    return (ssize_t) bytes_written;
+  else
+    ACE_FAIL_RETURN (-1);
+#else
+  return ACE_OS::write (handle, buf, nbyte);
+#endif /* ACE_WIN32 */
+}
+
+ACE_END_VERSIONED_NAMESPACE_DECL