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