ACE: OS_NS_fcntl.cpp Source File

00001 // $Id: OS_NS_fcntl.cpp 80826 2008-03-04 14:51:23Z wotte $
00002 
00003 #include "ace/OS_NS_fcntl.h"
00004 
00005 ACE_RCSID(ace, OS_NS_fcntl, "$Id: OS_NS_fcntl.cpp 80826 2008-03-04 14:51:23Z wotte $")
00006 
00007 #if !defined (ACE_HAS_INLINED_OSCALLS)
00008 # include "ace/OS_NS_fcntl.inl"
00009 #endif /* ACE_HAS_INLINED_OSCALLS */
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               mode_t 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       LONG high_size = 0;
00106       if (h != ACE_INVALID_HANDLE
00107           && ::SetFilePointer (h,
00108                                0,
00109                                &high_size,
00110                                FILE_END) == INVALID_SET_FILE_POINTER
00111           && GetLastError () != NO_ERROR)
00112         {
00113           ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
00114           ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
00115         }
00116 
00117       ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
00118     }
00119 
00120   if (h == ACE_INVALID_HANDLE)
00121     ACE_FAIL_RETURN (h);
00122   else
00123     return h;
00124 #elif defined (INTEGRITY)
00125   ACE_UNUSED_ARG (sa);
00126   if(!strcmp(filename,ACE_DEV_NULL)) {
00127       ACE_OSCALL_RETURN (::AllocateNullConsoleDescriptor(), ACE_HANDLE, -1);
00128   }
00129   else {
00130       ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, -1);
00131   }
00132 #else
00133   ACE_UNUSED_ARG (sa);
00134   ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, ACE_INVALID_HANDLE);
00135 #endif /* ACE_WIN32 */
00136 }
00137 
00138 #if defined (ACE_HAS_WCHAR)
00139 ACE_HANDLE
00140 ACE_OS::open (const wchar_t *filename,
00141               int mode,
00142               mode_t perms,
00143               LPSECURITY_ATTRIBUTES sa)
00144 {
00145 #if defined (ACE_WIN32)
00146   // @@ (brunsch) Yuck, maybe there is a way to combine the code
00147   // here with the char version
00148 
00149   DWORD access = GENERIC_READ;
00150   if (ACE_BIT_ENABLED (mode, O_WRONLY))
00151     access = GENERIC_WRITE;
00152   else if (ACE_BIT_ENABLED (mode, O_RDWR))
00153     access = GENERIC_READ | GENERIC_WRITE;
00154 
00155   DWORD creation = OPEN_EXISTING;
00156 
00157   if ((mode & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
00158     creation = CREATE_NEW;
00159   else if ((mode & (_O_CREAT | _O_TRUNC)) == (_O_CREAT | _O_TRUNC))
00160     creation = CREATE_ALWAYS;
00161   else if (ACE_BIT_ENABLED (mode, _O_CREAT))
00162     creation = OPEN_ALWAYS;
00163   else if (ACE_BIT_ENABLED (mode, _O_TRUNC))
00164     creation = TRUNCATE_EXISTING;
00165 
00166   DWORD flags = 0;
00167 
00168   if (ACE_BIT_ENABLED (mode, _O_TEMPORARY))
00169     flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
00170 
00171   if (ACE_BIT_ENABLED (mode, FILE_FLAG_WRITE_THROUGH))
00172     flags |= FILE_FLAG_WRITE_THROUGH;
00173   if (ACE_BIT_ENABLED (mode, FILE_FLAG_OVERLAPPED))
00174     flags |= FILE_FLAG_OVERLAPPED;
00175   if (ACE_BIT_ENABLED (mode, FILE_FLAG_NO_BUFFERING))
00176     flags |= FILE_FLAG_NO_BUFFERING;
00177   if (ACE_BIT_ENABLED (mode, FILE_FLAG_RANDOM_ACCESS))
00178     flags |= FILE_FLAG_RANDOM_ACCESS;
00179   if (ACE_BIT_ENABLED (mode, FILE_FLAG_SEQUENTIAL_SCAN))
00180     flags |= FILE_FLAG_SEQUENTIAL_SCAN;
00181   if (ACE_BIT_ENABLED (mode, FILE_FLAG_DELETE_ON_CLOSE))
00182     flags |= FILE_FLAG_DELETE_ON_CLOSE;
00183   if (ACE_BIT_ENABLED (mode, FILE_FLAG_BACKUP_SEMANTICS))
00184     flags |= FILE_FLAG_BACKUP_SEMANTICS;
00185   if (ACE_BIT_ENABLED (mode, FILE_FLAG_POSIX_SEMANTICS))
00186     flags |= FILE_FLAG_POSIX_SEMANTICS;
00187 
00188   ACE_MT (ACE_thread_mutex_t *ace_os_monitor_lock = 0;)
00189 
00190   if (ACE_BIT_ENABLED (mode, _O_APPEND))
00191     {
00192       ACE_MT
00193         (
00194           ace_os_monitor_lock = static_cast <ACE_thread_mutex_t *> (
00195             ACE_OS_Object_Manager::preallocated_object[
00196               ACE_OS_Object_Manager::ACE_OS_MONITOR_LOCK]);
00197           ACE_OS::thread_mutex_lock (ace_os_monitor_lock);
00198         )
00199     }
00200 
00201   DWORD shared_mode = perms;
00202   SECURITY_ATTRIBUTES sa_buffer;
00203   SECURITY_DESCRIPTOR sd_buffer;
00204 
00205   ACE_HANDLE h = ::CreateFileW (filename,
00206                                 access,
00207                                 shared_mode,
00208                                 ACE_OS::default_win32_security_attributes_r
00209                                   (sa, &sa_buffer, &sd_buffer),
00210                                 creation,
00211                                 flags,
00212                                 0);
00213 
00214   if (ACE_BIT_ENABLED (mode, _O_APPEND))
00215     {
00216       LONG high_size = 0;
00217       if (h != ACE_INVALID_HANDLE
00218           && ::SetFilePointer (h,
00219                                0,
00220                                &high_size,
00221                                FILE_END) == INVALID_SET_FILE_POINTER
00222           && GetLastError () != NO_ERROR)
00223         {
00224           ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
00225           ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
00226         }
00227 
00228       ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
00229     }
00230 
00231   if (h == ACE_INVALID_HANDLE)
00232     ACE_FAIL_RETURN (h);
00233   else
00234     return h;
00235 #else /* ACE_WIN32 */
00236   // Just emulate with ascii version
00237   return ACE_OS::open (ACE_Wide_To_Ascii (filename).char_rep (),
00238                        mode,
00239                        perms,
00240                        sa);
00241 #endif /* ACE_WIN32 */
00242 }
00243 #endif /* ACE_HAS_WCHAR */
00244 
00245 ACE_END_VERSIONED_NAMESPACE_DECL