00001
00002
00003
00004
00005 #include "ace/OS_NS_sys_utsname.h"
00006 #include "ace/OS_NS_string.h"
00007 #include "ace/OS_NS_errno.h"
00008 #include "ace/OS_NS_macros.h"
00009 #include "ace/OS_NS_fcntl.h"
00010 #include "ace/Default_Constants.h"
00011 #include "ace/OS_Memory.h"
00012 #include "ace/Truncate.h"
00013
00014 #if defined (ACE_HAS_CLOCK_GETTIME)
00015 # include "ace/os_include/os_time.h"
00016 #endif
00017
00018 #if defined (ACE_LACKS_ACCESS)
00019 # include "ace/OS_NS_stdio.h"
00020 #endif
00021
00022 #if defined (ACE_HAS_ACCESS_EMULATION)
00023 # include "ace/os_include/os_unistd.h"
00024 #endif
00025
00026 #if defined (ACE_VXWORKS) && (((ACE_VXWORKS >= 0x620) && (ACE_VXWORKS <= 0x680)) || defined (ACE_HAS_VXWORKS551_MEDUSA))
00027 # if defined (__RTP__)
00028 # include "ace/os_include/os_strings.h"
00029 # else
00030 # include "ace/os_include/os_string.h"
00031 # endif
00032 #endif
00033
00034 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00035
00036 ACE_INLINE int
00037 ACE_OS::access (const char *path, int amode)
00038 {
00039 ACE_OS_TRACE ("ACE_OS::access");
00040 #if defined (ACE_LACKS_ACCESS)
00041 # if defined (ACE_HAS_ACCESS_EMULATION)
00042
00043
00044 ACE_UNUSED_ARG (amode);
00045 FILE* handle = ACE_OS::fopen (ACE_TEXT_CHAR_TO_TCHAR(path),
00046 ACE_TEXT ("r"));
00047 if (handle != 0)
00048 {
00049 ACE_OS::fclose (handle);
00050 return 0;
00051 }
00052 return -1;
00053 # else
00054 ACE_UNUSED_ARG (path);
00055 ACE_UNUSED_ARG (amode);
00056 ACE_NOTSUP_RETURN (-1);
00057 # endif
00058 #elif defined(ACE_WIN32)
00059
00060 ACE_OSCALL_RETURN (::access (path, amode & 6), int, -1);
00061 #else
00062 ACE_OSCALL_RETURN (::access (path, amode), int, -1);
00063 #endif
00064 }
00065
00066
00067 #if defined (ACE_HAS_WCHAR)
00068 ACE_INLINE int
00069 ACE_OS::access (const wchar_t *path, int amode)
00070 {
00071 #if defined (ACE_WIN32) && !defined (ACE_LACKS__WACCESS)
00072 ACE_OSCALL_RETURN (::_waccess (path, amode), int, -1);
00073 #else
00074 return ACE_OS::access (ACE_Wide_To_Ascii (path).char_rep (), amode);
00075 #endif
00076 }
00077 #endif
00078
00079 ACE_INLINE u_int
00080 ACE_OS::alarm (u_int secs)
00081 {
00082 ACE_OS_TRACE ("ACE_OS::alarm");
00083 #if defined (ACE_LACKS_ALARM)
00084 ACE_UNUSED_ARG (secs);
00085 ACE_NOTSUP_RETURN (0);
00086 #else
00087 return ::alarm (secs);
00088 #endif
00089 }
00090
00091 ACE_INLINE long
00092 ACE_OS::getpagesize (void)
00093 {
00094 ACE_OS_TRACE ("ACE_OS::getpagesize");
00095 #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
00096 SYSTEM_INFO sys_info;
00097 ::GetSystemInfo (&sys_info);
00098 return (long) sys_info.dwPageSize;
00099 #elif defined (_SC_PAGESIZE) && !defined (ACE_HAS_NOTSUP_SC_PAGESIZE)
00100 return ::sysconf (_SC_PAGESIZE);
00101 #elif defined (ACE_HAS_GETPAGESIZE)
00102 return ::getpagesize ();
00103 #else
00104
00105 return ACE_PAGE_SIZE;
00106 #endif
00107 }
00108
00109 ACE_INLINE long
00110 ACE_OS::allocation_granularity (void)
00111 {
00112 #if defined (ACE_WIN32)
00113 SYSTEM_INFO sys_info;
00114 ::GetSystemInfo (&sys_info);
00115 return sys_info.dwAllocationGranularity;
00116 #else
00117 return ACE_OS::getpagesize ();
00118 #endif
00119 }
00120
00121 ACE_INLINE int
00122 ACE_OS::chdir (const char *path)
00123 {
00124 ACE_OS_TRACE ("ACE_OS::chdir");
00125 #if defined (ACE_LACKS_CHDIR)
00126 ACE_UNUSED_ARG (path);
00127 ACE_NOTSUP_RETURN (-1);
00128 #elif defined (ACE_HAS_NONCONST_CHDIR)
00129 ACE_OSCALL_RETURN (::chdir (const_cast<char *> (path)), int, -1);
00130 #else
00131 ACE_OSCALL_RETURN (::chdir (path), int, -1);
00132 #endif
00133 }
00134
00135 #if defined (ACE_HAS_WCHAR)
00136 ACE_INLINE int
00137 ACE_OS::chdir (const wchar_t *path)
00138 {
00139 #if defined (ACE_LACKS_CHDIR)
00140 ACE_UNUSED_ARG (path);
00141 ACE_NOTSUP_RETURN (-1);
00142 #elif defined (ACE_WIN32)
00143 ACE_OSCALL_RETURN (::_wchdir (path), int, -1);
00144 #else
00145 return ACE_OS::chdir (ACE_Wide_To_Ascii (path).char_rep ());
00146 #endif
00147 }
00148 #endif
00149
00150 ACE_INLINE int
00151 ACE_OS::rmdir (const char *path)
00152 {
00153 #if defined (ACE_HAS_WINCE)
00154 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::RemoveDirectory (ACE_TEXT_CHAR_TO_TCHAR(path)),
00155 ace_result_),
00156 int, -1);
00157 #else
00158 ACE_OSCALL_RETURN (::rmdir (path), int, -1);
00159 #endif
00160 }
00161
00162 #if defined (ACE_HAS_WCHAR)
00163 ACE_INLINE int
00164 ACE_OS::rmdir (const wchar_t *path)
00165 {
00166 #if defined (ACE_HAS_WINCE)
00167 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::RemoveDirectoryW (path),
00168 ace_result_),
00169 int, -1);
00170 #elif defined (ACE_WIN32)
00171 ACE_OSCALL_RETURN (::_wrmdir (path), int, -1);
00172 #else
00173 ACE_Wide_To_Ascii n_path (path);
00174 return ACE_OS::rmdir (n_path.char_rep ());
00175 #endif
00176 }
00177 #endif
00178
00179
00180
00181
00182
00183 ACE_INLINE int
00184 ACE_OS::close (ACE_HANDLE handle)
00185 {
00186 ACE_OS_TRACE ("ACE_OS::close");
00187 #if defined (ACE_WIN32)
00188 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (handle), ace_result_), int, -1);
00189 #else
00190 ACE_OSCALL_RETURN (::close (handle), int, -1);
00191 #endif
00192 }
00193
00194 ACE_INLINE ACE_HANDLE
00195 ACE_OS::dup (ACE_HANDLE handle)
00196 {
00197 ACE_OS_TRACE ("ACE_OS::dup");
00198 #if defined (ACE_LACKS_DUP)
00199 ACE_UNUSED_ARG (handle);
00200 ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
00201 #elif defined (ACE_WIN32)
00202 ACE_HANDLE new_fd;
00203 if (::DuplicateHandle(::GetCurrentProcess (),
00204 handle,
00205 ::GetCurrentProcess(),
00206 &new_fd,
00207 0,
00208 TRUE,
00209 DUPLICATE_SAME_ACCESS))
00210 return new_fd;
00211 else
00212 ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
00213
00214 #else
00215 ACE_OSCALL_RETURN (::dup (handle), ACE_HANDLE, ACE_INVALID_HANDLE);
00216 #endif
00217 }
00218
00219 ACE_INLINE ACE_HANDLE
00220 ACE_OS::dup(ACE_HANDLE handle, pid_t pid)
00221 {
00222 ACE_OS_TRACE("ACE_OS::dup");
00223 #if defined (ACE_LACKS_DUP)
00224 ACE_UNUSED_ARG (handle);
00225 ACE_UNUSED_ARG (pid);
00226 ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
00227 #elif defined (ACE_WIN32)
00228 ACE_HANDLE new_fd;
00229 ACE_HANDLE hTargetProcess = ::OpenProcess (PROCESS_DUP_HANDLE,
00230 FALSE,
00231 pid);
00232 if(::DuplicateHandle(::GetCurrentProcess (),
00233 handle,
00234 hTargetProcess,
00235 &new_fd,
00236 0,
00237 TRUE,
00238 DUPLICATE_SAME_ACCESS))
00239 {
00240 ::CloseHandle (hTargetProcess);
00241 return new_fd;
00242 }
00243 else
00244 ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
00245
00246 #else
00247 ACE_UNUSED_ARG (pid);
00248 ACE_OSCALL_RETURN(::dup(handle), ACE_HANDLE, ACE_INVALID_HANDLE);
00249 #endif
00250 }
00251
00252 ACE_INLINE int
00253 ACE_OS::dup2 (ACE_HANDLE oldhandle, ACE_HANDLE newhandle)
00254 {
00255 ACE_OS_TRACE ("ACE_OS::dup2");
00256 #if defined (ACE_LACKS_DUP2)
00257
00258 ACE_UNUSED_ARG (oldhandle);
00259 ACE_UNUSED_ARG (newhandle);
00260 ACE_NOTSUP_RETURN (-1);
00261 #else
00262 ACE_OSCALL_RETURN (::dup2 (oldhandle, newhandle), int, -1);
00263 #endif
00264 }
00265
00266 ACE_INLINE int
00267 ACE_OS::execv (const char *path,
00268 char *const argv[])
00269 {
00270 ACE_OS_TRACE ("ACE_OS::execv");
00271 #if defined (ACE_LACKS_EXEC)
00272 ACE_UNUSED_ARG (path);
00273 ACE_UNUSED_ARG (argv);
00274
00275 ACE_NOTSUP_RETURN (-1);
00276 #elif defined (ACE_WIN32)
00277 # if defined (__BORLANDC__)
00278 return ::execv (path, argv);
00279 # elif defined (__MINGW32__)
00280 return ::_execv (path, (char *const *) argv);
00281 # else
00282
00283
00284
00285
00286 ::_execv (path, (const char *const *) argv);
00287 return -1;
00288 # endif
00289 #else
00290 ACE_OSCALL_RETURN (::execv (path, argv), int, -1);
00291 #endif
00292 }
00293
00294 ACE_INLINE int
00295 ACE_OS::execve (const char *path,
00296 char *const argv[],
00297 char *const envp[])
00298 {
00299 ACE_OS_TRACE ("ACE_OS::execve");
00300 #if defined (ACE_LACKS_EXEC)
00301 ACE_UNUSED_ARG (path);
00302 ACE_UNUSED_ARG (argv);
00303 ACE_UNUSED_ARG (envp);
00304
00305 ACE_NOTSUP_RETURN (-1);
00306 #elif defined (ACE_WIN32)
00307 # if defined (__BORLANDC__)
00308 return ::execve (path, argv, envp);
00309 # elif defined (__MINGW32__)
00310 return ::_execve (path, (char *const *) argv, (char *const *) envp);
00311 # else
00312
00313
00314
00315
00316 ::_execve (path, (const char *const *) argv, (const char *const *) envp);
00317 return -1;
00318 # endif
00319 #else
00320 ACE_OSCALL_RETURN (::execve (path, argv, envp), int, -1);
00321 #endif
00322 }
00323
00324 ACE_INLINE int
00325 ACE_OS::execvp (const char *file,
00326 char *const argv[])
00327 {
00328 ACE_OS_TRACE ("ACE_OS::execvp");
00329 #if defined (ACE_LACKS_EXEC)
00330 ACE_UNUSED_ARG (file);
00331 ACE_UNUSED_ARG (argv);
00332
00333 ACE_NOTSUP_RETURN (-1);
00334 #elif defined (ACE_WIN32)
00335 # if defined (__BORLANDC__)
00336 return ::execvp (file, argv);
00337 # elif defined (__MINGW32__)
00338 return ::_execvp (file, (char *const *) argv);
00339 # else
00340
00341
00342
00343
00344 ::_execvp (file, (const char *const *) argv);
00345 return -1;
00346 # endif
00347 #else
00348 ACE_OSCALL_RETURN (::execvp (file, argv), int, -1);
00349 #endif
00350 }
00351
00352 ACE_INLINE pid_t
00353 ACE_OS::fork (void)
00354 {
00355 ACE_OS_TRACE ("ACE_OS::fork");
00356 #if defined (ACE_LACKS_FORK)
00357 ACE_NOTSUP_RETURN (pid_t (-1));
00358 #else
00359 ACE_OSCALL_RETURN (::fork (), pid_t, -1);
00360 #endif
00361 }
00362
00363 ACE_INLINE int
00364 ACE_OS::fsync (ACE_HANDLE handle)
00365 {
00366 ACE_OS_TRACE ("ACE_OS::fsync");
00367 # if defined (ACE_LACKS_FSYNC)
00368 ACE_UNUSED_ARG (handle);
00369 ACE_NOTSUP_RETURN (-1);
00370 # elif defined (ACE_WIN32)
00371 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FlushFileBuffers (handle), ace_result_), int, -1);
00372 # else
00373 ACE_OSCALL_RETURN (::fsync (handle), int, -1);
00374 # endif
00375 }
00376
00377 ACE_INLINE int
00378 ACE_OS::ftruncate (ACE_HANDLE handle, ACE_OFF_T offset)
00379 {
00380 ACE_OS_TRACE ("ACE_OS::ftruncate");
00381 #if defined (ACE_WIN32)
00382 # if !defined (ACE_LACKS_WIN32_SETFILEPOINTEREX)
00383 LARGE_INTEGER loff;
00384 loff.QuadPart = offset;
00385 if (::SetFilePointerEx (handle, loff, 0, FILE_BEGIN))
00386 # else
00387 if (::SetFilePointer (handle,
00388 offset,
00389 0,
00390 FILE_BEGIN) != INVALID_SET_FILE_POINTER)
00391 # endif
00392 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetEndOfFile (handle), ace_result_), int, -1);
00393 else
00394 ACE_FAIL_RETURN (-1);
00395 #else
00396 ACE_OSCALL_RETURN (::ftruncate (handle, offset), int, -1);
00397 #endif
00398 }
00399
00400 ACE_INLINE char *
00401 ACE_OS::getcwd (char *buf, size_t size)
00402 {
00403 ACE_OS_TRACE ("ACE_OS::getcwd");
00404 #if defined (ACE_LACKS_GETCWD)
00405 ACE_UNUSED_ARG (buf);
00406 ACE_UNUSED_ARG (size);
00407 ACE_NOTSUP_RETURN (0);
00408 #elif defined (ACE_WIN32)
00409 return ::getcwd (buf, static_cast<int> (size));
00410 #else
00411 ACE_OSCALL_RETURN (::getcwd (buf, size), char *, 0);
00412 #endif
00413 }
00414
00415 #if defined (ACE_HAS_WCHAR)
00416 ACE_INLINE wchar_t *
00417 ACE_OS::getcwd (wchar_t *buf, size_t size)
00418 {
00419 # if defined (ACE_HAS_WINCE)
00420 ACE_UNUSED_ARG (buf);
00421 ACE_UNUSED_ARG (size);
00422 ACE_NOTSUP_RETURN (0);
00423 # elif defined (ACE_WIN32)
00424 return ::_wgetcwd (buf, static_cast<int> (size));
00425 # else
00426 char *narrow_buf = new char[size];
00427 char *result = 0;
00428 result = ACE_OS::getcwd (narrow_buf, size);
00429 ACE_Ascii_To_Wide wide_buf (result);
00430 delete [] narrow_buf;
00431 if (result != 0)
00432 ACE_OS::strsncpy (buf, wide_buf.wchar_rep (), size);
00433 return result == 0 ? 0 : buf;
00434 # endif
00435 }
00436 #endif
00437
00438 ACE_INLINE gid_t
00439 ACE_OS::getgid (void)
00440 {
00441 ACE_OS_TRACE ("ACE_OS::getgid");
00442 #if defined (ACE_LACKS_GETGID)
00443 ACE_NOTSUP_RETURN (static_cast<gid_t> (-1));
00444 # else
00445 ACE_OSCALL_RETURN (::getgid (), gid_t, static_cast<gid_t> (-1));
00446 # endif
00447 }
00448
00449 ACE_INLINE gid_t
00450 ACE_OS::getegid (void)
00451 {
00452 ACE_OS_TRACE ("ACE_OS::getegid");
00453 #if defined (ACE_LACKS_GETEGID)
00454 ACE_NOTSUP_RETURN (static_cast<gid_t> (-1));
00455 # else
00456 ACE_OSCALL_RETURN (::getegid (), gid_t, static_cast<gid_t> (-1));
00457 # endif
00458 }
00459
00460 ACE_INLINE int
00461 ACE_OS::getopt (int argc, char *const *argv, const char *optstring)
00462 {
00463 ACE_OS_TRACE ("ACE_OS::getopt");
00464 #if defined (ACE_LACKS_GETOPT)
00465 ACE_UNUSED_ARG (argc);
00466 ACE_UNUSED_ARG (argv);
00467 ACE_UNUSED_ARG (optstring);
00468 ACE_NOTSUP_RETURN (-1);
00469 # else
00470 ACE_OSCALL_RETURN (::getopt (argc, argv, optstring), int, -1);
00471 # endif
00472 }
00473
00474 ACE_INLINE pid_t
00475 ACE_OS::getpgid (pid_t pid)
00476 {
00477 ACE_OS_TRACE ("ACE_OS::getpgid");
00478 #if defined (ACE_LACKS_GETPGID)
00479 ACE_UNUSED_ARG (pid);
00480 ACE_NOTSUP_RETURN (-1);
00481 #elif defined (linux) && __GLIBC__ > 1 && __GLIBC_MINOR__ >= 0
00482
00483
00484
00485
00486 ACE_OSCALL_RETURN (::__getpgid (pid), pid_t, -1);
00487 #else
00488 ACE_OSCALL_RETURN (::getpgid (pid), pid_t, -1);
00489 #endif
00490 }
00491
00492 ACE_INLINE pid_t
00493 ACE_OS::getpid (void)
00494 {
00495
00496 #if defined (ACE_LACKS_GETPID)
00497 ACE_NOTSUP_RETURN (-1);
00498 #elif defined (ACE_WIN32)
00499 return ::GetCurrentProcessId ();
00500 #else
00501 ACE_OSCALL_RETURN (::getpid (), int, -1);
00502 #endif
00503 }
00504
00505 ACE_INLINE pid_t
00506 ACE_OS::getppid (void)
00507 {
00508 ACE_OS_TRACE ("ACE_OS::getppid");
00509 #if defined (ACE_LACKS_GETPPID)
00510 ACE_NOTSUP_RETURN (-1);
00511 #else
00512 ACE_OSCALL_RETURN (::getppid (), pid_t, -1);
00513 #endif
00514 }
00515
00516 ACE_INLINE uid_t
00517 ACE_OS::getuid (void)
00518 {
00519 ACE_OS_TRACE ("ACE_OS::getuid");
00520 #if defined (ACE_LACKS_GETUID)
00521 ACE_NOTSUP_RETURN (static_cast<uid_t> (-1));
00522 # else
00523 ACE_OSCALL_RETURN (::getuid (), uid_t, static_cast<uid_t> (-1));
00524 # endif
00525 }
00526
00527 ACE_INLINE uid_t
00528 ACE_OS::geteuid (void)
00529 {
00530 ACE_OS_TRACE ("ACE_OS::geteuid");
00531 #if defined (ACE_LACKS_GETEUID)
00532 ACE_NOTSUP_RETURN (static_cast<uid_t> (-1));
00533 # else
00534 ACE_OSCALL_RETURN (::geteuid (), uid_t, (uid_t) -1);
00535 # endif
00536 }
00537
00538 ACE_INLINE int
00539 ACE_OS::hostname (char name[], size_t maxnamelen)
00540 {
00541 ACE_OS_TRACE ("ACE_OS::hostname");
00542 #if defined (ACE_HAS_PHARLAP)
00543
00544 # if defined (ACE_HAS_PHARLAP_RT)
00545
00546
00547
00548 ACE_SOCKCALL_RETURN (gethostname (name, maxnamelen), int, SOCKET_ERROR);
00549 # else
00550 ACE_UNUSED_ARG (name);
00551 ACE_UNUSED_ARG (maxnamelen);
00552 ACE_NOTSUP_RETURN (-1);
00553 # endif
00554 #elif defined (ACE_VXWORKS) || defined (ACE_HAS_WINCE)
00555 ACE_OSCALL_RETURN (::gethostname (name, maxnamelen), int, -1);
00556 #elif defined (ACE_WIN32)
00557 if (::gethostname (name, ACE_Utils::truncate_cast<int> (maxnamelen)) == 0)
00558 {
00559 return 0;
00560 }
00561 else
00562 {
00563 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::GetComputerNameA (name,
00564 LPDWORD (&maxnamelen)),
00565 ace_result_), int, -1);
00566 }
00567 #else
00568 ACE_utsname host_info;
00569
00570 if (ACE_OS::uname (&host_info) == -1)
00571 return -1;
00572 else
00573 {
00574 ACE_OS::strsncpy (name, host_info.nodename, maxnamelen);
00575 return 0;
00576 }
00577 #endif
00578 }
00579
00580 #if defined (ACE_HAS_WCHAR)
00581 ACE_INLINE int
00582 ACE_OS::hostname (wchar_t name[], size_t maxnamelen)
00583 {
00584 #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
00585 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (GetComputerNameW (name,
00586 LPDWORD (&maxnamelen)),
00587 ace_result_), int, -1);
00588 #else
00589
00590 char *char_name = 0;
00591
00592 ACE_NEW_RETURN (char_name, char[maxnamelen], -1);
00593
00594 int result = ACE_OS::hostname(char_name, maxnamelen);
00595 ACE_OS::strcpy (name, ACE_Ascii_To_Wide (char_name).wchar_rep ());
00596
00597 delete [] char_name;
00598 return result;
00599 #endif
00600 }
00601 #endif
00602
00603 ACE_INLINE int
00604 ACE_OS::isatty (int handle)
00605 {
00606 ACE_OS_TRACE ("ACE_OS::isatty");
00607 #if defined (ACE_LACKS_ISATTY)
00608 ACE_UNUSED_ARG (handle);
00609 return 0;
00610 # elif defined (ACE_WIN32)
00611 return ::_isatty (handle);
00612 # else
00613 ACE_OSCALL_RETURN (::isatty (handle), int, -1);
00614 # endif
00615 }
00616
00617 #if defined (ACE_WIN32)
00618 ACE_INLINE int
00619 ACE_OS::isatty (ACE_HANDLE handle)
00620 {
00621 #if defined (ACE_LACKS_ISATTY)
00622 ACE_UNUSED_ARG (handle);
00623 return 0;
00624 #else
00625 int const fd = ::_open_osfhandle (intptr_t (handle), 0);
00626 int status = 0;
00627 if (fd != -1)
00628 {
00629 status = ::_isatty (fd);
00630 ::_close (fd);
00631 }
00632 return status;
00633 #endif
00634 }
00635
00636 #endif
00637
00638 ACE_INLINE ACE_OFF_T
00639 ACE_OS::lseek (ACE_HANDLE handle, ACE_OFF_T offset, int whence)
00640 {
00641 ACE_OS_TRACE ("ACE_OS::lseek");
00642 #if defined (ACE_WIN32)
00643 # if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END
00644
00645 switch (whence)
00646 {
00647 case SEEK_SET:
00648 whence = FILE_BEGIN;
00649 break;
00650 case SEEK_CUR:
00651 whence = FILE_CURRENT;
00652 break;
00653 case SEEK_END:
00654 whence = FILE_END;
00655 break;
00656 default:
00657 errno = EINVAL;
00658 return static_cast<ACE_OFF_T> (-1);
00659 }
00660 # endif
00661 LONG low_offset = ACE_LOW_PART(offset);
00662 LONG high_offset = ACE_HIGH_PART(offset);
00663 DWORD const result =
00664 ::SetFilePointer (handle, low_offset, &high_offset, whence);
00665 if (result == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
00666 ACE_FAIL_RETURN (static_cast<ACE_OFF_T> (-1));
00667 else
00668 return result;
00669 #else
00670 ACE_OSCALL_RETURN (::lseek (handle, offset, whence), ACE_OFF_T, -1);
00671 #endif
00672 }
00673
00674 #if defined (ACE_HAS_LLSEEK) || defined (ACE_HAS_LSEEK64)
00675 ACE_INLINE ACE_LOFF_T
00676 ACE_OS::llseek (ACE_HANDLE handle, ACE_LOFF_T offset, int whence)
00677 {
00678 ACE_OS_TRACE ("ACE_OS::llseek");
00679
00680 #if ACE_SIZEOF_LONG == 8
00681
00682 return ACE_OS::lseek (handle, offset, whence);
00683 #elif defined (ACE_HAS_LLSEEK) && defined (ACE_HAS_LSEEK64)
00684 # error Either ACE_HAS_LSEEK64 and ACE_HAS_LLSEEK should be defined, not both!
00685 #elif defined (ACE_HAS_LSEEK64)
00686 ACE_OSCALL_RETURN (::lseek64 (handle, offset, whence), ACE_LOFF_T, -1);
00687 #elif defined (ACE_HAS_LLSEEK)
00688 # if defined (ACE_WIN32)
00689 # ifndef ACE_LACKS_WIN32_SETFILEPOINTEREX
00690 LARGE_INTEGER distance, new_file_pointer;
00691
00692 distance.QuadPart = offset;
00693
00694 return
00695 (::SetFilePointerEx (handle, distance, &new_file_pointer, whence)
00696 ? new_file_pointer.QuadPart
00697 : static_cast<ACE_LOFF_T> (-1));
00698 # else
00699 LARGE_INTEGER l_offset;
00700 l_offset.QuadPart = offset;
00701 LONG low_offset = l_offset.LowPart;
00702 LONG high_offset = l_offset.HighPart;
00703
00704 l_offset.LowPart = ::SetFilePointer (handle,
00705 low_offset,
00706 &high_offset,
00707 whence);
00708 if (l_offset.LowPart == INVALID_SET_FILE_POINTER &&
00709 GetLastError () != NO_ERROR)
00710 return static_cast<ACE_LOFF_T> (-1);
00711 l_offset.HighPart = high_offset;
00712 return l_offset.QuadPart;
00713 # endif
00714 # else
00715 ACE_OSCALL_RETURN (::llseek (handle, offset, whence), ACE_LOFF_T, -1);
00716 # endif
00717 #endif
00718 }
00719 #endif
00720
00721 ACE_INLINE ssize_t
00722 ACE_OS::read (ACE_HANDLE handle, void *buf, size_t len)
00723 {
00724 ACE_OS_TRACE ("ACE_OS::read");
00725 #if defined (ACE_WIN32)
00726 DWORD ok_len;
00727 if (::ReadFile (handle, buf, static_cast<DWORD> (len), &ok_len, 0))
00728 return (ssize_t) ok_len;
00729 else
00730 ACE_FAIL_RETURN (-1);
00731 #else
00732
00733 ssize_t result;
00734
00735 # if defined (ACE_HAS_CHARPTR_SOCKOPT)
00736 ACE_OSCALL (::read (handle, static_cast <char *> (buf), len), ssize_t, -1, result);
00737 # else
00738 ACE_OSCALL (::read (handle, buf, len), ssize_t, -1, result);
00739 # endif
00740
00741 # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK)
00742
00743
00744
00745
00746
00747 if (result == -1
00748 # if !defined (EAGAIN) || !defined (EWOULDBLOCK)
00749 && EAGAIN != EWOULDBLOCK
00750 # endif
00751 && errno == EAGAIN)
00752 {
00753 errno = EWOULDBLOCK;
00754 }
00755 # endif
00756
00757 return result;
00758 #endif
00759 }
00760
00761 ACE_INLINE ssize_t
00762 ACE_OS::read (ACE_HANDLE handle, void *buf, size_t len,
00763 ACE_OVERLAPPED *overlapped)
00764 {
00765 ACE_OS_TRACE ("ACE_OS::read");
00766 overlapped = overlapped;
00767 #if defined (ACE_WIN32)
00768 DWORD ok_len;
00769 DWORD short_len = static_cast<DWORD> (len);
00770 if (::ReadFile (handle, buf, short_len, &ok_len, overlapped))
00771 return (ssize_t) ok_len;
00772 else
00773 ACE_FAIL_RETURN (-1);
00774 #else
00775 return ACE_OS::read (handle, buf, len);
00776 #endif
00777 }
00778
00779 ACE_INLINE ssize_t
00780 ACE_OS::readlink (const char *path, char *buf, size_t bufsiz)
00781 {
00782 ACE_OS_TRACE ("ACE_OS::readlink");
00783 # if defined (ACE_LACKS_READLINK)
00784 ACE_UNUSED_ARG (path);
00785 ACE_UNUSED_ARG (buf);
00786 ACE_UNUSED_ARG (bufsiz);
00787 ACE_NOTSUP_RETURN (-1);
00788 # elif defined(ACE_HAS_NONCONST_READLINK)
00789 ACE_OSCALL_RETURN (
00790 ::readlink (const_cast <char *>(path), buf, bufsiz), ssize_t, -1);
00791 # else
00792 ACE_OSCALL_RETURN (::readlink (path, buf, bufsiz), ssize_t, -1);
00793 # endif
00794 }
00795
00796 ACE_INLINE int
00797 ACE_OS::pipe (ACE_HANDLE fds[])
00798 {
00799 ACE_OS_TRACE ("ACE_OS::pipe");
00800 # if defined (ACE_LACKS_PIPE)
00801 ACE_UNUSED_ARG (fds);
00802 ACE_NOTSUP_RETURN (-1);
00803 # elif defined (ACE_WIN32)
00804 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL
00805 (::CreatePipe (&fds[0], &fds[1], 0, 0),
00806 ace_result_), int, -1);
00807 # else
00808 ACE_OSCALL_RETURN (::pipe (fds), int, -1);
00809 # endif
00810 }
00811
00812 ACE_INLINE void *
00813 ACE_OS::sbrk (intptr_t brk)
00814 {
00815 #if defined (ACE_LACKS_SBRK)
00816 ACE_UNUSED_ARG (brk);
00817 ACE_NOTSUP_RETURN (0);
00818 #else
00819 ACE_OSCALL_RETURN (::sbrk (brk), void *, 0);
00820 #endif
00821 }
00822
00823 ACE_INLINE int
00824 ACE_OS::setgid (gid_t gid)
00825 {
00826 ACE_OS_TRACE ("ACE_OS::setgid");
00827 #if defined (ACE_LACKS_SETGID)
00828 ACE_UNUSED_ARG (gid);
00829 ACE_NOTSUP_RETURN (-1);
00830 # else
00831 ACE_OSCALL_RETURN (::setgid (gid), int, -1);
00832 # endif
00833 }
00834
00835 ACE_INLINE int
00836 ACE_OS::setegid (gid_t gid)
00837 {
00838 ACE_OS_TRACE ("ACE_OS::setegid");
00839 #if defined (ACE_LACKS_SETEGID)
00840 ACE_UNUSED_ARG (gid);
00841 ACE_NOTSUP_RETURN (-1);
00842 # else
00843 ACE_OSCALL_RETURN (::setegid (gid), int, -1);
00844 # endif
00845 }
00846
00847 ACE_INLINE int
00848 ACE_OS::setpgid (pid_t pid, pid_t pgid)
00849 {
00850 ACE_OS_TRACE ("ACE_OS::setpgid");
00851 #if defined (ACE_LACKS_SETPGID)
00852 ACE_UNUSED_ARG (pid);
00853 ACE_UNUSED_ARG (pgid);
00854 ACE_NOTSUP_RETURN (-1);
00855 #else
00856 ACE_OSCALL_RETURN (::setpgid (pid, pgid), int, -1);
00857 #endif
00858 }
00859
00860 ACE_INLINE int
00861 ACE_OS::setregid (gid_t rgid, gid_t egid)
00862 {
00863 ACE_OS_TRACE ("ACE_OS::setregid");
00864 #if defined (ACE_LACKS_SETREGID)
00865 ACE_UNUSED_ARG (rgid);
00866 ACE_UNUSED_ARG (egid);
00867 ACE_NOTSUP_RETURN (-1);
00868 #else
00869 ACE_OSCALL_RETURN (::setregid (rgid, egid), int, -1);
00870 #endif
00871 }
00872
00873 ACE_INLINE int
00874 ACE_OS::setreuid (uid_t ruid, uid_t euid)
00875 {
00876 ACE_OS_TRACE ("ACE_OS::setreuid");
00877 #if defined (ACE_LACKS_SETREUID)
00878 ACE_UNUSED_ARG (ruid);
00879 ACE_UNUSED_ARG (euid);
00880 ACE_NOTSUP_RETURN (-1);
00881 #else
00882 ACE_OSCALL_RETURN (::setreuid (ruid, euid), int, -1);
00883 #endif
00884 }
00885
00886 ACE_INLINE pid_t
00887 ACE_OS::setsid (void)
00888 {
00889 ACE_OS_TRACE ("ACE_OS::setsid");
00890 #if defined (ACE_LACKS_SETSID)
00891 ACE_NOTSUP_RETURN (-1);
00892 #else
00893 ACE_OSCALL_RETURN (::setsid (), int, -1);
00894 # endif
00895 }
00896
00897 ACE_INLINE int
00898 ACE_OS::setuid (uid_t uid)
00899 {
00900 ACE_OS_TRACE ("ACE_OS::setuid");
00901 #if defined (ACE_LACKS_SETUID)
00902 ACE_UNUSED_ARG (uid);
00903 ACE_NOTSUP_RETURN (-1);
00904 # else
00905 ACE_OSCALL_RETURN (::setuid (uid), int, -1);
00906 # endif
00907 }
00908
00909 ACE_INLINE int
00910 ACE_OS::seteuid (uid_t uid)
00911 {
00912 ACE_OS_TRACE ("ACE_OS::seteuid");
00913 #if defined (ACE_LACKS_SETEUID)
00914 ACE_UNUSED_ARG (uid);
00915 ACE_NOTSUP_RETURN (-1);
00916 # else
00917 ACE_OSCALL_RETURN (::seteuid (uid), int, -1);
00918 # endif
00919 }
00920
00921 ACE_INLINE int
00922 ACE_OS::sleep (u_int seconds)
00923 {
00924 ACE_OS_TRACE ("ACE_OS::sleep");
00925 #if defined (ACE_WIN32)
00926 ::Sleep (seconds * ACE_ONE_SECOND_IN_MSECS);
00927 return 0;
00928 #elif defined (ACE_HAS_CLOCK_GETTIME)
00929 struct timespec rqtp;
00930
00931 rqtp.tv_sec = seconds;
00932 rqtp.tv_nsec = 0L;
00933
00934 ACE_OSCALL_RETURN (::nanosleep (&rqtp, 0), int, -1);
00935
00936 #else
00937 ACE_OSCALL_RETURN (::sleep (seconds), int, -1);
00938 #endif
00939 }
00940
00941 ACE_INLINE int
00942 ACE_OS::sleep (const ACE_Time_Value &tv)
00943 {
00944 ACE_OS_TRACE ("ACE_OS::sleep");
00945 #if defined (ACE_WIN32)
00946 ::Sleep (tv.msec ());
00947 return 0;
00948 #elif defined (ACE_HAS_CLOCK_GETTIME)
00949 timespec_t rqtp = tv;
00950
00951 ACE_OSCALL_RETURN (::nanosleep (&rqtp, 0), int, -1);
00952
00953 #else
00954 # if defined (ACE_HAS_NONCONST_SELECT_TIMEVAL)
00955
00956
00957 timeval tv_copy = tv;
00958 # if defined(ACE_TANDEM_T1248_PTHREADS)
00959 ACE_OSCALL_RETURN (::spt_select (0, 0, 0, 0, &tv_copy), int, -1);
00960 # else
00961
00962 ACE_OSCALL_RETURN (::select (0, 0, 0, 0, &tv_copy), int, -1);
00963
00964 # endif
00965 # else
00966 const timeval *tvp = tv;
00967
00968 ACE_OSCALL_RETURN (::select (0, 0, 0, 0, tvp), int, -1);
00969
00970 # endif
00971 #endif
00972 }
00973
00974 ACE_INLINE void
00975 ACE_OS::swab (const void *src,
00976 void *dest,
00977 ssize_t length)
00978 {
00979 #if defined (ACE_LACKS_SWAB)
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000 const char *from = static_cast<const char*> (src);
01001 char *to = static_cast<char *> (dest);
01002 ssize_t ptr = 0;
01003 for (ptr = 1; ptr < length; ptr += 2)
01004 {
01005 char p = from[ptr];
01006 char q = from[ptr-1];
01007 to[ptr-1] = p;
01008 to[ptr ] = q;
01009 }
01010 if (ptr == length)
01011 to[ptr-1] = 0;
01012 #elif defined (ACE_HAS_NONCONST_SWAB)
01013 const char *tmp = static_cast<const char*> (src);
01014 char *from = const_cast<char *> (tmp);
01015 char *to = static_cast<char *> (dest);
01016 ::swab (from, to, length);
01017 #elif defined (ACE_HAS_CONST_CHAR_SWAB)
01018 const char *from = static_cast<const char*> (src);
01019 char *to = static_cast<char *> (dest);
01020 ::swab (from, to, length);
01021 #else
01022 ::swab (src, dest, length);
01023 #endif
01024
01025 }
01026
01027 ACE_INLINE long
01028 ACE_OS::sysconf (int name)
01029 {
01030 ACE_OS_TRACE ("ACE_OS::sysconf");
01031 #if defined (ACE_LACKS_SYSCONF)
01032 ACE_UNUSED_ARG (name);
01033 ACE_NOTSUP_RETURN (-1);
01034 #else
01035 ACE_OSCALL_RETURN (::sysconf (name), long, -1);
01036 #endif
01037 }
01038
01039 ACE_INLINE long
01040 ACE_OS::sysinfo (int cmd, char *buf, long count)
01041 {
01042 ACE_OS_TRACE ("ACE_OS::sysinfo");
01043 #if defined (ACE_HAS_SYSV_SYSINFO)
01044 ACE_OSCALL_RETURN (::sysinfo (cmd, buf, count), long, -1);
01045 #else
01046 ACE_UNUSED_ARG (cmd);
01047 ACE_UNUSED_ARG (buf);
01048 ACE_UNUSED_ARG (count);
01049
01050 ACE_NOTSUP_RETURN (0);
01051 #endif
01052 }
01053
01054 ACE_INLINE int
01055 ACE_OS::truncate (const ACE_TCHAR *filename,
01056 ACE_OFF_T offset)
01057 {
01058 ACE_OS_TRACE ("ACE_OS::truncate");
01059 #if defined (ACE_WIN32)
01060 ACE_HANDLE handle = ACE_OS::open (filename,
01061 O_WRONLY,
01062 ACE_DEFAULT_FILE_PERMS);
01063
01064 # if !defined (ACE_LACKS_WIN32_SETFILEPOINTEREX)
01065 LARGE_INTEGER loffset;
01066 loffset.QuadPart = offset;
01067 #else
01068 LONG low_offset = ACE_LOW_PART(offset);
01069 LONG high_offset = ACE_HIGH_PART(offset);
01070 #endif
01071
01072 if (handle == ACE_INVALID_HANDLE)
01073 ACE_FAIL_RETURN (-1);
01074
01075 # if !defined (ACE_LACKS_WIN32_SETFILEPOINTEREX)
01076 else if (::SetFilePointerEx (handle,
01077 loffset,
01078 0,
01079 FILE_BEGIN))
01080 # else
01081 else if (::SetFilePointer (handle,
01082 low_offset,
01083 &high_offset,
01084 FILE_BEGIN) != INVALID_SET_FILE_POINTER
01085 || GetLastError () == NO_ERROR)
01086 # endif
01087 {
01088 BOOL result = ::SetEndOfFile (handle);
01089 ::CloseHandle (handle);
01090 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (result, ace_result_), int, -1);
01091 }
01092 else
01093 {
01094 ::CloseHandle (handle);
01095 ACE_FAIL_RETURN (-1);
01096 }
01097
01098 #elif !defined (ACE_LACKS_TRUNCATE)
01099 ACE_OSCALL_RETURN
01100 (::truncate (ACE_TEXT_ALWAYS_CHAR (filename), offset), int, -1);
01101 #else
01102 ACE_UNUSED_ARG (filename);
01103 ACE_UNUSED_ARG (offset);
01104 ACE_NOTSUP_RETURN (-1);
01105 #endif
01106 }
01107
01108 ACE_INLINE useconds_t
01109 ACE_OS::ualarm (useconds_t usecs, useconds_t interval)
01110 {
01111 ACE_OS_TRACE ("ACE_OS::ualarm");
01112
01113 #if defined (ACE_HAS_UALARM)
01114 return ::ualarm (usecs, interval);
01115 #elif !defined (ACE_LACKS_UNIX_SIGNALS)
01116 ACE_UNUSED_ARG (interval);
01117 return ::alarm (usecs * ACE_ONE_SECOND_IN_USECS);
01118 #else
01119 ACE_UNUSED_ARG (usecs);
01120 ACE_UNUSED_ARG (interval);
01121 ACE_NOTSUP_RETURN (0);
01122 #endif
01123 }
01124
01125 ACE_INLINE useconds_t
01126 ACE_OS::ualarm (const ACE_Time_Value &tv,
01127 const ACE_Time_Value &tv_interval)
01128 {
01129 ACE_OS_TRACE ("ACE_OS::ualarm");
01130
01131 #if defined (ACE_HAS_UALARM)
01132 useconds_t usecs = (tv.sec () * ACE_ONE_SECOND_IN_USECS) + tv.usec ();
01133 useconds_t interval =
01134 (tv_interval.sec () * ACE_ONE_SECOND_IN_USECS) + tv_interval.usec ();
01135 return ::ualarm (usecs, interval);
01136 #elif !defined (ACE_LACKS_UNIX_SIGNALS)
01137 ACE_UNUSED_ARG (tv_interval);
01138 return ::alarm (tv.sec ());
01139 #else
01140 ACE_UNUSED_ARG (tv_interval);
01141 ACE_UNUSED_ARG (tv);
01142 ACE_NOTSUP_RETURN (0);
01143 #endif
01144 }
01145
01146 ACE_INLINE int
01147 ACE_OS::unlink (const char *path)
01148 {
01149 ACE_OS_TRACE ("ACE_OS::unlink");
01150 # if defined (ACE_HAS_NONCONST_UNLINK)
01151 ACE_OSCALL_RETURN (::unlink (const_cast<char *> (path)), int, -1);
01152 # elif defined (ACE_HAS_WINCE)
01153
01154 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::DeleteFile (ACE_TEXT_CHAR_TO_TCHAR (path)), ace_result_),
01155 int, -1);
01156 # elif defined (ACE_LACKS_UNLINK)
01157 ACE_UNUSED_ARG (path);
01158 ACE_NOTSUP_RETURN (-1);
01159 # else
01160 ACE_OSCALL_RETURN (::unlink (path), int, -1);
01161 # endif
01162 }
01163
01164 #if defined (ACE_HAS_WCHAR)
01165 ACE_INLINE int
01166 ACE_OS::unlink (const wchar_t *path)
01167 {
01168 ACE_OS_TRACE ("ACE_OS::unlink");
01169 # if defined (ACE_HAS_WINCE)
01170
01171 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::DeleteFileW (path), ace_result_),
01172 int, -1);
01173 # elif defined (ACE_WIN32)
01174 ACE_OSCALL_RETURN (::_wunlink (path), int, -1);
01175 # else
01176 ACE_Wide_To_Ascii npath (path);
01177 return ACE_OS::unlink (npath.char_rep ());
01178 # endif
01179 }
01180 #endif
01181
01182 ACE_INLINE ssize_t
01183 ACE_OS::write (ACE_HANDLE handle, const void *buf, size_t nbyte)
01184 {
01185 ACE_OS_TRACE ("ACE_OS::write");
01186 #if defined (ACE_WIN32)
01187 DWORD bytes_written;
01188
01189
01190
01191 DWORD short_nbyte = static_cast<DWORD> (nbyte);
01192 if (::WriteFile (handle, buf, short_nbyte, &bytes_written, 0))
01193 return (ssize_t) bytes_written;
01194 else
01195 ACE_FAIL_RETURN (-1);
01196 #else
01197 # if defined (ACE_HAS_CHARPTR_SOCKOPT)
01198 ACE_OSCALL_RETURN (::write (handle, static_cast <char *> (const_cast <void *> (buf)), nbyte), ssize_t, -1);
01199 # else
01200 ACE_OSCALL_RETURN (::write (handle, buf, nbyte), ssize_t, -1);
01201 # endif
01202 #endif
01203 }
01204
01205 ACE_INLINE ssize_t
01206 ACE_OS::write (ACE_HANDLE handle,
01207 const void *buf,
01208 size_t nbyte,
01209 ACE_OVERLAPPED *overlapped)
01210 {
01211 ACE_OS_TRACE ("ACE_OS::write");
01212 overlapped = overlapped;
01213 #if defined (ACE_WIN32)
01214 DWORD bytes_written;
01215
01216 DWORD short_nbyte = static_cast<DWORD> (nbyte);
01217 if (::WriteFile (handle, buf, short_nbyte, &bytes_written, overlapped))
01218 return (ssize_t) bytes_written;
01219 else
01220 ACE_FAIL_RETURN (-1);
01221 #else
01222 return ACE_OS::write (handle, buf, nbyte);
01223 #endif
01224 }
01225
01226 ACE_END_VERSIONED_NAMESPACE_DECL