ACE: OS_NS_fcntl.cpp Source File

00001 // OS_NS_fcntl.cpp,v 1.9 2006/05/05 07:54:01 jwillemsen Exp
00002 
00003 #include "ace/OS_NS_fcntl.h"
00004 
00005 ACE_RCSID(ace, OS_NS_fcntl, "OS_NS_fcntl.cpp,v 1.9 2006/05/05 07:54:01 jwillemsen Exp")
00006 
00007 #if !defined (ACE_HAS_INLINED_OSCALLS)
00008 # include "ace/OS_NS_fcntl.inl"
00009 #endif /* ACE_HAS_INLINED_OS_CALLS */
00010 
00011 #include "ace/OS_NS_stdio.h"
00012 #include "ace/OS_NS_Thread.h"
00013 #include "ace/OS_NS_macros.h"
00014 #include "ace/Object_Manager_Base.h"
00015 
00016 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00017 
00018 ACE_HANDLE
00019 ACE_OS::open (const char *filename,
00020               int mode,
00021               int perms,
00022               LPSECURITY_ATTRIBUTES sa)
00023 {
00024   ACE_OS_TRACE ("ACE_OS::open");
00025 
00026 #if defined (ACE_WIN32)
00027   DWORD access = GENERIC_READ;
00028   if (ACE_BIT_ENABLED (mode, O_WRONLY))
00029     access = GENERIC_WRITE;
00030   else if (ACE_BIT_ENABLED (mode, O_RDWR))
00031     access = GENERIC_READ | GENERIC_WRITE;
00032 
00033   DWORD creation = OPEN_EXISTING;
00034 
00035   if ((mode & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
00036     creation = CREATE_NEW;
00037   else if ((mode & (_O_CREAT | _O_TRUNC)) == (_O_CREAT | _O_TRUNC))
00038     creation = CREATE_ALWAYS;
00039   else if (ACE_BIT_ENABLED (mode, _O_CREAT))
00040     creation = OPEN_ALWAYS;
00041   else if (ACE_BIT_ENABLED (mode, _O_TRUNC))
00042     creation = TRUNCATE_EXISTING;
00043 
00044   DWORD flags = 0;
00045 
00046   if (ACE_BIT_ENABLED (mode, _O_TEMPORARY))
00047     flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
00048 
00049   if (ACE_BIT_ENABLED (mode, FILE_FLAG_WRITE_THROUGH))
00050     flags |= FILE_FLAG_WRITE_THROUGH;
00051   if (ACE_BIT_ENABLED (mode, FILE_FLAG_OVERLAPPED))
00052     flags |= FILE_FLAG_OVERLAPPED;
00053   if (ACE_BIT_ENABLED (mode, FILE_FLAG_NO_BUFFERING))
00054     flags |= FILE_FLAG_NO_BUFFERING;
00055   if (ACE_BIT_ENABLED (mode, FILE_FLAG_RANDOM_ACCESS))
00056     flags |= FILE_FLAG_RANDOM_ACCESS;
00057   if (ACE_BIT_ENABLED (mode, FILE_FLAG_SEQUENTIAL_SCAN))
00058     flags |= FILE_FLAG_SEQUENTIAL_SCAN;
00059   if (ACE_BIT_ENABLED (mode, FILE_FLAG_DELETE_ON_CLOSE))
00060     flags |= FILE_FLAG_DELETE_ON_CLOSE;
00061   if (ACE_BIT_ENABLED (mode, FILE_FLAG_BACKUP_SEMANTICS))
00062     flags |= FILE_FLAG_BACKUP_SEMANTICS;
00063   if (ACE_BIT_ENABLED (mode, FILE_FLAG_POSIX_SEMANTICS))
00064     flags |= FILE_FLAG_POSIX_SEMANTICS;
00065 
00066   ACE_MT (ACE_thread_mutex_t *ace_os_monitor_lock = 0;)
00067 
00068   if (ACE_BIT_ENABLED (mode, _O_APPEND))
00069     {
00070       ACE_MT
00071         (
00072           ace_os_monitor_lock = static_cast <ACE_thread_mutex_t *> (
00073             ACE_OS_Object_Manager::preallocated_object[
00074               ACE_OS_Object_Manager::ACE_OS_MONITOR_LOCK]);
00075           ACE_OS::thread_mutex_lock (ace_os_monitor_lock);
00076         )
00077     }
00078 
00079   DWORD shared_mode = perms;
00080   SECURITY_ATTRIBUTES sa_buffer;
00081   SECURITY_DESCRIPTOR sd_buffer;
00082 
00083 #if defined (ACE_HAS_WINCE)
00084   ACE_HANDLE h = ::CreateFileW (ACE_Ascii_To_Wide (filename).wchar_rep (),
00085                                 access,
00086                                 shared_mode,
00087                                 ACE_OS::default_win32_security_attributes_r
00088                                   (sa, &sa_buffer, &sd_buffer),
00089                                 creation,
00090                                 flags,
00091                                 0);
00092 #else /* ACE_HAS_WINCE */
00093   ACE_HANDLE h = ::CreateFileA (filename,
00094                                 access,
00095                                 shared_mode,
00096                                 ACE_OS::default_win32_security_attributes_r
00097                                   (sa, &sa_buffer, &sd_buffer),
00098                                 creation,
00099                                 flags,
00100                                 0);
00101 #endif /* ACE_HAS_WINCE */
00102 
00103   if (ACE_BIT_ENABLED (mode, _O_APPEND))
00104     {
00105       if (h != ACE_INVALID_HANDLE)
00106         {
00107           ::SetFilePointer (h, 0, 0, FILE_END);
00108         }
00109 
00110       ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
00111     }
00112 
00113   if (h == ACE_INVALID_HANDLE)
00114     ACE_FAIL_RETURN (h);
00115   else
00116     return h;
00117 #elif defined (INTEGRITY)
00118   ACE_UNUSED_ARG (sa);
00119   if(!strcmp(filename,ACE_DEV_NULL)) {
00120       ACE_OSCALL_RETURN (::AllocateNullConsoleDescriptor(), ACE_HANDLE, -1);
00121   }
00122   else {
00123       ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, -1);
00124   }
00125 #else
00126   ACE_UNUSED_ARG (sa);
00127   ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, ACE_INVALID_HANDLE);
00128 #endif /* ACE_WIN32 */
00129 }
00130 
00131 #if defined (ACE_HAS_WCHAR)
00132 ACE_HANDLE
00133 ACE_OS::open (const wchar_t *filename,
00134               int mode,
00135               int perms,
00136               LPSECURITY_ATTRIBUTES sa)
00137 {
00138 #if defined (ACE_WIN32)
00139   // @@ (brunsch) Yuck, maybe there is a way to combine the code
00140   // here with the char version
00141 
00142   DWORD access = GENERIC_READ;
00143   if (ACE_BIT_ENABLED (mode, O_WRONLY))
00144     access = GENERIC_WRITE;
00145   else if (ACE_BIT_ENABLED (mode, O_RDWR))
00146     access = GENERIC_READ | GENERIC_WRITE;
00147 
00148   DWORD creation = OPEN_EXISTING;
00149 
00150   if ((mode & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
00151     creation = CREATE_NEW;
00152   else if ((mode & (_O_CREAT | _O_TRUNC)) == (_O_CREAT | _O_TRUNC))
00153     creation = CREATE_ALWAYS;
00154   else if (ACE_BIT_ENABLED (mode, _O_CREAT))
00155     creation = OPEN_ALWAYS;
00156   else if (ACE_BIT_ENABLED (mode, _O_TRUNC))
00157     creation = TRUNCATE_EXISTING;
00158 
00159   DWORD flags = 0;
00160 
00161   if (ACE_BIT_ENABLED (mode, _O_TEMPORARY))
00162     flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
00163 
00164   if (ACE_BIT_ENABLED (mode, FILE_FLAG_WRITE_THROUGH))
00165     flags |= FILE_FLAG_WRITE_THROUGH;
00166   if (ACE_BIT_ENABLED (mode, FILE_FLAG_OVERLAPPED))
00167     flags |= FILE_FLAG_OVERLAPPED;
00168   if (ACE_BIT_ENABLED (mode, FILE_FLAG_NO_BUFFERING))
00169     flags |= FILE_FLAG_NO_BUFFERING;
00170   if (ACE_BIT_ENABLED (mode, FILE_FLAG_RANDOM_ACCESS))
00171     flags |= FILE_FLAG_RANDOM_ACCESS;
00172   if (ACE_BIT_ENABLED (mode, FILE_FLAG_SEQUENTIAL_SCAN))
00173     flags |= FILE_FLAG_SEQUENTIAL_SCAN;
00174   if (ACE_BIT_ENABLED (mode, FILE_FLAG_DELETE_ON_CLOSE))
00175     flags |= FILE_FLAG_DELETE_ON_CLOSE;
00176   if (ACE_BIT_ENABLED (mode, FILE_FLAG_BACKUP_SEMANTICS))
00177     flags |= FILE_FLAG_BACKUP_SEMANTICS;
00178   if (ACE_BIT_ENABLED (mode, FILE_FLAG_POSIX_SEMANTICS))
00179     flags |= FILE_FLAG_POSIX_SEMANTICS;
00180 
00181   ACE_MT (ACE_thread_mutex_t *ace_os_monitor_lock = 0;)
00182 
00183   if (ACE_BIT_ENABLED (mode, _O_APPEND))
00184     {
00185       ACE_MT
00186         (
00187           ace_os_monitor_lock = static_cast <ACE_thread_mutex_t *> (
00188             ACE_OS_Object_Manager::preallocated_object[
00189               ACE_OS_Object_Manager::ACE_OS_MONITOR_LOCK]);
00190           ACE_OS::thread_mutex_lock (ace_os_monitor_lock);
00191         )
00192     }
00193 
00194   DWORD shared_mode = perms;
00195   SECURITY_ATTRIBUTES sa_buffer;
00196   SECURITY_DESCRIPTOR sd_buffer;
00197 
00198   ACE_HANDLE h = ::CreateFileW (filename,
00199                                 access,
00200                                 shared_mode,
00201                                 ACE_OS::default_win32_security_attributes_r
00202                                   (sa, &sa_buffer, &sd_buffer),
00203                                 creation,
00204                                 flags,
00205                                 0);
00206 
00207   if (ACE_BIT_ENABLED (mode, _O_APPEND))
00208     {
00209       if (h != ACE_INVALID_HANDLE)
00210         {
00211           ::SetFilePointer (h, 0, 0, FILE_END);
00212         }
00213 
00214       ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
00215     }
00216 
00217   if (h == ACE_INVALID_HANDLE)
00218     ACE_FAIL_RETURN (h);
00219   else
00220     return h;
00221 #else /* ACE_WIN32 */
00222   // Just emulate with ascii version
00223   return ACE_OS::open (ACE_Wide_To_Ascii (filename).char_rep (),
00224                        mode,
00225                        perms,
00226                        sa);
00227 #endif /* ACE_WIN32 */
00228 }
00229 #endif /* ACE_HAS_WCHAR */
00230 
00231 ACE_END_VERSIONED_NAMESPACE_DECL