dep/ACE_wrappers/ace/OS_NS_fcntl.cpp

   1 // $Id: OS_NS_fcntl.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/OS_NS_fcntl.h"
   4
   5 ACE_RCSID(ace, OS_NS_fcntl, "$Id: OS_NS_fcntl.cpp 80826 2008-03-04 14:51:23Z wotte $")
   6
   7 #if !defined (ACE_HAS_INLINED_OSCALLS)
   8 # include "ace/OS_NS_fcntl.inl"
   9 #endif /* ACE_HAS_INLINED_OSCALLS */
  10
  11 #include "ace/OS_NS_stdio.h"
  12 #include "ace/OS_NS_Thread.h"
  13 #include "ace/OS_NS_macros.h"
  14 #include "ace/Object_Manager_Base.h"
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 ACE_HANDLE
  19 ACE_OS::open (const char *filename,
  20               int mode,
  21               mode_t perms,
  22               LPSECURITY_ATTRIBUTES sa)
  23 {
  24   ACE_OS_TRACE ("ACE_OS::open");
  25
  26 #if defined (ACE_WIN32)
  27   DWORD access = GENERIC_READ;
  28   if (ACE_BIT_ENABLED (mode, O_WRONLY))
  29     access = GENERIC_WRITE;
  30   else if (ACE_BIT_ENABLED (mode, O_RDWR))
  31     access = GENERIC_READ | GENERIC_WRITE;
  32
  33   DWORD creation = OPEN_EXISTING;
  34
  35   if ((mode & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
  36     creation = CREATE_NEW;
  37   else if ((mode & (_O_CREAT | _O_TRUNC)) == (_O_CREAT | _O_TRUNC))
  38     creation = CREATE_ALWAYS;
  39   else if (ACE_BIT_ENABLED (mode, _O_CREAT))
  40     creation = OPEN_ALWAYS;
  41   else if (ACE_BIT_ENABLED (mode, _O_TRUNC))
  42     creation = TRUNCATE_EXISTING;
  43
  44   DWORD flags = 0;
  45
  46   if (ACE_BIT_ENABLED (mode, _O_TEMPORARY))
  47     flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
  48
  49   if (ACE_BIT_ENABLED (mode, FILE_FLAG_WRITE_THROUGH))
  50     flags |= FILE_FLAG_WRITE_THROUGH;
  51   if (ACE_BIT_ENABLED (mode, FILE_FLAG_OVERLAPPED))
  52     flags |= FILE_FLAG_OVERLAPPED;
  53   if (ACE_BIT_ENABLED (mode, FILE_FLAG_NO_BUFFERING))
  54     flags |= FILE_FLAG_NO_BUFFERING;
  55   if (ACE_BIT_ENABLED (mode, FILE_FLAG_RANDOM_ACCESS))
  56     flags |= FILE_FLAG_RANDOM_ACCESS;
  57   if (ACE_BIT_ENABLED (mode, FILE_FLAG_SEQUENTIAL_SCAN))
  58     flags |= FILE_FLAG_SEQUENTIAL_SCAN;
  59   if (ACE_BIT_ENABLED (mode, FILE_FLAG_DELETE_ON_CLOSE))
  60     flags |= FILE_FLAG_DELETE_ON_CLOSE;
  61   if (ACE_BIT_ENABLED (mode, FILE_FLAG_BACKUP_SEMANTICS))
  62     flags |= FILE_FLAG_BACKUP_SEMANTICS;
  63   if (ACE_BIT_ENABLED (mode, FILE_FLAG_POSIX_SEMANTICS))
  64     flags |= FILE_FLAG_POSIX_SEMANTICS;
  65
  66   ACE_MT (ACE_thread_mutex_t *ace_os_monitor_lock = 0;)
  67
  68   if (ACE_BIT_ENABLED (mode, _O_APPEND))
  69     {
  70       ACE_MT
  71         (
  72           ace_os_monitor_lock = static_cast <ACE_thread_mutex_t *> (
  73             ACE_OS_Object_Manager::preallocated_object[
  74               ACE_OS_Object_Manager::ACE_OS_MONITOR_LOCK]);
  75           ACE_OS::thread_mutex_lock (ace_os_monitor_lock);
  76         )
  77     }
  78
  79   DWORD shared_mode = perms;
  80   SECURITY_ATTRIBUTES sa_buffer;
  81   SECURITY_DESCRIPTOR sd_buffer;
  82
  83 #if defined (ACE_HAS_WINCE)
  84   ACE_HANDLE h = ::CreateFileW (ACE_Ascii_To_Wide (filename).wchar_rep (),
  85                                 access,
  86                                 shared_mode,
  87                                 ACE_OS::default_win32_security_attributes_r
  88                                   (sa, &sa_buffer, &sd_buffer),
  89                                 creation,
  90                                 flags,
  91                                 0);
  92 #else /* ACE_HAS_WINCE */
  93   ACE_HANDLE h = ::CreateFileA (filename,
  94                                 access,
  95                                 shared_mode,
  96                                 ACE_OS::default_win32_security_attributes_r
  97                                   (sa, &sa_buffer, &sd_buffer),
  98                                 creation,
  99                                 flags,
 100                                 0);
 101 #endif /* ACE_HAS_WINCE */
 102
 103   if (ACE_BIT_ENABLED (mode, _O_APPEND))
 104     {
 105       LONG high_size = 0;
 106       if (h != ACE_INVALID_HANDLE
 107           && ::SetFilePointer (h,
 108                                0,
 109                                &high_size,
 110                                FILE_END) == INVALID_SET_FILE_POINTER
 111           && GetLastError () != NO_ERROR)
 112         {
 113           ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
 114           ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
 115         }
 116
 117       ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
 118     }
 119
 120   if (h == ACE_INVALID_HANDLE)
 121     ACE_FAIL_RETURN (h);
 122   else
 123     return h;
 124 #elif defined (INTEGRITY)
 125   ACE_UNUSED_ARG (sa);
 126   if(!strcmp(filename,ACE_DEV_NULL)) {
 127       ACE_OSCALL_RETURN (::AllocateNullConsoleDescriptor(), ACE_HANDLE, -1);
 128   }
 129   else {
 130       ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, -1);
 131   }
 132 #else
 133   ACE_UNUSED_ARG (sa);
 134   ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, ACE_INVALID_HANDLE);
 135 #endif /* ACE_WIN32 */
 136 }
 137
 138 #if defined (ACE_HAS_WCHAR)
 139 ACE_HANDLE
 140 ACE_OS::open (const wchar_t *filename,
 141               int mode,
 142               mode_t perms,
 143               LPSECURITY_ATTRIBUTES sa)
 144 {
 145 #if defined (ACE_WIN32)
 146   // @@ (brunsch) Yuck, maybe there is a way to combine the code
 147   // here with the char version
 148
 149   DWORD access = GENERIC_READ;
 150   if (ACE_BIT_ENABLED (mode, O_WRONLY))
 151     access = GENERIC_WRITE;
 152   else if (ACE_BIT_ENABLED (mode, O_RDWR))
 153     access = GENERIC_READ | GENERIC_WRITE;
 154
 155   DWORD creation = OPEN_EXISTING;
 156
 157   if ((mode & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
 158     creation = CREATE_NEW;
 159   else if ((mode & (_O_CREAT | _O_TRUNC)) == (_O_CREAT | _O_TRUNC))
 160     creation = CREATE_ALWAYS;
 161   else if (ACE_BIT_ENABLED (mode, _O_CREAT))
 162     creation = OPEN_ALWAYS;
 163   else if (ACE_BIT_ENABLED (mode, _O_TRUNC))
 164     creation = TRUNCATE_EXISTING;
 165
 166   DWORD flags = 0;
 167
 168   if (ACE_BIT_ENABLED (mode, _O_TEMPORARY))
 169     flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
 170
 171   if (ACE_BIT_ENABLED (mode, FILE_FLAG_WRITE_THROUGH))
 172     flags |= FILE_FLAG_WRITE_THROUGH;
 173   if (ACE_BIT_ENABLED (mode, FILE_FLAG_OVERLAPPED))
 174     flags |= FILE_FLAG_OVERLAPPED;
 175   if (ACE_BIT_ENABLED (mode, FILE_FLAG_NO_BUFFERING))
 176     flags |= FILE_FLAG_NO_BUFFERING;
 177   if (ACE_BIT_ENABLED (mode, FILE_FLAG_RANDOM_ACCESS))
 178     flags |= FILE_FLAG_RANDOM_ACCESS;
 179   if (ACE_BIT_ENABLED (mode, FILE_FLAG_SEQUENTIAL_SCAN))
 180     flags |= FILE_FLAG_SEQUENTIAL_SCAN;
 181   if (ACE_BIT_ENABLED (mode, FILE_FLAG_DELETE_ON_CLOSE))
 182     flags |= FILE_FLAG_DELETE_ON_CLOSE;
 183   if (ACE_BIT_ENABLED (mode, FILE_FLAG_BACKUP_SEMANTICS))
 184     flags |= FILE_FLAG_BACKUP_SEMANTICS;
 185   if (ACE_BIT_ENABLED (mode, FILE_FLAG_POSIX_SEMANTICS))
 186     flags |= FILE_FLAG_POSIX_SEMANTICS;
 187
 188   ACE_MT (ACE_thread_mutex_t *ace_os_monitor_lock = 0;)
 189
 190   if (ACE_BIT_ENABLED (mode, _O_APPEND))
 191     {
 192       ACE_MT
 193         (
 194           ace_os_monitor_lock = static_cast <ACE_thread_mutex_t *> (
 195             ACE_OS_Object_Manager::preallocated_object[
 196               ACE_OS_Object_Manager::ACE_OS_MONITOR_LOCK]);
 197           ACE_OS::thread_mutex_lock (ace_os_monitor_lock);
 198         )
 199     }
 200
 201   DWORD shared_mode = perms;
 202   SECURITY_ATTRIBUTES sa_buffer;
 203   SECURITY_DESCRIPTOR sd_buffer;
 204
 205   ACE_HANDLE h = ::CreateFileW (filename,
 206                                 access,
 207                                 shared_mode,
 208                                 ACE_OS::default_win32_security_attributes_r
 209                                   (sa, &sa_buffer, &sd_buffer),
 210                                 creation,
 211                                 flags,
 212                                 0);
 213
 214   if (ACE_BIT_ENABLED (mode, _O_APPEND))
 215     {
 216       LONG high_size = 0;
 217       if (h != ACE_INVALID_HANDLE
 218           && ::SetFilePointer (h,
 219                                0,
 220                                &high_size,
 221                                FILE_END) == INVALID_SET_FILE_POINTER
 222           && GetLastError () != NO_ERROR)
 223         {
 224           ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
 225           ACE_FAIL_RETURN (ACE_INVALID_HANDLE);
 226         }
 227
 228       ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);)
 229     }
 230
 231   if (h == ACE_INVALID_HANDLE)
 232     ACE_FAIL_RETURN (h);
 233   else
 234     return h;
 235 #else /* ACE_WIN32 */
 236   // Just emulate with ascii version
 237   return ACE_OS::open (ACE_Wide_To_Ascii (filename).char_rep (),
 238                        mode,
 239                        perms,
 240                        sa);
 241 #endif /* ACE_WIN32 */
 242 }
 243 #endif /* ACE_HAS_WCHAR */
 244
 245 ACE_END_VERSIONED_NAMESPACE_DECL