OS_NS_stdio.inl

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // $Id: OS_NS_stdio.inl 78957 2007-07-19 20:00:23Z mitza $
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 /* ACE_HAS_TRIO */
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 /* ACE_LACKS_WIN32_SETFILEPOINTEREX */
00060 
00061 # if defined (_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
00062         start += offset.QuadPart;
00063 # else
00064         start += offset.LowPart;
00065 # endif /* _FILE_OFFSET_BITS == 64 */
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 /* ACE_WIN32 */
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   // Once initialized, these values are never changed.
00098   lock->overlapped_.Internal = 0;
00099   lock->overlapped_.InternalHigh = 0;
00100   lock->overlapped_.OffsetHigh = 0;
00101   lock->overlapped_.hEvent = 0;
00102 #endif /* ACE_WIN32 */
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;   // Unlock file.
00149 
00150   // release lock
00151   ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLK,
00152                                     reinterpret_cast<long> (&lock->lock_)),
00153                      int, -1);
00154 #endif /* ACE_WIN32 */
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       // Close the handle.
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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;         // set read lock
00219   // block, if no access
00220   ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW,
00221                                     reinterpret_cast<long> (&lock->lock_)),
00222                      int, -1);
00223 #endif /* ACE_WIN32 */
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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;         // set read lock
00264 
00265   int result = 0;
00266   // Does not block, if no access, returns -1 and set errno = EBUSY;
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 /* ACE_WIN32 */
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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;         // set write lock
00316 
00317   int result = 0;
00318   // Does not block, if no access, returns -1 and set errno = EBUSY;
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 /* ACE_WIN32 */
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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 /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */
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;         // set write lock
00371   // block, if no access
00372   ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW,
00373                                     reinterpret_cast<long> (&lock->lock_)),
00374                      int, -1);
00375 #endif /* ACE_WIN32 */
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 /* !ACE_LACKS_CLEARERR */
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       // Require that the user field be non-null, i.e., don't
00396       // allocate or use static storage.
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  /* ACE_LACKS_PWD_FUNCTIONS */
00418 
00419   // POSIX.1 dropped the cuserid() function.
00420   // GNU GLIBC and other platforms correctly deprecate the cuserid()
00421   // function.
00422 
00423   if (maxlen == 0)
00424     {
00425       // It doesn't make sense to have a zero length user ID.
00426       errno = EINVAL;
00427       return 0;
00428     }
00429 
00430   struct passwd *pw = 0;
00431 
00432   // Make sure the file pointer is at the beginning of the password file
00433   ::setpwent ();
00434   // Should use ACE_OS::setpwent() but I didn't want to move this
00435   // method after it.
00436 
00437   // Use the effective user ID to determine the user name.
00438   pw = ::getpwuid (::geteuid ());
00439 
00440   // Make sure the password file is closed.
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       // Not reentrant/thread-safe, but nothing else can be done if a
00455       // zero pointer was passed in as the destination.
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;  // 8 character user ID + NULL
00461 #endif  /* _POSIX_SOURCE */
00462 
00463       static char tmp[ACE_L_cuserid] = { '\0' };
00464       max_length = ACE_L_cuserid - 1; // Do not include NULL in length
00465 
00466       userid = tmp;
00467     }
00468   else
00469     {
00470       max_length = maxlen;
00471       userid = user;
00472     }
00473 
00474   // Extract the user name from the passwd structure.
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;  // Buffer is not large enough.
00482       return 0;
00483     }
00484 #else
00485   // Hackish because of missing buffer size!
00486   ACE_UNUSED_ARG (maxlen);
00487   ACE_OSCALL_RETURN (::ace_cuserid(user), char*, 0);
00488 #endif /* ACE_VXWORKS */
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 /* ACE_WIN32 */
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 /* ACE_WIN32 */
00521 }
00522 #endif /* ACE_HAS_WCHAR  */
00523 #endif /* ACE_LACKS_CUSERID */
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   // kernel file handle -> FILE* conversion...
00542   // Options: _O_APPEND, _O_RDONLY and _O_TEXT are lost
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 /* __BORLANDC__ */
00559 
00560       if (!file)
00561         {
00562 #   if defined(__BORLANDC__)
00563           ::_rtl_close (crt_handle);
00564 #   else
00565           ::_close (crt_handle);
00566 #   endif /* defined(__BORLANDC__) */
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 /* ACE_HAS_WINCE */
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       // Do not allow fflush(0) on VxWorks
00589       return 0;
00590     }
00591 #endif /* ACE_VXWORKS */
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 /* ACE_HAS_WCHAR && !ACE_LACKS_FGETWS */
00629 
00630 #if !(defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
00631 // Win32 PC implementation of fopen () is in OS_NS_stdio.cpp.
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   // Non-Windows doesn't use wchar_t file systems.
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 /* ACE_HAS_WINCE */
00654 }
00655 #endif /* ACE_HAS_WCHAR */
00656 
00657 #endif /* ACE_WIN32 */
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 /* ACE_HAS_WCHAR && !ACE_LACKS_FPUTWS */
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 /* ACE_WIN32 && ACE_USES_WCHAR */
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   //#error Windows NT is evil AND rude!
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; // rather safe than sorry
00740     }
00741 #   endif  /* SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END */
00742 # endif   /* ACE_WIN32 */
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 /* ACE_HAS_WINCE */
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 /* ACE_HAS_WINCE */
00791 }
00792 #endif /* ACE_HAS_WCHAR */
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 /* ACE_WIN32 */
00809   // There's no putws()...
00810   ACE_Wide_To_Ascii n_s (s);
00811   ACE_OSCALL_RETURN (::puts (n_s.char_rep ()), int, -1);
00812 #endif /* ACE_WIN32 */
00813 }
00814 #endif /* ACE_HAS_WCHAR */
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   // Win CE is always wide-char.
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   // NT4 (and up) provides a way to rename/move a file with similar semantics
00835   // to what's usually done on UNIX - if there's an existing file with
00836   // <new_name> it is removed before the file is renamed/moved. The
00837   // MOVEFILE_COPY_ALLOWED is specified to allow such a rename across drives.
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 /* ACE_LACKS_RENAME */
00844   ACE_UNUSED_ARG (flags);
00845   ACE_OSCALL_RETURN (::rename (old_name, new_name), int, -1);
00846 # endif /* ACE_LACKS_RENAME */
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   // NT4 (and up) provides a way to rename/move a file with similar semantics
00867   // to what's usually done on UNIX - if there's an existing file with
00868   // <new_name> it is removed before the file is renamed/moved. The
00869   // MOVEFILE_COPY_ALLOWED is specified to allow such a rename across drives.
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 /* ACE_LACKS_RENAME */
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 /* ACE_LACKS_RENAME */
00883 }
00884 #endif /* ACE_HAS_WCHAR */
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   // This isn't perfect since it doesn't reset EOF, but it's probably
00894   // the closest we can get on WINCE.
00895   (void) fseek (fp, 0L, SEEK_SET);
00896 #endif /* ACE_HAS_WINCE */
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 /* ACE_LACKS_TEMPNAM */
00910   ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::tempnam (dir, pfx), char *, 0);
00911 #endif /* ACE_LACKS_TEMPNAM */
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 /* __BORLANDC__ */
00929 #else /* ACE_LACKS_TEMPNAM */
00930   // No native wide-char support; convert to narrow and call the char* variant.
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   // ACE_OS::tempnam returns a pointer to a malloc()-allocated space.
00935   // Convert that string to wide-char and free() the original.
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 /* ACE_LACKS_TEMPNAM */
00948 }
00949 #endif /* ACE_HAS_WCHAR */
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 /* defined (ACE_HAS_TR24731_2005_CRT) */
00963   // _vsnprintf_s() doesn't report the length needed when it truncates. This
00964   // info is needed and relied on by others things in ACE+TAO, so don't use
00965   // this. There's adequate protection via the maxlen.
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   // Win32 doesn't regard a full buffer with no 0-terminate as an overrun.
00973   if (result == static_cast<int> (maxlen))
00974     buffer[maxlen-1] = '\0';
00975 
00976   // Win32 doesn't 0-terminate the string if it overruns maxlen.
00977   if (result == -1)
00978     buffer[maxlen-1] = '\0';
00979 # endif
00980   // In out-of-range conditions, C99 defines vsnprintf() to return the number
00981   // of characters that would have been written if enough space was available.
00982   // Earlier variants of the vsnprintf() (e.g. UNIX98) defined it to return
00983   // -1. This method follows the C99 standard, but needs to guess at the
00984   // value; uses maxlen + 1.
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 /* ACE_LACKS_VSNPRINTF */
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   // The XPG4/UNIX98/C99 signature of the wide-char sprintf has a
01014   // maxlen argument. Since this method doesn't supply one, pass in
01015   // a length that works (ULONG_MAX doesn't on all platform since some check
01016   // to see if the operation will remain in bounds). If this isn't ok, use
01017   // ACE_OS::snprintf().
01018   return vswprintf (buffer, 4096, format, argptr);
01019 
01020 # elif defined (ACE_WIN32)
01021   // Windows has vswprintf, but the pre-VC8 signature is from the older
01022   // ISO C standard. Also see ACE_OS::snprintf() for more info on this.
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 /* XPG5 || ACE_HAS_DINKUM_STL */
01033 }
01034 #endif /* ACE_HAS_WCHAR */
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   // Win32 doesn't regard a full buffer with no 0-terminate as an
01056 // overrun.
01057   if (result == static_cast<int> (maxlen))
01058     result = -1;
01059 
01060   // Win32 doesn't 0-terminate the string if it overruns maxlen.
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 /* platforms with a variant of vswprintf */
01075 }
01076 #endif /* ACE_HAS_WCHAR */
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       // @@ This is a good place to use pthread_once.
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 /* !ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES */
01116   return sa;
01117 #endif /* ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES */
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 /* !ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES */
01141   ACE_UNUSED_ARG(sa_buffer);
01142   ACE_UNUSED_ARG(sd_buffer);
01143   return sa;
01144 #endif /* ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES */
01145 }
01146 
01147 #endif /* ACE_WIN32 */
01148 #endif
01149 
01150 ACE_END_VERSIONED_NAMESPACE_DECL

Generated on Sun Jan 27 12:05:33 2008 for ACE by doxygen 1.3.6