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 (::UnlockFileEx (lock->handle_,
00139 0,
00140 low_len,
00141 high_len,
00142 &lock->overlapped_),
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 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00198 0,
00199 0,
00200 low_len,
00201 high_len,
00202 &lock->overlapped_),
00203 ace_result_), int, -1);
00204 #else
00205 lock->lock_.l_whence = whence;
00206 lock->lock_.l_start = start;
00207 lock->lock_.l_len = len;
00208 lock->lock_.l_type = F_RDLCK;
00209
00210 ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW,
00211 reinterpret_cast<long> (&lock->lock_)),
00212 int, -1);
00213 #endif
00214 }
00215
00216 ACE_INLINE int
00217 ACE_OS::flock_tryrdlock (ACE_OS::ace_flock_t *lock,
00218 short whence,
00219 ACE_OFF_T start,
00220 ACE_OFF_T len)
00221 {
00222 ACE_OS_TRACE ("ACE_OS::ace_flock_tryrdlock");
00223 #if defined (ACE_LACKS_FILELOCKS)
00224 ACE_UNUSED_ARG (lock);
00225 ACE_UNUSED_ARG (whence);
00226 ACE_UNUSED_ARG (start);
00227 ACE_UNUSED_ARG (len);
00228 ACE_NOTSUP_RETURN (-1);
00229 #elif defined (ACE_WIN32)
00230 ACE_OS::flock_adjust_params (lock, whence, start, len);
00231 DWORD low_len = ACE_LOW_PART (len);
00232 DWORD high_len = ACE_HIGH_PART (len);
00233 ACE_WIN32CALL_RETURN (
00234 ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00235 LOCKFILE_FAIL_IMMEDIATELY,
00236 0,
00237 low_len,
00238 high_len,
00239 &lock->overlapped_),
00240 ace_result_), int, -1);
00241 #else
00242 lock->lock_.l_whence = whence;
00243 lock->lock_.l_start = start;
00244 lock->lock_.l_len = len;
00245 lock->lock_.l_type = F_RDLCK;
00246
00247 int result = 0;
00248
00249 ACE_OSCALL (ACE_OS::fcntl (lock->handle_, F_SETLK,
00250 reinterpret_cast<long> (&lock->lock_)),
00251 int, -1, result);
00252
00253 if (result == -1 && (errno == EACCES || errno == EAGAIN))
00254 errno = EBUSY;
00255
00256 return result;
00257 #endif
00258 }
00259
00260 ACE_INLINE int
00261 ACE_OS::flock_trywrlock (ACE_OS::ace_flock_t *lock,
00262 short whence,
00263 ACE_OFF_T start,
00264 ACE_OFF_T len)
00265 {
00266 ACE_OS_TRACE ("ACE_OS::ace_flock_trywrlock");
00267 #if defined (ACE_LACKS_FILELOCKS)
00268 ACE_UNUSED_ARG (lock);
00269 ACE_UNUSED_ARG (whence);
00270 ACE_UNUSED_ARG (start);
00271 ACE_UNUSED_ARG (len);
00272 ACE_NOTSUP_RETURN (-1);
00273 #elif defined (ACE_WIN32)
00274 ACE_OS::flock_adjust_params (lock, whence, start, len);
00275 DWORD low_len = ACE_LOW_PART (len);
00276 DWORD high_len = ACE_HIGH_PART (len);
00277 ACE_WIN32CALL_RETURN (
00278 ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00279 LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK,
00280 0,
00281 low_len,
00282 high_len,
00283 &lock->overlapped_),
00284 ace_result_), int, -1);
00285 #else
00286 lock->lock_.l_whence = whence;
00287 lock->lock_.l_start = start;
00288 lock->lock_.l_len = len;
00289 lock->lock_.l_type = F_WRLCK;
00290
00291 int result = 0;
00292
00293 ACE_OSCALL (ACE_OS::fcntl (lock->handle_,
00294 F_SETLK,
00295 reinterpret_cast<long> (&lock->lock_)),
00296 int, -1, result);
00297
00298 if (result == -1 && (errno == EACCES || errno == EAGAIN))
00299 errno = EBUSY;
00300
00301 return result;
00302 #endif
00303 }
00304
00305 ACE_INLINE int
00306 ACE_OS::flock_wrlock (ACE_OS::ace_flock_t *lock,
00307 short whence,
00308 ACE_OFF_T start,
00309 ACE_OFF_T len)
00310 {
00311 ACE_OS_TRACE ("ACE_OS::flock_wrlock");
00312 #if defined (ACE_LACKS_FILELOCKS)
00313 ACE_UNUSED_ARG (lock);
00314 ACE_UNUSED_ARG (whence);
00315 ACE_UNUSED_ARG (start);
00316 ACE_UNUSED_ARG (len);
00317 ACE_NOTSUP_RETURN (-1);
00318 #elif defined (ACE_WIN32)
00319 ACE_OS::flock_adjust_params (lock, whence, start, len);
00320 DWORD low_len = ACE_LOW_PART (len);
00321 DWORD high_len = ACE_HIGH_PART (len);
00322 ACE_WIN32CALL_RETURN (
00323 ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_,
00324 LOCKFILE_EXCLUSIVE_LOCK,
00325 0,
00326 low_len,
00327 high_len,
00328 &lock->overlapped_),
00329 ace_result_), int, -1);
00330 #else
00331 lock->lock_.l_whence = whence;
00332 lock->lock_.l_start = start;
00333 lock->lock_.l_len = len;
00334 lock->lock_.l_type = F_WRLCK;
00335
00336 ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW,
00337 reinterpret_cast<long> (&lock->lock_)),
00338 int, -1);
00339 #endif
00340 }
00341
00342 #if !defined (ACE_LACKS_CLEARERR)
00343 ACE_INLINE void
00344 ACE_OS::clearerr (FILE* fp)
00345 {
00346 ace_clearerr_helper (fp);
00347 }
00348 #endif
00349
00350 #if !defined (ACE_LACKS_CUSERID)
00351 ACE_INLINE char *
00352 ACE_OS::cuserid (char *user, size_t maxlen)
00353 {
00354 ACE_OS_TRACE ("ACE_OS::cuserid");
00355 #if defined (ACE_VXWORKS)
00356 ACE_UNUSED_ARG (maxlen);
00357 if (user == 0)
00358 {
00359
00360
00361 ACE_NOTSUP_RETURN (0);
00362 }
00363 else
00364 {
00365 ::remCurIdGet (user, 0);
00366 return user;
00367 }
00368 #elif defined (ACE_HAS_PHARLAP) || defined (ACE_HAS_WINCE)
00369 ACE_UNUSED_ARG (user);
00370 ACE_UNUSED_ARG (maxlen);
00371 ACE_NOTSUP_RETURN (0);
00372 #elif defined (ACE_WIN32)
00373 BOOL const result = GetUserNameA (user, (u_long *) &maxlen);
00374 if (result == FALSE)
00375 ACE_FAIL_RETURN (0);
00376 else
00377 return user;
00378 #elif defined (ACE_HAS_ALT_CUSERID)
00379 # if defined (ACE_LACKS_PWD_FUNCTIONS)
00380 # error Cannot use alternate cuserid() without POSIX password functions!
00381 # endif
00382
00383
00384
00385
00386
00387 if (maxlen == 0)
00388 {
00389
00390 errno = EINVAL;
00391 return 0;
00392 }
00393
00394 struct passwd *pw = 0;
00395
00396
00397 ACE_OS::setpwent ();
00398
00399
00400
00401
00402 pw = ::getpwuid (ACE_OS::geteuid ());
00403
00404
00405 ACE_OS::endpwent ();
00406
00407 if (pw == 0)
00408 {
00409 errno = ENOENT;
00410 return 0;
00411 }
00412
00413 size_t max_length = 0;
00414 char *userid = 0;
00415
00416 if (user == 0)
00417 {
00418
00419
00420
00421 #if defined (_POSIX_SOURCE) && defined (L_cuserid)
00422 const size_t ACE_L_cuserid = L_cuserid;
00423 #else
00424 const size_t ACE_L_cuserid = 9;
00425 #endif
00426
00427 static char tmp[ACE_L_cuserid] = { '\0' };
00428 max_length = ACE_L_cuserid - 1;
00429
00430 userid = tmp;
00431 }
00432 else
00433 {
00434 max_length = maxlen;
00435 userid = user;
00436 }
00437
00438
00439 if (ACE_OS::strlen (pw->pw_name) <= max_length)
00440 {
00441 return ACE_OS::strcpy (userid, pw->pw_name);
00442 }
00443 else
00444 {
00445 errno = ENOSPC;
00446 return 0;
00447 }
00448 #else
00449
00450 ACE_UNUSED_ARG (maxlen);
00451 ACE_OSCALL_RETURN (::ace_cuserid(user), char*, 0);
00452 #endif
00453 }
00454
00455 #if defined (ACE_HAS_WCHAR)
00456 ACE_INLINE wchar_t *
00457 ACE_OS::cuserid (wchar_t *user, size_t maxlen)
00458 {
00459 # if defined (ACE_HAS_WINCE)
00460 ACE_UNUSED_ARG (user);
00461 ACE_UNUSED_ARG (maxlen);
00462 ACE_NOTSUP_RETURN (0);
00463 # elif defined (ACE_WIN32)
00464 BOOL const result = GetUserNameW (user, (u_long *) &maxlen);
00465 if (result == FALSE)
00466 ACE_FAIL_RETURN (0);
00467 else
00468 return user;
00469 # else
00470 char *char_user;
00471 wchar_t *result = 0;
00472
00473 ACE_NEW_RETURN (char_user, char[maxlen + 1], 0);
00474
00475 if (ACE_OS::cuserid (char_user, maxlen))
00476 {
00477 ACE_OS::strcpy (user, ACE_Ascii_To_Wide (char_user).wchar_rep ());
00478 result = user;
00479 }
00480
00481 delete [] char_user;
00482
00483 return result;
00484 # endif
00485 }
00486 #endif
00487 #endif
00488
00489 ACE_INLINE int
00490 ACE_OS::fclose (FILE *fp)
00491 {
00492 ACE_OS_TRACE ("ACE_OS::fclose");
00493 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fclose (fp), int, -1);
00494 }
00495
00496 ACE_INLINE FILE *
00497 ACE_OS::fdopen (ACE_HANDLE handle, const ACE_TCHAR *mode)
00498 {
00499 ACE_OS_TRACE ("ACE_OS::fdopen");
00500 #if defined (ACE_HAS_WINCE)
00501 # if defined (ACE_HAS_NONCONST_WFDOPEN)
00502 ACE_OSCALL_RETURN (::_wfdopen ((int)handle, const_cast <ACE_TCHAR*> (ACE_TEXT_ALWAYS_WCHAR (mode))),
00503 FILE*,
00504 0);
00505 # else
00506 ACE_OSCALL_RETURN (::_wfdopen (handle, ACE_TEXT_ALWAYS_WCHAR (mode)),
00507 FILE*,
00508 0);
00509 # endif
00510 #elif defined (ACE_WIN32)
00511
00512
00513
00514 FILE * file = 0;
00515
00516 int const crt_handle = ::_open_osfhandle (intptr_t (handle), 0);
00517
00518 if (crt_handle != -1)
00519 {
00520 # if defined (ACE_USES_WCHAR)
00521 file = ::_wfdopen (crt_handle, mode);
00522 # else
00523 file = ::_fdopen (crt_handle, mode);
00524 # endif
00525
00526 if (!file)
00527 {
00528 ::_close (crt_handle);
00529 }
00530 }
00531
00532 return file;
00533 #elif defined (ACE_LACKS_FDOPEN)
00534 ACE_UNUSED_ARG (handle);
00535 ACE_UNUSED_ARG (mode);
00536 ACE_NOTSUP_RETURN (0);
00537 #else
00538 ACE_OSCALL_RETURN
00539 (::fdopen (handle, ACE_TEXT_ALWAYS_CHAR (mode)), FILE *, 0);
00540 #endif
00541 }
00542
00543 ACE_INLINE int
00544 ACE_OS::fflush (FILE *fp)
00545 {
00546 ACE_OS_TRACE ("ACE_OS::fflush");
00547 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fflush (fp), int, -1);
00548 }
00549
00550 ACE_INLINE int
00551 ACE_OS::fgetc (FILE* fp)
00552 {
00553 return ace_fgetc_helper (fp);
00554 }
00555
00556 ACE_INLINE int
00557 ACE_OS::getc (FILE* fp)
00558 {
00559 return ace_getc_helper (fp);
00560 }
00561
00562 ACE_INLINE int
00563 ACE_OS::fgetpos (FILE* fp, fpos_t* pos)
00564 {
00565 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgetpos (fp, pos), int, -1);
00566 }
00567
00568 ACE_INLINE char *
00569 ACE_OS::fgets (char *buf, int size, FILE *fp)
00570 {
00571 ACE_OS_TRACE ("ACE_OS::fgets");
00572 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgets (buf, size, fp), char *, 0);
00573 }
00574
00575 #if defined (ACE_HAS_WCHAR) && !defined(ACE_LACKS_FGETWS)
00576 ACE_INLINE wchar_t *
00577 ACE_OS::fgets (wchar_t *buf, int size, FILE *fp)
00578 {
00579 ACE_OS_TRACE ("ACE_OS::fgets");
00580 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgetws (buf, size, fp), wchar_t *, 0);
00581 }
00582 #endif
00583
00584 ACE_INLINE ACE_HANDLE
00585 ACE_OS::fileno (FILE *stream)
00586 {
00587 #if defined ACE_FILENO_EQUIVALENT
00588 return (ACE_HANDLE)ACE_FILENO_EQUIVALENT (stream);
00589 #else
00590 return ace_fileno_helper (stream);
00591 #endif
00592 }
00593
00594 #if !(defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
00595
00596 ACE_INLINE FILE *
00597 ACE_OS::fopen (const char *filename, const char *mode)
00598 {
00599 ACE_OS_TRACE ("ACE_OS::fopen");
00600 ACE_OSCALL_RETURN (::fopen (filename, mode), FILE *, 0);
00601 }
00602
00603 #if defined (ACE_HAS_WCHAR)
00604
00605 ACE_INLINE FILE *
00606 ACE_OS::fopen (const char *filename, const wchar_t *mode)
00607 {
00608 ACE_OS_TRACE ("ACE_OS::fopen");
00609 ACE_Wide_To_Ascii n_mode (mode);
00610 ACE_OSCALL_RETURN (::fopen (filename, n_mode.char_rep ()), FILE *, 0);
00611 }
00612
00613
00614 ACE_INLINE FILE *
00615 ACE_OS::fopen (const wchar_t *filename, const wchar_t *mode)
00616 {
00617 ACE_OS_TRACE ("ACE_OS::fopen");
00618 #if defined (ACE_HAS_WINCE)
00619 ACE_OSCALL_RETURN (::_wfopen (filename, mode), FILE *, 0);
00620 #else
00621
00622 ACE_Wide_To_Ascii n_filename (filename);
00623 ACE_Wide_To_Ascii n_mode (mode);
00624 ACE_OSCALL_RETURN
00625 (::fopen (n_filename.char_rep (), n_mode.char_rep ()), FILE*, 0);
00626 #endif
00627 }
00628
00629 ACE_INLINE FILE *
00630 ACE_OS::fopen (const wchar_t *filename, const char *mode)
00631 {
00632 ACE_OS_TRACE ("ACE_OS::fopen");
00633 #if defined (ACE_HAS_WINCE)
00634 ACE_Ascii_To_Wide n_mode (mode);
00635 ACE_OSCALL_RETURN
00636 (::_wfopen (filename, n_mode.wchar_rep ()), FILE *, 0);
00637 #else
00638
00639 ACE_Wide_To_Ascii n_filename (filename);
00640 ACE_OSCALL_RETURN
00641 (::fopen (n_filename.char_rep (), mode), FILE*, 0);
00642 #endif
00643 }
00644 #endif
00645
00646 #endif
00647
00648 ACE_INLINE int
00649 ACE_OS::ungetc (int c, FILE *fp)
00650 {
00651 return ace_ungetc_helper (c, fp);
00652 }
00653
00654 ACE_INLINE int
00655 ACE_OS::fputc (int c, FILE *fp)
00656 {
00657 return ace_fputc_helper (c, fp);
00658 }
00659
00660 ACE_INLINE int
00661 ACE_OS::putc (int c, FILE *fp)
00662 {
00663 return ace_putc_helper (c, fp);
00664 }
00665
00666 ACE_INLINE int
00667 ACE_OS::fputs (const char *s, FILE *stream)
00668 {
00669 ACE_OS_TRACE ("ACE_OS::fputs");
00670 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fputs (s, stream), int, -1);
00671 }
00672
00673 #if defined (ACE_HAS_WCHAR) && !defined(ACE_LACKS_FPUTWS)
00674 ACE_INLINE int
00675 ACE_OS::fputs (const wchar_t *s, FILE *stream)
00676 {
00677 ACE_OS_TRACE ("ACE_OS::fputs");
00678 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fputws (s, stream), int, -1);
00679 }
00680 #endif
00681
00682 ACE_INLINE size_t
00683 ACE_OS::fread (void *ptr, size_t size, size_t nelems, FILE *fp)
00684 {
00685 ACE_OS_TRACE ("ACE_OS::fread");
00686 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fread (ptr, size, nelems, fp),
00687 size_t,
00688 0);
00689 }
00690
00691 ACE_INLINE FILE *
00692 ACE_OS::freopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode, FILE* stream)
00693 {
00694 ACE_OS_TRACE ("ACE_OS::freopen");
00695 #if defined (ACE_WIN32) && defined(ACE_USES_WCHAR)
00696 ACE_OSCALL_RETURN (::_wfreopen (ACE_TEXT_ALWAYS_WCHAR (filename),
00697 ACE_TEXT_ALWAYS_WCHAR (mode),
00698 stream),
00699 FILE *, 0);
00700 #else
00701 ACE_OSCALL_RETURN
00702 (ACE_STD_NAMESPACE::freopen (ACE_TEXT_ALWAYS_CHAR (filename),
00703 ACE_TEXT_ALWAYS_CHAR (mode),
00704 stream),
00705 FILE *, 0);
00706 #endif
00707 }
00708
00709 ACE_INLINE int
00710 ACE_OS::fseek (FILE *fp, long offset, int whence)
00711 {
00712 # if defined (ACE_WIN32)
00713 # if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END
00714
00715 switch (whence)
00716 {
00717 case SEEK_SET:
00718 whence = FILE_BEGIN;
00719 break;
00720 case SEEK_CUR:
00721 whence = FILE_CURRENT;
00722 break;
00723 case SEEK_END:
00724 whence = FILE_END;
00725 break;
00726 default:
00727 errno = EINVAL;
00728 return -1;
00729 }
00730 # endif
00731 # endif
00732 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fseek (fp, offset, whence), int, -1);
00733 }
00734
00735 ACE_INLINE int
00736 ACE_OS::fsetpos (FILE* fp, fpos_t* pos)
00737 {
00738 ACE_OSCALL_RETURN (::fsetpos (fp, pos), int, -1);
00739 }
00740
00741 ACE_INLINE long
00742 ACE_OS::ftell (FILE* fp)
00743 {
00744 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::ftell (fp), long, -1);
00745 }
00746
00747 ACE_INLINE size_t
00748 ACE_OS::fwrite (const void *ptr, size_t size, size_t nitems, FILE *fp)
00749 {
00750 ACE_OS_TRACE ("ACE_OS::fwrite");
00751 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fwrite (ptr, size, nitems, fp),
00752 size_t,
00753 0);
00754 }
00755
00756 ACE_INLINE void
00757 ACE_OS::perror (const char *s)
00758 {
00759 ACE_OS_TRACE ("ACE_OS::perror");
00760 #if defined (ACE_LACKS_PERROR)
00761 ACE_UNUSED_ARG (s);
00762 #else
00763 ::perror (s);
00764 #endif
00765 }
00766
00767 #if defined (ACE_HAS_WCHAR)
00768 ACE_INLINE void
00769 ACE_OS::perror (const wchar_t *s)
00770 {
00771 ACE_OS_TRACE ("ACE_OS::perror");
00772 #if defined (ACE_LACKS_PERROR)
00773 ACE_UNUSED_ARG (s);
00774 #elif defined (ACE_WIN32)
00775 ::_wperror (s);
00776 #else
00777 ACE_Wide_To_Ascii n_s (s);
00778 ::perror (n_s.char_rep ());
00779 #endif
00780 }
00781 #endif
00782
00783 ACE_INLINE int
00784 ACE_OS::puts (const char *s)
00785 {
00786 ACE_OS_TRACE ("ACE_OS::puts");
00787 ACE_OSCALL_RETURN (::puts (s), int, -1);
00788 }
00789
00790 #if defined (ACE_HAS_WCHAR)
00791 ACE_INLINE int
00792 ACE_OS::puts (const wchar_t *s)
00793 {
00794 ACE_OS_TRACE ("ACE_OS::puts");
00795 #if defined (ACE_WIN32)
00796 ACE_OSCALL_RETURN (::_putws (s), int, -1);
00797 #else
00798
00799 ACE_Wide_To_Ascii n_s (s);
00800 ACE_OSCALL_RETURN (::puts (n_s.char_rep ()), int, -1);
00801 #endif
00802 }
00803 #endif
00804
00805 ACE_INLINE int
00806 ACE_OS::rename (const char *old_name,
00807 const char *new_name,
00808 int flags)
00809 {
00810 # if defined (ACE_LACKS_RENAME)
00811 ACE_UNUSED_ARG (old_name);
00812 ACE_UNUSED_ARG (new_name);
00813 ACE_UNUSED_ARG (flags);
00814 ACE_NOTSUP_RETURN (-1);
00815 # elif defined (ACE_HAS_WINCE)
00816
00817 ACE_UNUSED_ARG (flags);
00818 if (0 == ::MoveFile (ACE_TEXT_CHAR_TO_TCHAR (old_name),
00819 ACE_TEXT_CHAR_TO_TCHAR (new_name)))
00820 ACE_FAIL_RETURN (-1);
00821 return 0;
00822 # elif defined (ACE_WIN32) && !defined (ACE_LACKS_WIN32_MOVEFILEEX)
00823
00824
00825
00826
00827 if (flags == -1)
00828 flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING;
00829 if (::MoveFileExA (old_name, new_name, flags) == 0)
00830 ACE_FAIL_RETURN (-1);
00831 return 0;
00832 # else
00833 ACE_UNUSED_ARG (flags);
00834 ACE_OSCALL_RETURN (::rename (old_name, new_name), int, -1);
00835 # endif
00836 }
00837
00838 #if defined (ACE_HAS_WCHAR)
00839 ACE_INLINE int
00840 ACE_OS::rename (const wchar_t *old_name,
00841 const wchar_t *new_name,
00842 int flags)
00843 {
00844 # if defined (ACE_LACKS_RENAME)
00845 ACE_UNUSED_ARG (old_name);
00846 ACE_UNUSED_ARG (new_name);
00847 ACE_UNUSED_ARG (flags);
00848 ACE_NOTSUP_RETURN (-1);
00849 # elif defined (ACE_HAS_WINCE)
00850 ACE_UNUSED_ARG (flags);
00851 if (::MoveFileW (old_name, new_name) == 0)
00852 ACE_FAIL_RETURN (-1);
00853 return 0;
00854 # elif defined (ACE_WIN32) && !defined (ACE_LACKS_WIN32_MOVEFILEEX)
00855
00856
00857
00858
00859 if (flags == -1)
00860 flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING;
00861 if (::MoveFileExW (old_name, new_name, flags) == 0)
00862 ACE_FAIL_RETURN (-1);
00863 return 0;
00864 # elif defined (ACE_WIN32)
00865 ACE_UNUSED_ARG (flags);
00866 ACE_OSCALL_RETURN (::_wrename (old_name, new_name), int, -1);
00867 # else
00868 ACE_Wide_To_Ascii nold_name (old_name);
00869 ACE_Wide_To_Ascii nnew_name (new_name);
00870 return ACE_OS::rename (nold_name.char_rep (), nnew_name.char_rep (), flags);
00871 # endif
00872 }
00873 #endif
00874
00875 ACE_INLINE void
00876 ACE_OS::rewind (FILE *fp)
00877 {
00878 #if !defined (ACE_HAS_WINCE)
00879 ACE_OS_TRACE ("ACE_OS::rewind");
00880 ::rewind (fp);
00881 #else
00882
00883
00884 (void) ::fseek (fp, 0L, SEEK_SET);
00885 #endif
00886 }
00887
00888 ACE_INLINE char *
00889 ACE_OS::tempnam (const char *dir, const char *pfx)
00890 {
00891 ACE_OS_TRACE ("ACE_OS::tempnam");
00892 #if defined (ACE_LACKS_TEMPNAM)
00893 ACE_UNUSED_ARG (dir);
00894 ACE_UNUSED_ARG (pfx);
00895 ACE_NOTSUP_RETURN (0);
00896 #elif defined (ACE_HAS_NONCONST_TEMPNAM)
00897 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::tempnam (const_cast <char *> (dir), const_cast<char *> (pfx)), char *, 0);
00898 #else
00899 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::tempnam (dir, pfx), char *, 0);
00900 #endif
00901 }
00902
00903 #if defined (ACE_HAS_WCHAR)
00904 ACE_INLINE wchar_t *
00905 ACE_OS::tempnam (const wchar_t *dir, const wchar_t *pfx)
00906 {
00907 ACE_OS_TRACE ("ACE_OS::tempnam");
00908 #if defined (ACE_LACKS_TEMPNAM)
00909 ACE_UNUSED_ARG (dir);
00910 ACE_UNUSED_ARG (pfx);
00911 ACE_NOTSUP_RETURN (0);
00912 #elif defined(ACE_WIN32)
00913 # if defined (ACE_HAS_NONCONST_TEMPNAM)
00914 ACE_OSCALL_RETURN (::_wtempnam (const_cast <wchar_t*> (dir), const_cast <wchar_t*> (pfx)), wchar_t *, 0);
00915 # else
00916 ACE_OSCALL_RETURN (::_wtempnam (dir, pfx), wchar_t *, 0);
00917 # endif
00918 #else
00919
00920 char *ndir = ACE_Wide_To_Ascii (dir).char_rep ();
00921 char *npfx = ACE_Wide_To_Ascii (pfx).char_rep ();
00922 char *name = ACE_OS::tempnam (ndir, npfx);
00923
00924
00925 wchar_t *wname = 0;
00926 if (name != 0)
00927 {
00928 size_t namelen = ACE_OS::strlen (name) + 1;
00929 wname = reinterpret_cast<wchar_t *>
00930 (ACE_OS::malloc (namelen * sizeof (wchar_t)));
00931 if (wname != 0)
00932 ACE_OS::strcpy (wname, ACE_Ascii_To_Wide (name).wchar_rep ());
00933 ACE_OS::free (name);
00934 }
00935 return wname;
00936 #endif
00937 }
00938 #endif
00939
00940 ACE_INLINE int
00941 ACE_OS::vasprintf (char **bufp, const char* format, va_list argptr)
00942 {
00943 #if defined (ACE_HAS_VASPRINTF)
00944 return ::vasprintf (bufp, format, argptr);
00945 #else
00946 return ACE_OS::vasprintf_emulation (bufp, format, argptr);
00947 #endif
00948 }
00949
00950 #if defined (ACE_HAS_WCHAR)
00951 ACE_INLINE int
00952 ACE_OS::vasprintf (wchar_t **bufp, const wchar_t* format, va_list argptr)
00953 {
00954 #if defined (ACE_HAS_VASWPRINTF)
00955 return ::vaswprintf (bufp, format, argptr);
00956 #else
00957 return ACE_OS::vaswprintf_emulation (bufp, format, argptr);
00958 #endif
00959 }
00960 #endif
00961
00962 ACE_INLINE int
00963 ACE_OS::vprintf (const char *format, va_list argptr)
00964 {
00965 return ::vprintf (format, argptr);
00966 }
00967
00968 #if defined (ACE_HAS_WCHAR)
00969 ACE_INLINE int
00970 ACE_OS::vprintf (const wchar_t *format, va_list argptr)
00971 {
00972 #if defined (ACE_HAS_VWPRINTF)
00973 return ::vwprintf (format, argptr);
00974 #else
00975 ACE_UNUSED_ARG (format);
00976 ACE_UNUSED_ARG (argptr);
00977 ACE_NOTSUP_RETURN (-1);
00978 #endif
00979 }
00980 #endif
00981
00982 ACE_INLINE int
00983 ACE_OS::vfprintf (FILE *fp, const char *format, va_list argptr)
00984 {
00985 return ACE_STD_NAMESPACE::vfprintf (fp, format, argptr);
00986 }
00987
00988 #if defined (ACE_HAS_WCHAR)
00989 ACE_INLINE int
00990 ACE_OS::vfprintf (FILE *fp, const wchar_t *format, va_list argptr)
00991 {
00992 #if defined (ACE_HAS_VFWPRINTF)
00993 return ::vfwprintf (fp, format, argptr);
00994 #else
00995 ACE_UNUSED_ARG (fp);
00996 ACE_UNUSED_ARG (format);
00997 ACE_UNUSED_ARG (argptr);
00998 ACE_NOTSUP_RETURN (-1);
00999 #endif
01000 }
01001 #endif
01002
01003 ACE_INLINE int
01004 ACE_OS::vsprintf (char *buffer, const char *format, va_list argptr)
01005 {
01006 return ::vsprintf (buffer, format, argptr);
01007 }
01008
01009 #if defined (ACE_HAS_WCHAR)
01010 ACE_INLINE int
01011 ACE_OS::vsprintf (wchar_t *buffer, const wchar_t *format, va_list argptr)
01012 {
01013 # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) || \
01014 (defined (sun) && !(defined(_XOPEN_SOURCE) && (_XOPEN_VERSION-0==4))) || \
01015 defined (ACE_HAS_DINKUM_STL) || defined (__DMC__) || \
01016 defined (ACE_HAS_VSWPRINTF) || \
01017 (defined (ACE_WIN32_VC10) && !defined (ACE_HAS_WINCE)) || \
01018 (defined (ACE_WIN32_VC9) && !defined (ACE_HAS_WINCE)) || \
01019 (defined (ACE_WIN32_VC8) && !defined (ACE_HAS_WINCE) && \
01020 _MSC_FULL_VER > 140050000)
01021
01022
01023
01024
01025
01026
01027 return vswprintf (buffer, 4096, format, argptr);
01028
01029 # elif defined (ACE_WIN32)
01030
01031
01032
01033 return vswprintf (buffer, format, argptr);
01034
01035 # else
01036 ACE_UNUSED_ARG (buffer);
01037 ACE_UNUSED_ARG (format);
01038 ACE_UNUSED_ARG (argptr);
01039 ACE_NOTSUP_RETURN (-1);
01040
01041 # endif
01042 }
01043 #endif
01044
01045 ACE_INLINE int
01046 ACE_OS::vsnprintf (char *buffer, size_t maxlen, const char *format, va_list ap)
01047 {
01048 #if !defined (ACE_LACKS_VSNPRINTF)
01049 int result;
01050 # if 0
01051
01052
01053
01054 result = _vsnprintf_s (buffer, maxlen, _TRUNCATE, format, ap);
01055 # elif !defined (ACE_WIN32)
01056 result = ::vsnprintf (buffer, maxlen, format, ap);
01057 # else
01058 result = ::_vsnprintf (buffer, maxlen, format, ap);
01059
01060
01061 if (result == static_cast<int> (maxlen) && maxlen > 0)
01062 buffer[maxlen-1] = '\0';
01063
01064
01065 if (result == -1 && maxlen > 0)
01066 buffer[maxlen-1] = '\0';
01067 # endif
01068
01069
01070
01071
01072
01073 if (result == -1)
01074 {
01075 result = static_cast <int> (maxlen + 1);
01076 }
01077
01078 return result;
01079 #elif defined (ACE_HAS_TRIO)
01080 return trio_vsnprintf (buffer, maxlen, format, ap);
01081 #else
01082 ACE_UNUSED_ARG (buffer);
01083 ACE_UNUSED_ARG (maxlen);
01084 ACE_UNUSED_ARG (format);
01085 ACE_UNUSED_ARG (ap);
01086 ACE_NOTSUP_RETURN (-1);
01087 #endif
01088 }
01089
01090 #if defined (ACE_HAS_WCHAR)
01091 ACE_INLINE int
01092 ACE_OS::vsnprintf (wchar_t *buffer, size_t maxlen, const wchar_t *format, va_list ap)
01093 {
01094 # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) || \
01095 (defined (sun) && !(defined(_XOPEN_SOURCE) && (_XOPEN_VERSION-0==4))) || \
01096 (defined (ACE_HAS_DINKUM_STL) || defined (__DMC__)) || \
01097 defined (ACE_HAS_VSWPRINTF) || \
01098 defined (ACE_WIN32)
01099
01100 int result;
01101
01102 # if defined (ACE_WIN32)
01103
01104
01105
01106 result = ::_vsnwprintf (buffer, maxlen, format, ap);
01107
01108
01109 if (result == static_cast<int> (maxlen) && maxlen > 0)
01110 buffer[maxlen-1] = '\0';
01111
01112
01113 if (result == -1 && maxlen > 0)
01114 buffer[maxlen-1] = '\0';
01115 # else
01116 result = vswprintf (buffer, maxlen, format, ap);
01117 #endif
01118
01119
01120
01121
01122
01123
01124 if (result == -1)
01125 result = static_cast <int> (maxlen + 1);
01126
01127 return result;
01128
01129 # else
01130
01131 ACE_UNUSED_ARG (buffer);
01132 ACE_UNUSED_ARG (maxlen);
01133 ACE_UNUSED_ARG (format);
01134 ACE_UNUSED_ARG (ap);
01135 ACE_NOTSUP_RETURN (-1);
01136
01137 # endif
01138 }
01139 #endif
01140
01141 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
01142 #if defined (ACE_WIN32)
01143 ACE_INLINE const ACE_TEXT_OSVERSIONINFO &
01144 ACE_OS::get_win32_versioninfo ()
01145 {
01146 return ACE_OS::win32_versioninfo_;
01147 }
01148
01149 ACE_INLINE HINSTANCE
01150 ACE_OS::get_win32_resource_module ()
01151 {
01152 return ACE_OS::win32_resource_module_;
01153 }
01154
01155 ACE_INLINE void
01156 ACE_OS::set_win32_resource_module (HINSTANCE instance)
01157 {
01158 ACE_OS::win32_resource_module_ = instance;
01159 }
01160
01161 ACE_INLINE LPSECURITY_ATTRIBUTES
01162 ACE_OS::default_win32_security_attributes (LPSECURITY_ATTRIBUTES sa)
01163 {
01164 #if defined (ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES)
01165 if (sa == 0)
01166 {
01167
01168 static SECURITY_ATTRIBUTES default_sa;
01169 static SECURITY_DESCRIPTOR sd;
01170 InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
01171 SetSecurityDescriptorDacl(&sd, TRUE, 0, FALSE);
01172 default_sa.nLength = sizeof(SECURITY_ATTRIBUTES);
01173 default_sa.lpSecurityDescriptor = &sd;
01174 default_sa.bInheritHandle = TRUE;
01175 sa = &default_sa;
01176 }
01177 return sa;
01178 #else
01179 return sa;
01180 #endif
01181 }
01182
01183 ACE_INLINE LPSECURITY_ATTRIBUTES
01184 ACE_OS::default_win32_security_attributes_r (LPSECURITY_ATTRIBUTES sa,
01185 LPSECURITY_ATTRIBUTES sa_buffer,
01186 SECURITY_DESCRIPTOR* sd_buffer)
01187 {
01188 #if defined (ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES)
01189 if (sa == 0)
01190 {
01191 if (sa_buffer != 0 && sd_buffer != 0)
01192 {
01193 InitializeSecurityDescriptor
01194 (sd_buffer, SECURITY_DESCRIPTOR_REVISION);
01195 SetSecurityDescriptorDacl (sd_buffer, TRUE, 0, FALSE);
01196 sa_buffer->nLength = sizeof(SECURITY_ATTRIBUTES);
01197 sa_buffer->lpSecurityDescriptor = sd_buffer;
01198 sa_buffer->bInheritHandle = TRUE;
01199 sa = sa_buffer;
01200 }
01201 }
01202 return sa;
01203 #else
01204 ACE_UNUSED_ARG(sa_buffer);
01205 ACE_UNUSED_ARG(sd_buffer);
01206 return sa;
01207 #endif
01208 }
01209
01210 #endif
01211 #endif
01212
01213 ACE_END_VERSIONED_NAMESPACE_DECL