00001
00002
00003
00004
00005 #include "ace/OS_NS_unistd.h"
00006 #include "ace/OS_NS_stdlib.h"
00007 #include "ace/OS_NS_fcntl.h"
00008 #include "ace/OS_NS_errno.h"
00009 #include "ace/OS_NS_string.h"
00010 #include "ace/OS_NS_pwd.h"
00011 #include "ace/OS_NS_macros.h"
00012 #include "ace/OS_NS_sys_stat.h"
00013 #include "ace/OS_Memory.h"
00014
00015 #if defined (ACE_HAS_TRIO)
00016 # include <trio.h>
00017 #endif
00018
00019
00020
00021 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00022
00023 #if defined (ACE_WIN32)
00024 ACE_INLINE void
00025 ACE_OS::flock_adjust_params (ACE_OS::ace_flock_t *lock,
00026 short whence,
00027 ACE_OFF_T &start,
00028 ACE_OFF_T &len)
00029 {
00030 switch (whence)
00031 {
00032 case SEEK_SET:
00033 break;
00034 case SEEK_CUR:
00035 {
00036 LARGE_INTEGER offset;
00037 # if !defined (ACE_LACKS_WIN32_SETFILEPOINTEREX)
00038 LARGE_INTEGER distance;
00039 distance.QuadPart = 0;
00040 if (!::SetFilePointerEx (lock->handle_,
00041 distance,
00042 &offset,
00043 FILE_CURRENT))
00044 {
00045 ACE_OS::set_errno_to_last_error ();
00046 return;
00047 }
00048 # else
00049 offset.LowPart = ::SetFilePointer (lock->handle_,
00050 0,
00051 &offset.HighPart,
00052 FILE_CURRENT);
00053 if (offset.LowPart == INVALID_SET_FILE_POINTER &&
00054 ::GetLastError() != NO_ERROR)
00055 {
00056 ACE_OS::set_errno_to_last_error ();
00057 return;
00058 }
00059 # endif
00060
00061 # if defined (_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
00062 start += offset.QuadPart;
00063 # else
00064 start += offset.LowPart;
00065 # endif
00066 }
00067 break;
00068 case SEEK_END:
00069 {
00070 ACE_OFF_T const size = ACE_OS::filesize (lock->handle_);
00071 if (size == -1)
00072 return;
00073
00074 start += size;
00075 }
00076 break;
00077 }
00078 lock->overlapped_.Offset = ACE_LOW_PART (start);
00079 lock->overlapped_.OffsetHigh = ACE_HIGH_PART (start);
00080 if (len == 0)
00081 {
00082 ACE_OFF_T const tlen = ACE_OS::filesize (lock->handle_);
00083 if (tlen != -1)
00084 len = tlen - start;
00085 }
00086 }
00087 #endif
00088
00089 ACE_INLINE int
00090 ACE_OS::flock_init (ACE_OS::ace_flock_t *lock,
00091 int flags,
00092 const ACE_TCHAR *name,
00093 mode_t perms)
00094 {
00095 ACE_OS_TRACE ("ACE_OS::flock_init");
00096 #if defined (ACE_WIN32)
00097
00098 lock->overlapped_.Internal = 0;
00099 lock->overlapped_.InternalHigh = 0;
00100 lock->overlapped_.OffsetHigh = 0;
00101 lock->overlapped_.hEvent = 0;
00102 #endif
00103 lock->handle_ = ACE_INVALID_HANDLE;
00104 lock->lockname_ = 0;
00105
00106 if (name != 0)
00107 {
00108 ACE_OSCALL (ACE_OS::open (name, flags, perms),
00109 ACE_HANDLE,
00110 ACE_INVALID_HANDLE,
00111 lock->handle_);
00112 if (lock->handle_ != ACE_INVALID_HANDLE)
00113 lock->lockname_ = ACE_OS::strdup (name);
00114 return lock->handle_ == ACE_INVALID_HANDLE ? -1 : 0;
00115 }
00116 else
00117 return 0;
00118 }
00119
00120 ACE_INLINE int
00121 ACE_OS::flock_unlock (ACE_OS::ace_flock_t *lock,
00122 short whence,
00123 ACE_OFF_T start,
00124 ACE_OFF_T len)
00125 {
00126 ACE_OS_TRACE ("ACE_OS::flock_unlock");
00127 #if defined (ACE_LACKS_FILELOCKS)
00128 ACE_UNUSED_ARG (lock);
00129 ACE_UNUSED_ARG (whence);
00130 ACE_UNUSED_ARG (start);
00131 ACE_UNUSED_ARG (len);
00132 ACE_NOTSUP_RETURN (-1);
00133 #elif defined (ACE_WIN32)
00134 ACE_OS::flock_adjust_params (lock, whence, start, len);
00135 DWORD low_len = ACE_LOW_PART (len);
00136 DWORD high_len = ACE_HIGH_PART (len);
00137 ACE_WIN32CALL_RETURN (
00138 ACE_ADAPT_RETVAL (::UnlockFile (lock->handle_,
00139 lock->overlapped_.Offset,
00140 lock->overlapped_.OffsetHigh,
00141 low_len,
00142 high_len),
00143 ace_result_), int, -1);
00144 #else
00145 lock->lock_.l_whence = whence;
00146 lock->lock_.l_start = start;
00147 lock->lock_.l_len = len;
00148 lock->lock_.l_type = F_UNLCK;
00149
00150
00151 ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLK,
00152 reinterpret_cast<long> (&lock->lock_)),
00153 int, -1);
00154 #endif
00155 }
00156
00157 ACE_INLINE int
00158 ACE_OS::flock_destroy (ACE_OS::ace_flock_t *lock,
00159 int unlink_file)
00160 {
00161 ACE_OS_TRACE ("ACE_OS::flock_destroy");
00162 if (lock->handle_ != ACE_INVALID_HANDLE)
00163 {
00164 ACE_OS::flock_unlock (lock);
00165
00166 ACE_OS::close (lock->handle_);
00167 lock->handle_ = ACE_INVALID_HANDLE;
00168 if (lock->lockname_ != 0)
00169 {
00170 if (unlink_file)
00171 ACE_OS::unlink (lock->lockname_);
00172 ACE_OS::free (
00173 static_cast<void *> (const_cast<ACE_TCHAR *> (lock->lockname_)));
00174 }
00175 lock->lockname_ = 0;
00176 }
00177 return 0;
00178 }
00179
00180 ACE_INLINE int
00181 ACE_OS::flock_rdlock (ACE_OS::ace_flock_t *lock,
00182 short whence,
00183 ACE_OFF_T start,
00184 ACE_OFF_T len)
00185 {
00186 ACE_OS_TRACE ("ACE_OS::flock_rdlock");
00187 #if defined (ACE_LACKS_FILELOCKS)
00188 ACE_UNUSED_ARG (lock);
00189 ACE_UNUSED_ARG (whence);
00190 ACE_UNUSED_ARG (start);
00191 ACE_UNUSED_ARG (len);
00192 ACE_NOTSUP_RETURN (-1);
00193 #elif defined (ACE_WIN32)
00194 ACE_OS::flock_adjust_params (lock, whence, start, len);
00195 DWORD low_len = ACE_LOW_PART (len);
00196 DWORD high_len = ACE_HIGH_PART (len);
00197 # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)
00198 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00199 0,
00200 0,
00201 low_len,
00202 high_len,
00203 &lock->overlapped_),
00204 ace_result_), int, -1);
00205 # else
00206 ACE_WIN32CALL_RETURN (
00207 ACE_ADAPT_RETVAL (::LockFile (lock->handle_,
00208 lock->overlapped_.Offset,
00209 lock->overlapped_.OffsetHigh,
00210 low_len,
00211 high_len),
00212 ace_result_), int, -1);
00213 # endif
00214 #else
00215 lock->lock_.l_whence = whence;
00216 lock->lock_.l_start = start;
00217 lock->lock_.l_len = len;
00218 lock->lock_.l_type = F_RDLCK;
00219
00220 ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW,
00221 reinterpret_cast<long> (&lock->lock_)),
00222 int, -1);
00223 #endif
00224 }
00225
00226 ACE_INLINE int
00227 ACE_OS::flock_tryrdlock (ACE_OS::ace_flock_t *lock,
00228 short whence,
00229 ACE_OFF_T start,
00230 ACE_OFF_T len)
00231 {
00232 ACE_OS_TRACE ("ACE_OS::ace_flock_tryrdlock");
00233 #if defined (ACE_LACKS_FILELOCKS)
00234 ACE_UNUSED_ARG (lock);
00235 ACE_UNUSED_ARG (whence);
00236 ACE_UNUSED_ARG (start);
00237 ACE_UNUSED_ARG (len);
00238 ACE_NOTSUP_RETURN (-1);
00239 #elif defined (ACE_WIN32)
00240 # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)
00241 ACE_OS::flock_adjust_params (lock, whence, start, len);
00242 DWORD low_len = ACE_LOW_PART (len);
00243 DWORD high_len = ACE_HIGH_PART (len);
00244 ACE_WIN32CALL_RETURN (
00245 ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00246 LOCKFILE_FAIL_IMMEDIATELY,
00247 0,
00248 low_len,
00249 high_len,
00250 &lock->overlapped_),
00251 ace_result_), int, -1);
00252 # else
00253 ACE_UNUSED_ARG (lock);
00254 ACE_UNUSED_ARG (whence);
00255 ACE_UNUSED_ARG (start);
00256 ACE_UNUSED_ARG (len);
00257 ACE_NOTSUP_RETURN (-1);
00258 # endif
00259 #else
00260 lock->lock_.l_whence = whence;
00261 lock->lock_.l_start = start;
00262 lock->lock_.l_len = len;
00263 lock->lock_.l_type = F_RDLCK;
00264
00265 int result = 0;
00266
00267 ACE_OSCALL (ACE_OS::fcntl (lock->handle_, F_SETLK,
00268 reinterpret_cast<long> (&lock->lock_)),
00269 int, -1, result);
00270
00271 if (result == -1 && (errno == EACCES || errno == EAGAIN))
00272 errno = EBUSY;
00273
00274 return result;
00275 #endif
00276 }
00277
00278 ACE_INLINE int
00279 ACE_OS::flock_trywrlock (ACE_OS::ace_flock_t *lock,
00280 short whence,
00281 ACE_OFF_T start,
00282 ACE_OFF_T len)
00283 {
00284 ACE_OS_TRACE ("ACE_OS::ace_flock_trywrlock");
00285 #if defined (ACE_LACKS_FILELOCKS)
00286 ACE_UNUSED_ARG (lock);
00287 ACE_UNUSED_ARG (whence);
00288 ACE_UNUSED_ARG (start);
00289 ACE_UNUSED_ARG (len);
00290 ACE_NOTSUP_RETURN (-1);
00291 #elif defined (ACE_WIN32)
00292 # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)
00293 ACE_OS::flock_adjust_params (lock, whence, start, len);
00294 DWORD low_len = ACE_LOW_PART (len);
00295 DWORD high_len = ACE_HIGH_PART (len);
00296 ACE_WIN32CALL_RETURN (
00297 ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00298 LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK,
00299 0,
00300 low_len,
00301 high_len,
00302 &lock->overlapped_),
00303 ace_result_), int, -1);
00304 # else
00305 ACE_UNUSED_ARG (lock);
00306 ACE_UNUSED_ARG (whence);
00307 ACE_UNUSED_ARG (start);
00308 ACE_UNUSED_ARG (len);
00309 ACE_NOTSUP_RETURN (-1);
00310 # endif
00311 #else
00312 lock->lock_.l_whence = whence;
00313 lock->lock_.l_start = start;
00314 lock->lock_.l_len = len;
00315 lock->lock_.l_type = F_WRLCK;
00316
00317 int result = 0;
00318
00319 ACE_OSCALL (ACE_OS::fcntl (lock->handle_,
00320 F_SETLK,
00321 reinterpret_cast<long> (&lock->lock_)),
00322 int, -1, result);
00323
00324 if (result == -1 && (errno == EACCES || errno == EAGAIN))
00325 errno = EBUSY;
00326
00327 return result;
00328 #endif
00329 }
00330
00331 ACE_INLINE int
00332 ACE_OS::flock_wrlock (ACE_OS::ace_flock_t *lock,
00333 short whence,
00334 ACE_OFF_T start,
00335 ACE_OFF_T len)
00336 {
00337 ACE_OS_TRACE ("ACE_OS::flock_wrlock");
00338 #if defined (ACE_LACKS_FILELOCKS)
00339 ACE_UNUSED_ARG (lock);
00340 ACE_UNUSED_ARG (whence);
00341 ACE_UNUSED_ARG (start);
00342 ACE_UNUSED_ARG (len);
00343 ACE_NOTSUP_RETURN (-1);
00344 #elif defined (ACE_WIN32)
00345 ACE_OS::flock_adjust_params (lock, whence, start, len);
00346 DWORD low_len = ACE_LOW_PART (len);
00347 DWORD high_len = ACE_HIGH_PART (len);
00348 # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)
00349 ACE_WIN32CALL_RETURN (
00350 ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00351 LOCKFILE_EXCLUSIVE_LOCK,
00352 0,
00353 low_len,
00354 high_len,
00355 &lock->overlapped_),
00356 ace_result_), int, -1);
00357 # else
00358 ACE_WIN32CALL_RETURN (
00359 ACE_ADAPT_RETVAL (::LockFile (lock->handle_,
00360 lock->overlapped_.Offset,
00361 lock->overlapped_.OffsetHigh,
00362 low_len,
00363 high_len),
00364 ace_result_), int, -1);
00365 # endif
00366 #else
00367 lock->lock_.l_whence = whence;
00368 lock->lock_.l_start = start;
00369 lock->lock_.l_len = len;
00370 lock->lock_.l_type = F_WRLCK;
00371
00372 ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW,
00373 reinterpret_cast<long> (&lock->lock_)),
00374 int, -1);
00375 #endif
00376 }
00377
00378 #if !defined (ACE_LACKS_CLEARERR)
00379 ACE_INLINE void
00380 ACE_OS::clearerr (FILE* fp)
00381 {
00382 ace_clearerr_helper (fp);
00383 }
00384 #endif
00385
00386 #if !defined (ACE_LACKS_CUSERID)
00387 ACE_INLINE char *
00388 ACE_OS::cuserid (char *user, size_t maxlen)
00389 {
00390 ACE_OS_TRACE ("ACE_OS::cuserid");
00391 #if defined (ACE_VXWORKS)
00392 ACE_UNUSED_ARG (maxlen);
00393 if (user == 0)
00394 {
00395
00396
00397 ACE_NOTSUP_RETURN (0);
00398 }
00399 else
00400 {
00401 ::remCurIdGet (user, 0);
00402 return user;
00403 }
00404 #elif defined (__QNXNTO__) || defined (ACE_HAS_PHARLAP) || defined (ACE_HAS_WINCE)
00405 ACE_UNUSED_ARG (user);
00406 ACE_UNUSED_ARG (maxlen);
00407 ACE_NOTSUP_RETURN (0);
00408 #elif defined (ACE_WIN32)
00409 BOOL result = GetUserNameA (user, (u_long *) &maxlen);
00410 if (result == FALSE)
00411 ACE_FAIL_RETURN (0);
00412 else
00413 return user;
00414 #elif defined (ACE_HAS_ALT_CUSERID)
00415 # if defined (ACE_LACKS_PWD_FUNCTIONS)
00416 # error Cannot use alternate cuserid() without POSIX password functions!
00417 # endif
00418
00419
00420
00421
00422
00423 if (maxlen == 0)
00424 {
00425
00426 errno = EINVAL;
00427 return 0;
00428 }
00429
00430 struct passwd *pw = 0;
00431
00432
00433 ::setpwent ();
00434
00435
00436
00437
00438 pw = ::getpwuid (::geteuid ());
00439
00440
00441 ::endpwent ();
00442
00443 if (pw == 0)
00444 {
00445 errno = ENOENT;
00446 return 0;
00447 }
00448
00449 size_t max_length = 0;
00450 char *userid = 0;
00451
00452 if (user == 0)
00453 {
00454
00455
00456
00457 #if defined (_POSIX_SOURCE) && defined (L_cuserid)
00458 const size_t ACE_L_cuserid = L_cuserid;
00459 #else
00460 const size_t ACE_L_cuserid = 9;
00461 #endif
00462
00463 static char tmp[ACE_L_cuserid] = { '\0' };
00464 max_length = ACE_L_cuserid - 1;
00465
00466 userid = tmp;
00467 }
00468 else
00469 {
00470 max_length = maxlen;
00471 userid = user;
00472 }
00473
00474
00475 if (ACE_OS::strlen (pw->pw_name) <= max_length)
00476 {
00477 return ACE_OS::strcpy (userid, pw->pw_name);
00478 }
00479 else
00480 {
00481 errno = ENOSPC;
00482 return 0;
00483 }
00484 #else
00485
00486 ACE_UNUSED_ARG (maxlen);
00487 ACE_OSCALL_RETURN (::ace_cuserid(user), char*, 0);
00488 #endif
00489 }
00490
00491 #if defined (ACE_HAS_WCHAR)
00492 ACE_INLINE wchar_t *
00493 ACE_OS::cuserid (wchar_t *user, size_t maxlen)
00494 {
00495 # if defined (ACE_HAS_WINCE)
00496 ACE_UNUSED_ARG (user);
00497 ACE_UNUSED_ARG (maxlen);
00498 ACE_NOTSUP_RETURN (0);
00499 # elif defined (ACE_WIN32)
00500 BOOL result = GetUserNameW (user, (u_long *) &maxlen);
00501 if (result == FALSE)
00502 ACE_FAIL_RETURN (0);
00503 else
00504 return user;
00505 # else
00506 char *char_user;
00507 wchar_t *result = 0;
00508
00509 ACE_NEW_RETURN (char_user, char[maxlen + 1], 0);
00510
00511 if (ACE_OS::cuserid (char_user, maxlen))
00512 {
00513 ACE_OS::strcpy (user, ACE_Ascii_To_Wide (char_user).wchar_rep ());
00514 result = user;
00515 }
00516
00517 delete [] char_user;
00518
00519 return result;
00520 # endif
00521 }
00522 #endif
00523 #endif
00524
00525 ACE_INLINE int
00526 ACE_OS::fclose (FILE *fp)
00527 {
00528 ACE_OS_TRACE ("ACE_OS::fclose");
00529 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fclose (fp), int, -1);
00530 }
00531
00532 ACE_INLINE FILE *
00533 ACE_OS::fdopen (ACE_HANDLE handle, const ACE_TCHAR *mode)
00534 {
00535 ACE_OS_TRACE ("ACE_OS::fdopen");
00536 #if defined (ACE_HAS_WINCE)
00537 ACE_OSCALL_RETURN (::_wfdopen (handle, ACE_TEXT_ALWAYS_WCHAR (mode)),
00538 FILE*,
00539 0);
00540 #elif defined (ACE_WIN32)
00541
00542
00543
00544 FILE * file = 0;
00545
00546 int const crt_handle = ::_open_osfhandle (intptr_t (handle), 0);
00547
00548 if (crt_handle != -1)
00549 {
00550 # if defined(ACE_HAS_NONCONST_FDOPEN) && !defined (ACE_USES_WCHAR)
00551 file = ::_fdopen (crt_handle, const_cast<ACE_TCHAR *> (mode));
00552 # elif defined (ACE_HAS_NONCONST_FDOPEN) && defined (ACE_USES_WCHAR)
00553 file = ::_wfdopen (crt_handle, const_cast<ACE_TCHAR *> (mode));
00554 # elif defined (ACE_USES_WCHAR)
00555 file = ::_wfdopen (crt_handle, mode);
00556 # else
00557 file = ::_fdopen (crt_handle, mode);
00558 # endif
00559
00560 if (!file)
00561 {
00562 # if defined(__BORLANDC__)
00563 ::_rtl_close (crt_handle);
00564 # else
00565 ::_close (crt_handle);
00566 # endif
00567 }
00568 }
00569
00570 return file;
00571 #elif defined (ACE_LACKS_FDOPEN)
00572 ACE_UNUSED_ARG (handle);
00573 ACE_UNUSED_ARG (mode);
00574 ACE_NOTSUP_RETURN (0);
00575 #else
00576 ACE_OSCALL_RETURN
00577 (::fdopen (handle, ACE_TEXT_ALWAYS_CHAR (mode)), FILE *, 0);
00578 #endif
00579 }
00580
00581 ACE_INLINE int
00582 ACE_OS::fflush (FILE *fp)
00583 {
00584 ACE_OS_TRACE ("ACE_OS::fflush");
00585 #if defined (ACE_VXWORKS)
00586 if (fp == 0)
00587 {
00588
00589 return 0;
00590 }
00591 #endif
00592
00593 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fflush (fp), int, -1);
00594 }
00595
00596 ACE_INLINE int
00597 ACE_OS::fgetc (FILE* fp)
00598 {
00599 return ace_fgetc_helper (fp);
00600 }
00601
00602 ACE_INLINE int
00603 ACE_OS::getc (FILE* fp)
00604 {
00605 return ace_getc_helper (fp);
00606 }
00607
00608 ACE_INLINE int
00609 ACE_OS::fgetpos (FILE* fp, fpos_t* pos)
00610 {
00611 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgetpos (fp, pos), int, -1);
00612 }
00613
00614 ACE_INLINE char *
00615 ACE_OS::fgets (char *buf, int size, FILE *fp)
00616 {
00617 ACE_OS_TRACE ("ACE_OS::fgets");
00618 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgets (buf, size, fp), char *, 0);
00619 }
00620
00621 #if defined (ACE_HAS_WCHAR) && !defined(ACE_LACKS_FGETWS)
00622 ACE_INLINE wchar_t *
00623 ACE_OS::fgets (wchar_t *buf, int size, FILE *fp)
00624 {
00625 ACE_OS_TRACE ("ACE_OS::fgets");
00626 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgetws (buf, size, fp), wchar_t *, 0);
00627 }
00628 #endif
00629
00630 #if !(defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
00631
00632 ACE_INLINE FILE *
00633 ACE_OS::fopen (const char *filename, const ACE_TCHAR *mode)
00634 {
00635 ACE_OS_TRACE ("ACE_OS::fopen");
00636 ACE_OSCALL_RETURN
00637 (::fopen (filename, ACE_TEXT_ALWAYS_CHAR (mode)), FILE *, 0);
00638 }
00639
00640 #if defined (ACE_HAS_WCHAR)
00641 ACE_INLINE FILE *
00642 ACE_OS::fopen (const wchar_t *filename, const ACE_TCHAR *mode)
00643 {
00644 ACE_OS_TRACE ("ACE_OS::fopen");
00645 #if defined (ACE_HAS_WINCE)
00646 ACE_OSCALL_RETURN
00647 (::_wfopen (filename, ACE_TEXT_ALWAYS_WCHAR (mode)), FILE *, 0);
00648 #else
00649
00650 ACE_Wide_To_Ascii n_filename (filename);
00651 ACE_OSCALL_RETURN
00652 (::fopen (n_filename.char_rep (), ACE_TEXT_ALWAYS_CHAR (mode)), FILE*, 0);
00653 #endif
00654 }
00655 #endif
00656
00657 #endif
00658
00659 ACE_INLINE int
00660 ACE_OS::ungetc (int c, FILE *fp)
00661 {
00662 return ace_ungetc_helper (c, fp);
00663 }
00664
00665 ACE_INLINE int
00666 ACE_OS::fputc (int c, FILE *fp)
00667 {
00668 return ace_fputc_helper (c, fp);
00669 }
00670
00671 ACE_INLINE int
00672 ACE_OS::putc (int c, FILE *fp)
00673 {
00674 return ace_putc_helper (c, fp);
00675 }
00676
00677 ACE_INLINE int
00678 ACE_OS::fputs (const char *s, FILE *stream)
00679 {
00680 ACE_OS_TRACE ("ACE_OS::fputs");
00681 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fputs (s, stream), int, -1);
00682 }
00683
00684 #if defined (ACE_HAS_WCHAR) && !defined(ACE_LACKS_FPUTWS)
00685 ACE_INLINE int
00686 ACE_OS::fputs (const wchar_t *s, FILE *stream)
00687 {
00688 ACE_OS_TRACE ("ACE_OS::fputs");
00689 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fputws (s, stream), int, -1);
00690 }
00691 #endif
00692
00693 ACE_INLINE size_t
00694 ACE_OS::fread (void *ptr, size_t size, size_t nelems, FILE *fp)
00695 {
00696 ACE_OS_TRACE ("ACE_OS::fread");
00697 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fread (ptr, size, nelems, fp),
00698 size_t,
00699 0);
00700 }
00701
00702 ACE_INLINE FILE *
00703 ACE_OS::freopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode, FILE* stream)
00704 {
00705 ACE_OS_TRACE ("ACE_OS::freopen");
00706 #if defined (ACE_WIN32) && (defined(ACE_USES_WCHAR) || defined(ACE_HAS_WINCE))
00707 ACE_OSCALL_RETURN (::_wfreopen (ACE_TEXT_ALWAYS_WCHAR (filename),
00708 ACE_TEXT_ALWAYS_WCHAR (mode),
00709 stream),
00710 FILE *, 0);
00711 #else
00712 ACE_OSCALL_RETURN
00713 (ACE_STD_NAMESPACE::freopen (ACE_TEXT_ALWAYS_CHAR (filename),
00714 ACE_TEXT_ALWAYS_CHAR (mode),
00715 stream),
00716 FILE *, 0);
00717 #endif
00718 }
00719
00720 ACE_INLINE int
00721 ACE_OS::fseek (FILE *fp, long offset, int whence)
00722 {
00723 # if defined (ACE_WIN32)
00724 # if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END
00725
00726 switch (whence)
00727 {
00728 case SEEK_SET:
00729 whence = FILE_BEGIN;
00730 break;
00731 case SEEK_CUR:
00732 whence = FILE_CURRENT;
00733 break;
00734 case SEEK_END:
00735 whence = FILE_END;
00736 break;
00737 default:
00738 errno = EINVAL;
00739 return -1;
00740 }
00741 # endif
00742 # endif
00743 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fseek (fp, offset, whence), int, -1);
00744 }
00745
00746 ACE_INLINE int
00747 ACE_OS::fsetpos (FILE* fp, fpos_t* pos)
00748 {
00749 ACE_OSCALL_RETURN (::fsetpos (fp, pos), int, -1);
00750 }
00751
00752 ACE_INLINE long
00753 ACE_OS::ftell (FILE* fp)
00754 {
00755 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::ftell (fp), long, -1);
00756 }
00757
00758 ACE_INLINE size_t
00759 ACE_OS::fwrite (const void *ptr, size_t size, size_t nitems, FILE *fp)
00760 {
00761 ACE_OS_TRACE ("ACE_OS::fwrite");
00762 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fwrite (ptr, size, nitems, fp),
00763 size_t,
00764 0);
00765 }
00766
00767 ACE_INLINE void
00768 ACE_OS::perror (const char *s)
00769 {
00770 ACE_OS_TRACE ("ACE_OS::perror");
00771 #if defined (ACE_LACKS_PERROR)
00772 ACE_UNUSED_ARG (s);
00773 #else
00774 ::perror (s);
00775 #endif
00776 }
00777
00778 #if defined (ACE_HAS_WCHAR)
00779 ACE_INLINE void
00780 ACE_OS::perror (const wchar_t *s)
00781 {
00782 ACE_OS_TRACE ("ACE_OS::perror");
00783 #if defined (ACE_LACKS_PERROR)
00784 ACE_UNUSED_ARG (s);
00785 #elif defined (ACE_WIN32)
00786 ::_wperror (s);
00787 #else
00788 ACE_Wide_To_Ascii n_s (s);
00789 ::perror (n_s.char_rep ());
00790 #endif
00791 }
00792 #endif
00793
00794 ACE_INLINE int
00795 ACE_OS::puts (const char *s)
00796 {
00797 ACE_OS_TRACE ("ACE_OS::puts");
00798 ACE_OSCALL_RETURN (::puts (s), int, -1);
00799 }
00800
00801 #if defined (ACE_HAS_WCHAR)
00802 ACE_INLINE int
00803 ACE_OS::puts (const wchar_t *s)
00804 {
00805 ACE_OS_TRACE ("ACE_OS::puts");
00806 #if defined (ACE_WIN32)
00807 ACE_OSCALL_RETURN (::_putws (s), int, -1);
00808 #else
00809
00810 ACE_Wide_To_Ascii n_s (s);
00811 ACE_OSCALL_RETURN (::puts (n_s.char_rep ()), int, -1);
00812 #endif
00813 }
00814 #endif
00815
00816 ACE_INLINE int
00817 ACE_OS::rename (const char *old_name,
00818 const char *new_name,
00819 int flags)
00820 {
00821 # if defined (ACE_LACKS_RENAME)
00822 ACE_UNUSED_ARG (old_name);
00823 ACE_UNUSED_ARG (new_name);
00824 ACE_UNUSED_ARG (flags);
00825 ACE_NOTSUP_RETURN (-1);
00826 # elif defined (ACE_HAS_WINCE)
00827
00828 ACE_UNUSED_ARG (flags);
00829 if (0 != MoveFile (ACE_TEXT_CHAR_TO_TCHAR (old_name),
00830 ACE_TEXT_CHAR_TO_TCHAR (new_name)))
00831 ACE_FAIL_RETURN (-1);
00832 return 0;
00833 # elif defined (ACE_WIN32) && !defined (ACE_LACKS_WIN32_MOVEFILEEX)
00834
00835
00836
00837
00838 if (flags == -1)
00839 flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING;
00840 if (::MoveFileExA (old_name, new_name, flags) == 0)
00841 ACE_FAIL_RETURN (-1);
00842 return 0;
00843 # else
00844 ACE_UNUSED_ARG (flags);
00845 ACE_OSCALL_RETURN (::rename (old_name, new_name), int, -1);
00846 # endif
00847 }
00848
00849 #if defined (ACE_HAS_WCHAR)
00850 ACE_INLINE int
00851 ACE_OS::rename (const wchar_t *old_name,
00852 const wchar_t *new_name,
00853 int flags)
00854 {
00855 # if defined (ACE_LACKS_RENAME)
00856 ACE_UNUSED_ARG (old_name);
00857 ACE_UNUSED_ARG (new_name);
00858 ACE_UNUSED_ARG (flags);
00859 ACE_NOTSUP_RETURN (-1);
00860 # elif defined (ACE_HAS_WINCE)
00861 ACE_UNUSED_ARG (flags);
00862 if (MoveFileW (old_name, new_name) != 0)
00863 ACE_FAIL_RETURN (-1);
00864 return 0;
00865 # elif defined (ACE_WIN32) && !defined (ACE_LACKS_WIN32_MOVEFILEEX)
00866
00867
00868
00869
00870 if (flags == -1)
00871 flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING;
00872 if (::MoveFileExW (old_name, new_name, flags) == 0)
00873 ACE_FAIL_RETURN (-1);
00874 return 0;
00875 # elif defined (ACE_WIN32)
00876 ACE_UNUSED_ARG (flags);
00877 ACE_OSCALL_RETURN (::_wrename (old_name, new_name), int, -1);
00878 # else
00879 ACE_Wide_To_Ascii nold_name (old_name);
00880 ACE_Wide_To_Ascii nnew_name (new_name);
00881 return ACE_OS::rename (nold_name.char_rep (), nnew_name.char_rep (), flags);
00882 # endif
00883 }
00884 #endif
00885
00886 ACE_INLINE void
00887 ACE_OS::rewind (FILE *fp)
00888 {
00889 #if !defined (ACE_HAS_WINCE)
00890 ACE_OS_TRACE ("ACE_OS::rewind");
00891 ::rewind (fp);
00892 #else
00893
00894
00895 (void) fseek (fp, 0L, SEEK_SET);
00896 #endif
00897 }
00898
00899 ACE_INLINE char *
00900 ACE_OS::tempnam (const char *dir, const char *pfx)
00901 {
00902 ACE_OS_TRACE ("ACE_OS::tempnam");
00903 #if defined (ACE_LACKS_TEMPNAM)
00904 ACE_UNUSED_ARG (dir);
00905 ACE_UNUSED_ARG (pfx);
00906 ACE_NOTSUP_RETURN (0);
00907 #elif defined (ACE_HAS_NONCONST_TEMPNAM)
00908 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::tempnam (const_cast <char *> (dir), const_cast<char *> (pfx)), char *, 0);
00909 #else
00910 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::tempnam (dir, pfx), char *, 0);
00911 #endif
00912 }
00913
00914 #if defined (ACE_HAS_WCHAR)
00915 ACE_INLINE wchar_t *
00916 ACE_OS::tempnam (const wchar_t *dir, const wchar_t *pfx)
00917 {
00918 ACE_OS_TRACE ("ACE_OS::tempnam");
00919 #if defined (ACE_LACKS_TEMPNAM)
00920 ACE_UNUSED_ARG (dir);
00921 ACE_UNUSED_ARG (pfx);
00922 ACE_NOTSUP_RETURN (0);
00923 #elif defined(ACE_WIN32)
00924 # if defined (ACE_HAS_NONCONST_TEMPNAM)
00925 ACE_OSCALL_RETURN (::_wtempnam (const_cast <wchar_t*> (dir), const_cast <wchar_t*> (pfx)), wchar_t *, 0);
00926 # else
00927 ACE_OSCALL_RETURN (::_wtempnam (dir, pfx), wchar_t *, 0);
00928 # endif
00929 #else
00930
00931 char *ndir = ACE_Wide_To_Ascii (dir).char_rep ();
00932 char *npfx = ACE_Wide_To_Ascii (pfx).char_rep ();
00933 char *name = ACE_OS::tempnam (ndir, npfx);
00934
00935
00936 wchar_t *wname = 0;
00937 if (name != 0)
00938 {
00939 size_t namelen = ACE_OS::strlen (name) + 1;
00940 wname = reinterpret_cast<wchar_t *>
00941 (ACE_OS::malloc (namelen * sizeof (wchar_t)));
00942 if (wname != 0)
00943 ACE_OS::strcpy (wname, ACE_Ascii_To_Wide (name).wchar_rep ());
00944 ACE_OS::free (name);
00945 }
00946 return wname;
00947 #endif
00948 }
00949 #endif
00950
00951 ACE_INLINE int
00952 ACE_OS::vsprintf (char *buffer, const char *format, va_list argptr)
00953 {
00954 return ::vsprintf (buffer, format, argptr);
00955 }
00956
00957 ACE_INLINE int
00958 ACE_OS::vsnprintf (char *buffer, size_t maxlen, const char *format, va_list ap)
00959 {
00960 #if !defined (ACE_LACKS_VSNPRINTF)
00961 int result;
00962 # if 0
00963
00964
00965
00966 result = _vsnprintf_s (buffer, maxlen, _TRUNCATE, format, ap);
00967 # elif !defined (ACE_WIN32)
00968 result = ::vsnprintf (buffer, maxlen, format, ap);
00969 # else
00970 result = ::_vsnprintf (buffer, maxlen, format, ap);
00971
00972
00973 if (result == static_cast<int> (maxlen))
00974 buffer[maxlen-1] = '\0';
00975
00976
00977 if (result == -1)
00978 buffer[maxlen-1] = '\0';
00979 # endif
00980
00981
00982
00983
00984
00985 if (result == -1)
00986 {
00987 result = static_cast <int> (maxlen + 1);
00988 }
00989
00990 return result;
00991 #elif defined (ACE_HAS_TRIO)
00992 return trio_vsnprintf (buffer, maxlen, format, ap);
00993 #else
00994 ACE_UNUSED_ARG (buffer);
00995 ACE_UNUSED_ARG (maxlen);
00996 ACE_UNUSED_ARG (format);
00997 ACE_UNUSED_ARG (ap);
00998 ACE_NOTSUP_RETURN (-1);
00999 #endif
01000 }
01001
01002 #if defined (ACE_HAS_WCHAR)
01003 ACE_INLINE int
01004 ACE_OS::vsprintf (wchar_t *buffer, const wchar_t *format, va_list argptr)
01005 {
01006 # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) || \
01007 (defined (sun) && !(defined(_XOPEN_SOURCE) && (_XOPEN_VERSION-0==4))) || \
01008 defined (ACE_HAS_DINKUM_STL) || defined (__DMC__) || \
01009 defined (ACE_HAS_VSWPRINTF) || \
01010 (defined (ACE_WIN32_VC8) && !defined (ACE_HAS_WINCE) && \
01011 _MSC_FULL_VER > 140050000)
01012
01013
01014
01015
01016
01017
01018 return vswprintf (buffer, 4096, format, argptr);
01019
01020 # elif defined (ACE_WIN32)
01021
01022
01023
01024 return vswprintf (buffer, format, argptr);
01025
01026 # else
01027 ACE_UNUSED_ARG (buffer);
01028 ACE_UNUSED_ARG (format);
01029 ACE_UNUSED_ARG (argptr);
01030 ACE_NOTSUP_RETURN (-1);
01031
01032 # endif
01033 }
01034 #endif
01035
01036 #if defined (ACE_HAS_WCHAR)
01037 ACE_INLINE int
01038 ACE_OS::vsnprintf (wchar_t *buffer, size_t maxlen, const wchar_t *format, va_list ap)
01039 {
01040 # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) || \
01041 (defined (sun) && !(defined(_XOPEN_SOURCE) && (_XOPEN_VERSION-0==4))) || \
01042 (defined (ACE_HAS_DINKUM_STL) || defined (__DMC__)) || \
01043 defined (ACE_HAS_VSWPRINTF)
01044
01045 return vswprintf (buffer, maxlen, format, ap);
01046
01047 # elif defined (ACE_HAS_TR24731_2005_CRT)
01048
01049 return _vsnwprintf_s (buffer, maxlen, _TRUNCATE, format, ap);
01050
01051 # elif defined (ACE_WIN32)
01052
01053 int result = ::_vsnwprintf (buffer, maxlen, format, ap);
01054
01055
01056
01057 if (result == static_cast<int> (maxlen))
01058 result = -1;
01059
01060
01061 if (result == -1)
01062 buffer[maxlen-1] = '\0';
01063
01064 return result;
01065
01066 # else
01067
01068 ACE_UNUSED_ARG (buffer);
01069 ACE_UNUSED_ARG (maxlen);
01070 ACE_UNUSED_ARG (format);
01071 ACE_UNUSED_ARG (ap);
01072 ACE_NOTSUP_RETURN (-1);
01073
01074 # endif
01075 }
01076 #endif
01077
01078 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
01079 #if defined (ACE_WIN32)
01080 ACE_INLINE const ACE_TEXT_OSVERSIONINFO &
01081 ACE_OS::get_win32_versioninfo ()
01082 {
01083 return ACE_OS::win32_versioninfo_;
01084 }
01085
01086 ACE_INLINE HINSTANCE
01087 ACE_OS::get_win32_resource_module ()
01088 {
01089 return ACE_OS::win32_resource_module_;
01090 }
01091
01092 ACE_INLINE void
01093 ACE_OS::set_win32_resource_module (HINSTANCE instance)
01094 {
01095 ACE_OS::win32_resource_module_ = instance;
01096 }
01097
01098 ACE_INLINE LPSECURITY_ATTRIBUTES
01099 ACE_OS::default_win32_security_attributes (LPSECURITY_ATTRIBUTES sa)
01100 {
01101 #if defined (ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES)
01102 if (sa == 0)
01103 {
01104
01105 static SECURITY_ATTRIBUTES default_sa;
01106 static SECURITY_DESCRIPTOR sd;
01107 InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
01108 SetSecurityDescriptorDacl(&sd, TRUE, 0, FALSE);
01109 default_sa.nLength = sizeof(SECURITY_ATTRIBUTES);
01110 default_sa.lpSecurityDescriptor = &sd;
01111 default_sa.bInheritHandle = TRUE;
01112 sa = &default_sa;
01113 }
01114 return sa;
01115 #else
01116 return sa;
01117 #endif
01118 }
01119
01120 ACE_INLINE LPSECURITY_ATTRIBUTES
01121 ACE_OS::default_win32_security_attributes_r (LPSECURITY_ATTRIBUTES sa,
01122 LPSECURITY_ATTRIBUTES sa_buffer,
01123 SECURITY_DESCRIPTOR* sd_buffer)
01124 {
01125 #if defined (ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES)
01126 if (sa == 0)
01127 {
01128 if (sa_buffer != 0 && sd_buffer != 0)
01129 {
01130 InitializeSecurityDescriptor
01131 (sd_buffer, SECURITY_DESCRIPTOR_REVISION);
01132 SetSecurityDescriptorDacl (sd_buffer, TRUE, 0, FALSE);
01133 sa_buffer->nLength = sizeof(SECURITY_ATTRIBUTES);
01134 sa_buffer->lpSecurityDescriptor = sd_buffer;
01135 sa_buffer->bInheritHandle = TRUE;
01136 sa = sa_buffer;
01137 }
01138 }
01139 return sa;
01140 #else
01141 ACE_UNUSED_ARG(sa_buffer);
01142 ACE_UNUSED_ARG(sd_buffer);
01143 return sa;
01144 #endif
01145 }
01146
01147 #endif
01148 #endif
01149
01150 ACE_END_VERSIONED_NAMESPACE_DECL