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