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