0027620: Test perf bop boxholes crashes DRAW
[occt.git] / src / OSD / OSD_File.cxx
1 // Copyright (c) 1998-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifdef _WIN32
16   #include <windows.h>
17 #endif
18
19 #include <OSD_File.hxx>
20
21 #include <NCollection_Array1.hxx>
22 #include <OSD.hxx>
23 #include <OSD_OSDError.hxx>
24 #include <OSD_Path.hxx>
25 #include <OSD_Protection.hxx>
26 #include <OSD_WhoAmI.hxx>
27 #include <Standard_ProgramError.hxx>
28 #include <TCollection_ExtendedString.hxx>
29
30 #ifdef _WIN32
31
32   #include <OSD_WNT.hxx>
33
34   #include <stdio.h>
35   #include <io.h>
36
37   #include <strsafe.h>
38
39   #define ACE_HEADER_SIZE (sizeof(ACCESS_ALLOWED_ACE) - sizeof (DWORD))
40
41   #define OPEN_NEW    0
42   #define OPEN_OLD    1
43   #define OPEN_APPEND 2
44
45   void                            _osd_wnt_set_error        ( OSD_Error&, OSD_WhoAmI, ... );
46
47 #ifndef OCCT_UWP
48   PSECURITY_DESCRIPTOR __fastcall _osd_wnt_protection_to_sd ( const OSD_Protection&, BOOL, const wchar_t* );
49   BOOL                 __fastcall _osd_wnt_sd_to_protection (PSECURITY_DESCRIPTOR, OSD_Protection&, BOOL);
50
51   static int OSD_File_getBuffer (HANDLE theChannel,
52                                  char* theBuffer,
53                                  DWORD theSize,
54                                  BOOL theIsPeek,
55                                  BOOL theIsSocket)
56   {
57     if (theIsSocket)
58     {
59       const int aFlags = theIsPeek ? MSG_PEEK : 0;
60       const int aRetVal = recv ((SOCKET )theChannel, theBuffer, (int )theSize, aFlags);
61       return aRetVal != SOCKET_ERROR
62            ? aRetVal
63            : -1;
64     }
65
66     DWORD aBytesRead = 0;
67     if (theIsPeek)
68     {
69       DWORD aDummy = 0;
70       if (!PeekNamedPipe (theChannel, theBuffer, theSize, &aBytesRead, &aDummy, &aDummy)
71         && GetLastError() != ERROR_BROKEN_PIPE)
72       {
73         return -1;
74       }
75       return (int )aBytesRead;
76     }
77     else if (!ReadFile (theChannel, theBuffer, theSize, &aBytesRead, NULL))
78     {
79       return -1;
80     }
81     return (int )aBytesRead;
82   }
83
84   static OSD_SingleProtection OSD_File_getProtection (DWORD theMask)
85   {
86     switch (theMask)
87     {
88       case FILE_GENERIC_READ:
89         return OSD_R;
90       case FILE_GENERIC_WRITE:
91         return OSD_W;
92       case FILE_GENERIC_READ | FILE_GENERIC_WRITE:
93         return OSD_RW;
94       case FILE_GENERIC_EXECUTE:
95         return OSD_X;
96       case FILE_GENERIC_READ | FILE_GENERIC_EXECUTE:
97         return OSD_RX;
98       case FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE:
99         return OSD_WX;
100       case FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE:
101         return OSD_RWX;
102       case DELETE:
103         return OSD_D;
104       case FILE_GENERIC_READ | DELETE:
105         return OSD_RD;
106       case FILE_GENERIC_WRITE | DELETE:
107         return OSD_WD;
108       case FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE:
109         return OSD_RWD;
110       case FILE_GENERIC_EXECUTE | DELETE:
111         return OSD_XD;
112       case FILE_GENERIC_READ | FILE_GENERIC_EXECUTE | DELETE:
113         return OSD_RXD;
114       case FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE:
115         return OSD_WXD;
116       case FILE_ALL_ACCESS:
117       case FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE:
118         return OSD_RWXD;
119     }
120     return OSD_None;
121   }
122
123   static OSD_SingleProtection OSD_File_getProtectionDir (DWORD theMask)
124   {
125     switch (theMask)
126     {
127       case GENERIC_READ:
128         return OSD_R;
129       case GENERIC_WRITE:
130         return OSD_W;
131       case GENERIC_READ | GENERIC_WRITE:
132         return OSD_RW;
133       case GENERIC_EXECUTE:
134         return OSD_X;
135       case GENERIC_READ | GENERIC_EXECUTE:
136         return OSD_RX;
137       case GENERIC_WRITE | GENERIC_EXECUTE:
138         return OSD_WX;
139       case GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE:
140         return OSD_RWX;
141       case DELETE:
142         return OSD_D;
143       case GENERIC_READ | DELETE:
144         return OSD_RD;
145       case GENERIC_WRITE | DELETE:
146         return OSD_WD;
147       case GENERIC_READ | GENERIC_WRITE | DELETE:
148         return OSD_RWD;
149       case GENERIC_EXECUTE | DELETE:
150         return OSD_XD;
151       case GENERIC_READ | GENERIC_EXECUTE | DELETE:
152         return OSD_RXD;
153       case GENERIC_WRITE | GENERIC_EXECUTE | DELETE:
154         return OSD_WXD;
155       case FILE_ALL_ACCESS:
156       case GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE:
157         return OSD_RWXD;
158       case 0:
159         return OSD_None;
160       default:
161         // remote directories (on Samba server) have flags like for files
162         return OSD_File_getProtection (theMask);
163     }
164   }
165
166   static DWORD OSD_File_getAccessMask (OSD_SingleProtection theProtection)
167   {
168     switch (theProtection)
169     {
170       case OSD_None: return 0;
171       case OSD_R:    return FILE_GENERIC_READ;
172       case OSD_W:    return FILE_GENERIC_WRITE;
173       case OSD_RW:   return FILE_GENERIC_READ | FILE_GENERIC_WRITE;
174       case OSD_X:    return FILE_GENERIC_EXECUTE;
175       case OSD_RX:   return FILE_GENERIC_READ | FILE_GENERIC_EXECUTE;
176       case OSD_WX:   return FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE;
177       case OSD_RWX:  return FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE;
178       case OSD_D:    return DELETE;
179       case OSD_RD:   return FILE_GENERIC_READ | DELETE;
180       case OSD_WD:   return FILE_GENERIC_WRITE | DELETE;
181       case OSD_RWD:  return FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE;
182       case OSD_XD:   return FILE_GENERIC_EXECUTE | DELETE;
183       case OSD_RXD:  return FILE_GENERIC_READ | FILE_GENERIC_EXECUTE | DELETE;
184       case OSD_WXD:  return FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE;
185       case OSD_RWXD: return FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE;
186     }
187     throw Standard_ProgramError ("OSD_File_getAccessMask(): incorrect parameter");
188   }
189
190   static DWORD OSD_File_getDirAccessMask (OSD_SingleProtection theProtection)
191   {
192     switch (theProtection)
193     {
194       case OSD_None: return 0;
195       case OSD_R:    return GENERIC_READ;
196       case OSD_W:    return GENERIC_WRITE;
197       case OSD_RW:   return GENERIC_READ | GENERIC_WRITE;
198       case OSD_X:    return GENERIC_EXECUTE;
199       case OSD_RX:   return GENERIC_READ  | GENERIC_EXECUTE;
200       case OSD_WX:   return GENERIC_WRITE | GENERIC_EXECUTE;
201       case OSD_RWX:  return GENERIC_READ  | GENERIC_WRITE | GENERIC_EXECUTE;
202       case OSD_D:    return DELETE;
203       case OSD_RD:   return GENERIC_READ  | DELETE;
204       case OSD_WD:   return GENERIC_WRITE | DELETE;
205       case OSD_RWD:  return GENERIC_READ  | GENERIC_WRITE | DELETE;
206       case OSD_XD:   return GENERIC_EXECUTE | DELETE;
207       case OSD_RXD:  return GENERIC_READ  | GENERIC_EXECUTE | DELETE;
208       case OSD_WXD:  return GENERIC_WRITE | GENERIC_EXECUTE | DELETE;
209       case OSD_RWXD: return GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE;
210     }
211     throw Standard_ProgramError ("OSD_File_getDirAccessMask(): incorrect parameter");
212   }
213
214   struct OSD_File_WntKey
215   {
216     HKEY           hKey;
217     const wchar_t* keyPath;
218   };
219
220   #endif /* ! OCCT_UWP */
221
222   Standard_Integer __fastcall _get_file_type (Standard_CString theFileName,
223                                               HANDLE theFileHandle)
224   {
225     const int aFileType = theFileHandle == INVALID_HANDLE_VALUE
226                         ? FILE_TYPE_DISK
227                         : GetFileType (theFileHandle);
228     switch (aFileType)
229     {
230       case FILE_TYPE_UNKNOWN:
231         return FLAG_SOCKET;
232       case FILE_TYPE_DISK:
233       {
234         const TCollection_ExtendedString aFileNameW (theFileName, Standard_True);
235         WIN32_FILE_ATTRIBUTE_DATA aFileInfo;
236         if (GetFileAttributesExW (aFileNameW.ToWideString(), GetFileExInfoStandard, &aFileInfo))
237         {
238           return aFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ? FLAG_DIRECTORY : FLAG_FILE;
239         }
240         return 0x80000000;
241       }
242       case FILE_TYPE_CHAR:
243         return FLAG_DEVICE;
244       case FILE_TYPE_PIPE:
245         return FLAG_PIPE;
246     }
247     return 0;
248   }
249
250   //! Returns number of bytes in the string (including end \n, but excluding \r);
251   static Standard_Integer OSD_File_getLine (char* theBuffer, DWORD theBuffSize, LONG& theSeekPos)
252   {
253     theBuffer[theBuffSize] = 0;
254     for (char* aCharIter = theBuffer; *aCharIter != 0; )
255     {
256       if (*aCharIter == '\n')
257       {
258         ++aCharIter;   // jump newline char
259         *aCharIter = '\0';
260         theSeekPos = LONG(aCharIter - theBuffer - theBuffSize);
261         return Standard_Integer(aCharIter - theBuffer);
262       }
263       else if (aCharIter[0] == '\r'
264             && aCharIter[1] == '\n')
265       {
266         *(aCharIter++) = '\n'; // Substitute carriage return by newline
267         *aCharIter = 0;
268         theSeekPos = LONG(aCharIter + 1 - theBuffer - theBuffSize);
269         return Standard_Integer(aCharIter - theBuffer);
270       }
271       else if (aCharIter[0] == '\r'
272             && aCharIter[1] == '\0')
273       {
274         *aCharIter = '\n' ; // Substitute carriage return by newline
275         return -1;
276       }
277       ++aCharIter;
278     }
279
280     theSeekPos = 0;
281     return theBuffSize;
282   }
283
284   static HANDLE OSD_File_openFile (const TCollection_AsciiString& theFileName,
285                                    OSD_OpenMode theOpenMode,
286                                    DWORD theOptions, bool* theIsNew = NULL)
287   {
288     DWORD  dwDesiredAccess = 0;
289     switch (theOpenMode)
290     {
291       case OSD_ReadOnly:
292         dwDesiredAccess = GENERIC_READ;
293         break;
294       case OSD_WriteOnly:
295         dwDesiredAccess = GENERIC_WRITE;
296         break;
297       case OSD_ReadWrite:
298         dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
299         break;
300       default:
301         throw Standard_ProgramError ("OSD_File_openFile(): incorrect parameter");
302     }
303
304     DWORD dwCreationDistribution = (theOptions != OPEN_NEW) ? OPEN_EXISTING : CREATE_ALWAYS;
305     const TCollection_ExtendedString aFileNameW (theFileName);
306   #ifndef OCCT_UWP
307     HANDLE aFileHandle = CreateFileW (aFileNameW.ToWideString(), dwDesiredAccess,
308                                       FILE_SHARE_READ | FILE_SHARE_WRITE,
309                                       NULL, dwCreationDistribution, FILE_ATTRIBUTE_NORMAL, NULL);
310   #else
311     CREATEFILE2_EXTENDED_PARAMETERS pCreateExParams = {};
312     pCreateExParams.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS);
313     pCreateExParams.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
314     pCreateExParams.lpSecurityAttributes = NULL;
315     pCreateExParams.hTemplateFile = NULL;
316     HANDLE aFileHandle = CreateFile2 (aFileNameW.ToWideString(), dwDesiredAccess,
317                                       FILE_SHARE_READ | FILE_SHARE_WRITE,
318                                       dwCreationDistribution, &pCreateExParams);
319   #endif
320     if (aFileHandle    != INVALID_HANDLE_VALUE
321      || theOptions     != OPEN_APPEND
322      || GetLastError() != ERROR_FILE_NOT_FOUND)
323     {
324       return aFileHandle;
325     }
326
327     dwCreationDistribution = CREATE_ALWAYS;
328   #ifndef OCCT_UWP
329     aFileHandle = CreateFileW (aFileNameW.ToWideString(), dwDesiredAccess,
330                                FILE_SHARE_READ | FILE_SHARE_WRITE,
331                                NULL, dwCreationDistribution, FILE_ATTRIBUTE_NORMAL, NULL );
332   #else
333     CREATEFILE2_EXTENDED_PARAMETERS pCreateExParams2 = {};
334     pCreateExParams2.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS);
335     pCreateExParams2.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
336     pCreateExParams2.lpSecurityAttributes = NULL;
337     pCreateExParams2.hTemplateFile = NULL;
338     aFileHandle = CreateFile2 (aFileNameW.ToWideString(), dwDesiredAccess,
339                                FILE_SHARE_READ | FILE_SHARE_WRITE,
340                                dwCreationDistribution, &pCreateExParams2 );
341   #endif
342     *theIsNew = true;
343     return aFileHandle;
344   }
345
346 #else
347
348   const OSD_WhoAmI Iam = OSD_WFile;
349
350   #if defined (sun) || defined(SOLARIS)
351     #define POSIX
352   #else
353     #define SYSV
354   #endif
355
356   #include <errno.h>
357   #include <stdlib.h>
358   #include <stdio.h>
359   #include <fcntl.h>
360   #include <unistd.h>
361   #include <sys/stat.h>
362
363   #define NEWLINE '\10';
364 #endif
365
366 // =======================================================================
367 // function : OSD_File
368 // purpose  :
369 // =======================================================================
370 OSD_File::OSD_File() :
371 #ifdef _WIN32
372   myFileHandle (INVALID_HANDLE_VALUE),
373 #else
374   myFileChannel (-1),
375   myFILE (NULL),
376 #endif
377   myIO (0),
378   myLock (OSD_NoLock),
379   myMode (OSD_ReadWrite),
380   ImperativeFlag (Standard_False)
381 {
382   //
383 }
384
385 // =======================================================================
386 // function : OSD_File
387 // purpose  :
388 // =======================================================================
389 OSD_File::OSD_File (const OSD_Path& theName)
390 : OSD_FileNode (theName),
391 #ifdef _WIN32
392   myFileHandle (INVALID_HANDLE_VALUE),
393 #else
394   myFileChannel (-1),
395   myFILE (NULL),
396 #endif
397   myIO (0),
398   myLock (OSD_NoLock),
399   myMode (OSD_ReadWrite),
400   ImperativeFlag (Standard_False)
401 {
402   //
403 }
404
405 // =======================================================================
406 // function : ~OSD_File
407 // purpose  :
408 // =======================================================================
409 OSD_File::~OSD_File()
410 {
411   if (IsOpen())
412   {
413     if (IsLocked())
414     {
415       UnLock();
416     }
417     Close();
418   }
419 }
420
421 // =======================================================================
422 // function : Build
423 // purpose  :
424 // =======================================================================
425 void OSD_File::Build (const OSD_OpenMode theMode,
426                       const OSD_Protection& theProtect)
427 {
428   if (OSD_File::KindOfFile() == OSD_DIRECTORY)
429   {
430     throw Standard_ProgramError ("OSD_File::Build(): it is a directory");
431   }
432   if (IsOpen())
433   {
434     throw Standard_ProgramError ("OSD_File::Build(): incorrect call - file already opened");
435   }
436
437   TCollection_AsciiString aFileName;
438   myPath.SystemName (aFileName);
439 #ifdef _WIN32
440   if (aFileName.IsEmpty())
441   {
442     throw Standard_ProgramError ("OSD_File::Build(): incorrect call - no filename given");
443   }
444
445   myMode = theMode;
446   myFileHandle = OSD_File_openFile (aFileName, theMode, OPEN_NEW);
447   if (myFileHandle == INVALID_HANDLE_VALUE)
448   {
449     _osd_wnt_set_error (myError, OSD_WFile);
450   }
451   else
452   {
453   #ifndef OCCT_UWP
454     SetProtection (theProtect);
455   #else
456     (void)theProtect;
457   #endif
458     myIO |= FLAG_FILE;
459   }
460 #else
461   if (myPath.Name().Length() == 0)
462   {
463     throw Standard_ProgramError ("OSD_File::Build(): no name was given");
464   }
465
466   const char* anFDOpenMode = "r";
467   Standard_Integer anOpenMode = O_CREAT | O_TRUNC;
468   switch (theMode)
469   {
470     case OSD_ReadOnly:
471       anOpenMode |= O_RDONLY;
472       anFDOpenMode = "r";
473       break;
474     case OSD_WriteOnly:
475       anOpenMode |= O_WRONLY;
476       anFDOpenMode = "w";
477       break;
478     case OSD_ReadWrite:
479       anOpenMode |= O_RDWR;
480       anFDOpenMode = "w+";
481       break;
482   }
483
484   myMode = theMode;
485   myFileChannel = open (aFileName.ToCString(), anOpenMode, theProtect.Internal());
486   if (myFileChannel >= 0)
487   {
488     myFILE = fdopen (myFileChannel, anFDOpenMode);
489   }
490   else
491   {
492     myError.SetValue (errno, Iam, "Open");
493   }
494 #endif
495 }
496
497 // =======================================================================
498 // function : Append
499 // purpose  :
500 // =======================================================================
501 void OSD_File::Append (const OSD_OpenMode theMode,
502                        const OSD_Protection& theProtect)
503 {
504   if (OSD_File::KindOfFile() == OSD_DIRECTORY)
505   {
506     throw Standard_ProgramError ("OSD_File::Append(): it is a directory");
507   }
508   if (IsOpen())
509   {
510     throw Standard_ProgramError ("OSD_File::Append(): incorrect call - file already opened");
511   }
512
513   TCollection_AsciiString aFileName;
514   myPath.SystemName (aFileName);
515 #ifdef _WIN32
516   if (aFileName.IsEmpty())
517   {
518     throw Standard_ProgramError ("OSD_File::Append(): incorrect call - no filename given");
519   }
520
521   bool isNewFile = false;
522   myMode = theMode;
523   myFileHandle = OSD_File_openFile (aFileName, theMode, OPEN_APPEND, &isNewFile);
524   if (myFileHandle == INVALID_HANDLE_VALUE)
525   {
526     _osd_wnt_set_error (myError, OSD_WFile);
527   }
528   else
529   {
530     if (!isNewFile)
531     {
532       myIO |= _get_file_type (aFileName.ToCString(), myFileHandle);
533       Seek (0, OSD_FromEnd);
534     }
535     else
536     {
537     #ifndef OCCT_UWP
538       SetProtection (theProtect);
539     #else
540       (void)theProtect;
541     #endif
542       myIO |= FLAG_FILE;
543     }
544   }
545 #else
546   if (myPath.Name().Length() == 0)
547   {
548     throw Standard_ProgramError ("OSD_File::Append(): no name was given");
549   }
550
551   const char* anFDOpenMode = "r";
552   Standard_Integer anOpenMode = O_APPEND;
553   switch (theMode)
554   {
555     case OSD_ReadOnly:
556       anOpenMode |= O_RDONLY;
557       anFDOpenMode = "r";
558       break;
559     case OSD_WriteOnly:
560       anOpenMode |= O_WRONLY;
561       anFDOpenMode = "a";
562       break;
563     case OSD_ReadWrite:
564       anOpenMode |= O_RDWR;
565       anFDOpenMode = "a+";
566       break;
567   }
568
569   if (!Exists())
570   {
571     // if file doesn't exist, creates it
572     anOpenMode |= O_CREAT;
573   }
574
575   myMode = theMode;
576   myFileChannel = open (aFileName.ToCString(), anOpenMode, theProtect.Internal());
577   if (myFileChannel >= 0)
578   {
579     myFILE = fdopen (myFileChannel, anFDOpenMode);
580   }
581   else
582   {
583     myError.SetValue (errno, Iam, "Open");
584   }
585 #endif
586 }
587
588 // =======================================================================
589 // function : Open
590 // purpose  :
591 // =======================================================================
592 void OSD_File::Open (const OSD_OpenMode theMode,
593                      const OSD_Protection& theProtect)
594 {
595   if (OSD_File::KindOfFile() == OSD_DIRECTORY)
596   {
597     throw Standard_ProgramError ("OSD_File::Open(): it is a directory");
598   }
599   if (IsOpen())
600   {
601     throw Standard_ProgramError ("OSD_File::Open(): incorrect call - file already opened");
602   }
603
604   TCollection_AsciiString aFileName;
605   myPath.SystemName (aFileName);
606 #ifdef _WIN32
607   if (aFileName.IsEmpty())
608   {
609     throw Standard_ProgramError ("OSD_File::Open(): incorrect call - no filename given");
610   }
611
612   (void )theProtect;
613   myMode = theMode;
614   myFileHandle = OSD_File_openFile (aFileName, theMode, OPEN_OLD);
615   if (myFileHandle == INVALID_HANDLE_VALUE)
616   {
617     _osd_wnt_set_error (myError, OSD_WFile);
618   }
619   else
620   {
621     myIO |= _get_file_type (aFileName.ToCString(), myFileHandle);
622   }
623 #else
624   if (myPath.Name().Length() == 0)
625   {
626     throw Standard_ProgramError ("OSD_File::Open(): no name was given");
627   }
628
629   const char* anFDOpenMode = "r";
630   Standard_Integer anOpenMode = 0;
631   switch (theMode)
632   {
633     case OSD_ReadOnly:
634       anOpenMode |= O_RDONLY;
635       anFDOpenMode = "r";
636       break;
637     case OSD_WriteOnly:
638       anOpenMode |= O_WRONLY;
639       anFDOpenMode = "w";
640       break;
641     case OSD_ReadWrite:
642       anOpenMode |= O_RDWR;
643       anFDOpenMode = "w+";
644       break;
645   }
646
647   myMode = theMode;
648   myFileChannel = open (aFileName.ToCString(), anOpenMode, theProtect.Internal());
649   if (myFileChannel >= 0)
650   {
651     myFILE = fdopen (myFileChannel, anFDOpenMode);
652   }
653   else
654   {
655     myError.SetValue (errno, Iam, "Open");
656   }
657 #endif
658 }
659
660 // =======================================================================
661 // function : BuildTemporary
662 // purpose  :
663 // =======================================================================
664 void OSD_File::BuildTemporary()
665 {
666 #ifdef _WIN32
667
668   TCollection_ExtendedString aTmpFolderW;
669   BOOL fOK = FALSE;
670 #ifndef OCCT_UWP
671   const OSD_File_WntKey TheRegKeys[2] =
672   {
673     { HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" },
674     { HKEY_USERS,         L".DEFAULT\\Environment" }
675   };
676   for (int aKeyIter = 0; aKeyIter < 2; ++aKeyIter)
677   {
678     HKEY aRegKey = NULL;
679     if (RegOpenKeyExW (TheRegKeys[aKeyIter].hKey, TheRegKeys[aKeyIter].keyPath, 0, KEY_QUERY_VALUE, &aRegKey) != ERROR_SUCCESS)
680     {
681       continue;
682     }
683
684     DWORD aKeyType = 0, aKeySize = 0;
685     if (RegQueryValueExW (aRegKey, L"TEMP", NULL, &aKeyType, NULL, &aKeySize) == ERROR_SUCCESS)
686     {
687       NCollection_Array1<wchar_t> aKeyValW (0, aKeySize);
688       RegQueryValueExW (aRegKey, L"TEMP", NULL, &aKeyType, (LPBYTE )&aKeyValW.ChangeFirst(), &aKeySize);
689       if (aKeyType == REG_EXPAND_SZ)
690       {
691         wchar_t aTmpBuffer[MAX_PATH];
692         ExpandEnvironmentStringsW (&aKeyValW.First(), aTmpBuffer, MAX_PATH);
693         aTmpFolderW = TCollection_ExtendedString (aTmpBuffer);
694       }
695       else
696       {
697         aTmpFolderW = TCollection_ExtendedString (&aKeyValW.First());
698       }
699       fOK = TRUE;
700     }
701     RegCloseKey (aRegKey);
702     if (fOK) break;
703   }
704 #else
705   // Windows Registry not supported by UWP
706   {
707     wchar_t aTmpBuffer[MAX_PATH];
708     fOK = GetTempPathW (_countof(aTmpBuffer), aTmpBuffer) != 0;
709     aTmpFolderW = TCollection_ExtendedString (aTmpBuffer);
710   }
711 #endif
712   if (!fOK)
713   {
714     aTmpFolderW = "./";
715   }
716
717   wchar_t aTmpPathW[MAX_PATH];
718   GetTempFileNameW (aTmpFolderW.ToWideString(), L"CSF", 0, aTmpPathW);
719   if (IsOpen())
720   {
721     Close();
722   }
723
724   SetPath (OSD_Path (TCollection_AsciiString (aTmpPathW)));
725   Build (OSD_ReadWrite, OSD_Protection());
726
727 #else /* _WIN32 */
728
729   if (IsOpen())
730   {
731     Close();
732   }
733 #if defined(vax) || defined(__vms) || defined(VAXVMS)
734   FILE* fic = tmpfile();
735   int dummy = open("dummy", O_RDWR | O_CREAT); // open a dummy file
736   myFileChannel = dummy - 1;                   // this is file channel of "fic" +1
737   close (dummy);                               // close dummy file
738   unlink ("dummy");                            // removes dummy file
739 #else
740   char aTmpName[] = "/tmp/CSFXXXXXX";
741   myFileChannel = mkstemp (aTmpName);
742   const TCollection_AsciiString aName (aTmpName);
743   const OSD_Path aPath (aName);
744   SetPath (aPath);
745   myFILE = fdopen (myFileChannel, "w+");
746 #endif
747   myMode = OSD_ReadWrite;
748
749 #endif
750 }
751
752 // =======================================================================
753 // function : Read
754 // purpose  :
755 // =======================================================================
756 void OSD_File::Read (TCollection_AsciiString& theBuffer,
757                      const Standard_Integer theNbBytes)
758 {
759   if (OSD_File::KindOfFile() == OSD_DIRECTORY)
760   {
761     throw Standard_ProgramError ("OSD_File::Read(): it is a directory");
762   }
763   if (!IsOpen())
764   {
765     throw Standard_ProgramError ("OSD_File::Read(): file is not open");
766   }
767   if (Failed())
768   {
769     Perror();
770   }
771   if (myMode == OSD_WriteOnly)
772   {
773     throw Standard_ProgramError ("OSD_File::Read(): file is Write only");
774   }
775   if (theNbBytes <= 0)
776   {
777     throw Standard_ProgramError ("OSD_File::Read(): theNbBytes is 0");
778   }
779
780   NCollection_Array1<char> aBuffer (0, theNbBytes);
781   Standard_Integer aNbBytesRead = 0;
782 #ifdef _WIN32
783   Read (&aBuffer.ChangeFirst(), theNbBytes, aNbBytesRead);
784 #else
785   aNbBytesRead = read (myFileChannel, &aBuffer.ChangeFirst(), theNbBytes);
786   if (aNbBytesRead == -1)
787   {
788     aNbBytesRead = 0;
789     myError.SetValue (errno, Iam, "Read");
790   }
791   else if (aNbBytesRead < theNbBytes)
792   {
793     myIO = EOF;
794   }
795 #endif
796   if (aNbBytesRead != 0)
797   {
798     aBuffer.ChangeValue (aNbBytesRead) = '\0';
799     theBuffer = &aBuffer.First();
800   }
801   else
802   {
803     theBuffer.Clear();
804   }
805 }
806
807 // =======================================================================
808 // function : ReadLine
809 // purpose  :
810 // =======================================================================
811 void OSD_File::ReadLine (TCollection_AsciiString& theBuffer,
812                          const Standard_Integer theNbBytes,
813                          Standard_Integer& theNbBytesRead)
814 {
815   if (OSD_File::KindOfFile() == OSD_DIRECTORY)
816   {
817     throw Standard_ProgramError ("OSD_File::ReadLine(): it is a directory");
818   }
819   if (!IsOpen())
820   {
821     throw Standard_ProgramError ("OSD_File::ReadLine(): file is not open");
822   }
823   if (Failed())
824   {
825     Perror();
826   }
827   if (myMode == OSD_WriteOnly)
828   {
829     throw Standard_ProgramError ("OSD_File::ReadLine(): file is Write only");
830   }
831   if (theNbBytes <= 0)
832   {
833     throw Standard_ProgramError ("OSD_File::ReadLine(): theNbBytes is 0");
834   }
835 #ifdef _WIN32
836   if (myIO & FLAG_PIPE && !(myIO & FLAG_READ_PIPE))
837   {
838     throw Standard_ProgramError ("OSD_File::ReadLine(): attempt to read from write only pipe");
839   }
840
841   DWORD aNbBytesRead = 0;
842   LONG  aSeekPos = 0;
843   char  aPeekChar = '\0';
844   // +----> leave space for end-of-string
845   // |       plus <CR><LF> sequence
846   // |
847   NCollection_Array1<char> aBuffer (0, theNbBytes + 2);
848   if (myIO & FLAG_FILE)
849   {
850     if (!ReadFile (myFileHandle, &aBuffer.ChangeFirst(), theNbBytes, &aNbBytesRead, NULL))
851     {
852       _osd_wnt_set_error (myError, OSD_WFile);
853       theBuffer.Clear();
854       theNbBytesRead = 0;
855     }
856     else if (aNbBytesRead == 0)
857     {
858       theBuffer.Clear();
859       theNbBytesRead = 0;
860       myIO |= FLAG_EOF;
861     }
862     else
863     {
864       myIO &= ~FLAG_EOF;  // if the file increased since last read (LD)
865       theNbBytesRead = OSD_File_getLine (&aBuffer.ChangeFirst(), aNbBytesRead, aSeekPos);
866       if (theNbBytesRead == -1) // last character in the buffer is <CR> -
867       {                         // peek next character to see if it is a <LF>
868         DWORD dwDummy = 0;
869         if (!ReadFile (myFileHandle, &aPeekChar, 1, &dwDummy, NULL))
870         {
871           _osd_wnt_set_error (myError, OSD_WFile);
872         }
873         else if (dwDummy != 0) // end-of-file reached?
874         {
875           if (aPeekChar != '\n')  // if we did not get a <CR><LF> sequence
876           {
877             // adjust file position
878             LARGE_INTEGER aDistanceToMove;
879             aDistanceToMove.QuadPart = -1;
880             SetFilePointerEx (myFileHandle, aDistanceToMove, NULL, FILE_CURRENT);
881           }
882         }
883         else
884         {
885           myIO |= FLAG_EOF;
886         }
887
888         theNbBytesRead = aNbBytesRead;
889       }
890       else if (aSeekPos != 0)
891       {
892         LARGE_INTEGER aDistanceToMove;
893         aDistanceToMove.QuadPart = aSeekPos;
894         SetFilePointerEx (myFileHandle, aDistanceToMove, NULL, FILE_CURRENT);
895       }
896     }
897   }
898   else if (myIO & FLAG_SOCKET
899         || myIO & FLAG_PIPE
900         || myIO & FLAG_NAMED_PIPE)
901   {
902   #ifndef OCCT_UWP
903     aNbBytesRead = (DWORD )OSD_File_getBuffer (myFileHandle, &aBuffer.ChangeFirst(), (DWORD )theNbBytes, TRUE, myIO & FLAG_SOCKET);
904     if ((int )aNbBytesRead == -1)
905     {
906       _osd_wnt_set_error (myError, OSD_WFile);
907       theBuffer.Clear();
908       theNbBytesRead = 0;
909     }
910     else if (aNbBytesRead == 0) // connection closed - set end-of-file flag
911     {
912       theBuffer.Clear();
913       theNbBytesRead = 0;
914       myIO |= FLAG_EOF;
915     }
916     else
917     {
918       theNbBytesRead = OSD_File_getLine (&aBuffer.ChangeFirst(), aNbBytesRead, aSeekPos);
919       if (theNbBytesRead == -1)  // last character in the buffer is <CR> - peek next character to see if it is a <LF>
920       {
921         theNbBytesRead = aNbBytesRead; // (LD) always fits this case
922
923         const DWORD dwDummy = OSD_File_getBuffer (myFileHandle, &aPeekChar, 1, TRUE, myIO & FLAG_SOCKET);
924         if ((int )dwDummy == -1)
925         {
926           _osd_wnt_set_error (myError, OSD_WFile);
927         }
928         else if (dwDummy != 0) // connection closed?
929         {
930           if (aPeekChar == '\n') // we got a <CR><LF> sequence
931           {
932             ++aNbBytesRead;  // (LD) we have to jump <LF>
933           }
934         }
935         else
936         {
937           myIO |= FLAG_EOF;
938         }
939       }
940       else if (aSeekPos != 0)
941       {
942         aNbBytesRead = aNbBytesRead + aSeekPos;
943       }
944
945       // do not rewrite data in aBuffer
946       NCollection_Array1<char> aBuffer2 (0, theNbBytes + 2);
947       // remove pending input
948       OSD_File_getBuffer (myFileHandle, &aBuffer2.ChangeFirst(), aNbBytesRead, FALSE, myIO & FLAG_SOCKET);
949     }
950   #endif
951   }
952   else
953   {
954     throw Standard_ProgramError ("OSD_File::ReadLine(): incorrect call - file is a directory");
955   }
956
957   if (!Failed() && !IsAtEnd())
958   {
959     theBuffer = &aBuffer.First();
960   }
961 #else
962   NCollection_Array1<char> aBuffer (0, theNbBytes);
963   char* aBufferGets = fgets (&aBuffer.ChangeFirst(), theNbBytes, (FILE* )myFILE);
964   if (aBufferGets == NULL)
965   {
966     if (!feof ((FILE* )myFILE))
967     {
968       myError.SetValue (errno, Iam, "ReadLine");
969       return;
970     }
971
972     myIO = EOF;
973     theBuffer.Clear();
974     theNbBytesRead = 0;
975   }
976   else
977   {
978     aBuffer.ChangeLast() = '\0';
979     theNbBytesRead = (Standard_Integer )strlen (aBufferGets);
980     theBuffer.SetValue (1, aBufferGets);
981     theBuffer.Trunc (theNbBytesRead);
982   }
983 #endif
984 }
985
986 // =======================================================================
987 // function : KindOfFile
988 // purpose  :
989 // =======================================================================
990 OSD_KindFile OSD_File::KindOfFile() const
991 {
992   TCollection_AsciiString aFullName;
993   myPath.SystemName (aFullName);
994 #ifdef _WIN32
995   Standard_Integer aFlags = myIO;
996   if (myFileHandle == INVALID_HANDLE_VALUE)
997   {
998     if (aFullName.IsEmpty())
999     {
1000       throw Standard_ProgramError ("OSD_File::KindOfFile(): incorrect call - no filename given");
1001     }
1002     aFlags = _get_file_type (aFullName.ToCString(), INVALID_HANDLE_VALUE);
1003   }
1004
1005   switch (aFlags & FLAG_TYPE)
1006   {
1007     case FLAG_FILE:      return OSD_FILE;
1008     case FLAG_DIRECTORY: return OSD_DIRECTORY;
1009     case FLAG_SOCKET:    return OSD_SOCKET;
1010   }
1011   return OSD_UNKNOWN;
1012 #else
1013   struct stat aStatBuffer;
1014   if (stat (aFullName.ToCString(), &aStatBuffer) == 0)
1015   {
1016     if      (S_ISDIR (aStatBuffer.st_mode)) { return OSD_DIRECTORY; }
1017     else if (S_ISREG (aStatBuffer.st_mode)) { return OSD_FILE; }
1018     else if (S_ISLNK (aStatBuffer.st_mode)) { return OSD_LINK; }
1019     else if (S_ISSOCK(aStatBuffer.st_mode)) { return OSD_SOCKET; }
1020   }
1021   return OSD_UNKNOWN;
1022 #endif
1023 }
1024
1025 // =======================================================================
1026 // function : Read
1027 // purpose  :
1028 // =======================================================================
1029 void OSD_File::Read (const Standard_Address  theBuffer,
1030                      const Standard_Integer  theNbBytes,
1031                            Standard_Integer& theNbReadBytes)
1032 {
1033   if (OSD_File::KindOfFile ( ) == OSD_DIRECTORY)
1034   {
1035     throw Standard_ProgramError ("OSD_File::Read(): it is a directory");
1036   }
1037   if (!IsOpen())
1038   {
1039     throw Standard_ProgramError ("OSD_File::Read(): file is not open");
1040   }
1041   if (Failed())
1042   {
1043     Perror();
1044   }
1045   if (myMode == OSD_WriteOnly)
1046   {
1047     throw Standard_ProgramError ("OSD_File::Read(): file is Write only");
1048   }
1049   if (theNbBytes <= 0)
1050   {
1051     throw Standard_ProgramError ("OSD_File::Read(): theNbBytes is 0");
1052   }
1053   if (theBuffer == NULL)
1054   {
1055     throw Standard_ProgramError ("OSD_File::Read(): theBuffer is NULL");
1056   }
1057 #ifdef _WIN32
1058   if (myIO & FLAG_PIPE && !(myIO & FLAG_READ_PIPE))
1059   {
1060     throw Standard_ProgramError ("OSD_File::Read(): attempt to read from write only pipe");
1061   }
1062
1063   DWORD aNbReadBytes = 0;
1064   if (!ReadFile (myFileHandle, theBuffer, (DWORD )theNbBytes, &aNbReadBytes, NULL))
1065   {
1066     _osd_wnt_set_error (myError, OSD_WFile);
1067     aNbReadBytes = 0;
1068   }
1069   else if (aNbReadBytes == 0)
1070   {
1071     myIO |= FLAG_EOF;
1072   }
1073   else
1074   {
1075     myIO &= ~FLAG_EOF;
1076   }
1077
1078   theNbReadBytes = (Standard_Integer )aNbReadBytes;
1079 #else
1080   theNbReadBytes = 0;
1081   int aNbReadBytes = read (myFileChannel, (char* )theBuffer, theNbBytes);
1082   if (aNbReadBytes == -1)
1083   {
1084     myError.SetValue (errno, Iam, "Read");
1085   }
1086   else
1087   {
1088     if (aNbReadBytes < theNbBytes)
1089     {
1090       myIO = EOF;
1091     }
1092     theNbReadBytes = aNbReadBytes;
1093   }
1094 #endif
1095 }
1096
1097 // =======================================================================
1098 // function : Write
1099 // purpose  :
1100 // =======================================================================
1101 void OSD_File::Write (const Standard_Address theBuffer,
1102                       const Standard_Integer theNbBytes)
1103 {
1104   if (!IsOpen())
1105   {
1106     throw Standard_ProgramError ("OSD_File::Write(): file is not open");
1107   }
1108   if (Failed())
1109   {
1110     Perror();
1111   }
1112   if (myMode == OSD_ReadOnly)
1113   {
1114     throw Standard_ProgramError ("OSD_File::Write(): file is Read only");
1115   }
1116   if (theNbBytes <= 0)
1117   {
1118     throw Standard_ProgramError ("OSD_File::Write(): theNbBytes is null");
1119   }
1120 #ifdef _WIN32
1121   if ((myIO & FLAG_PIPE) != 0
1122    && (myIO & FLAG_READ_PIPE) != 0)
1123   {
1124     throw Standard_ProgramError ("OSD_File::Write(): attempt to write to read only pipe");
1125   }
1126
1127   DWORD aNbWritten = 0;
1128   if (!WriteFile (myFileHandle, theBuffer, (DWORD )theNbBytes, &aNbWritten, NULL)
1129   ||  aNbWritten != (DWORD )theNbBytes)
1130   {
1131     _osd_wnt_set_error (myError, OSD_WFile);
1132   }
1133 #else
1134   const int aNbWritten = write (myFileChannel, (const char* )theBuffer, theNbBytes);
1135   if (aNbWritten == -1)
1136   {
1137     myError.SetValue (errno, Iam, "Write");
1138   }
1139   else if (aNbWritten < theNbBytes)
1140   {
1141     myIO = EOF;
1142   }
1143 #endif
1144 }
1145
1146 // =======================================================================
1147 // function : Seek
1148 // purpose  :
1149 // =======================================================================
1150 void OSD_File::Seek (const Standard_Integer theOffset,
1151                      const OSD_FromWhere theWhence)
1152 {
1153   if (!IsOpen())
1154   {
1155     throw Standard_ProgramError ("OSD_File::Seek(): file is not open");
1156   }
1157   if (Failed())
1158   {
1159     Perror();
1160   }
1161
1162 #ifdef _WIN32
1163   DWORD aWhere = 0;
1164   if (myIO & FLAG_FILE
1165    || myIO & FLAG_DIRECTORY)
1166   {
1167     switch (theWhence)
1168     {
1169       case OSD_FromBeginning: aWhere = FILE_BEGIN;   break;
1170       case OSD_FromHere:      aWhere = FILE_CURRENT; break;
1171       case OSD_FromEnd:       aWhere = FILE_END;     break;
1172       default:
1173         throw Standard_ProgramError ("OSD_File::Seek(): invalid parameter");
1174     }
1175
1176     LARGE_INTEGER aDistanceToMove, aNewFilePointer;
1177     aNewFilePointer.QuadPart = 0;
1178     aDistanceToMove.QuadPart = theOffset;
1179     if (!SetFilePointerEx (myFileHandle, aDistanceToMove, &aNewFilePointer, aWhere))
1180     {
1181       _osd_wnt_set_error (myError, OSD_WFile);
1182     }
1183   }
1184   myIO &= ~FLAG_EOF;
1185 #else
1186   int aWhere = 0;
1187   switch (theWhence)
1188   {
1189     case OSD_FromBeginning: aWhere = SEEK_SET; break;
1190     case OSD_FromHere:      aWhere = SEEK_CUR; break;
1191     case OSD_FromEnd:       aWhere = SEEK_END; break;
1192     default:
1193       throw Standard_ProgramError ("OSD_File::Seek(): invalid parameter");
1194   }
1195
1196   off_t aStatus = lseek (myFileChannel, theOffset, aWhere);
1197   if (aStatus == -1)
1198   {
1199     myError.SetValue (errno, Iam, "Seek");
1200   }
1201 #endif
1202 }
1203
1204 // =======================================================================
1205 // function : Close
1206 // purpose  :
1207 // =======================================================================
1208 void OSD_File::Close()
1209 {
1210   if (!IsOpen())
1211   {
1212     throw Standard_ProgramError ("OSD_File::Close(): file is not open");
1213   }
1214   if (Failed())
1215   {
1216     Perror();
1217   }
1218 #ifdef _WIN32
1219   CloseHandle (myFileHandle);
1220   myFileHandle = INVALID_HANDLE_VALUE;
1221 #else
1222   // note: it probably should be single call to fclose()...
1223   int status = close (myFileChannel);
1224   if (status == -1)
1225   {
1226     myError.SetValue (errno, Iam, "Close");
1227   }
1228   myFileChannel = -1;
1229   if (myFILE != NULL)
1230   {
1231     status = fclose ((FILE* )myFILE);
1232     myFILE = NULL;
1233   }
1234 #endif
1235   myIO = 0;
1236 }
1237
1238 // =======================================================================
1239 // function : IsAtEnd
1240 // purpose  :
1241 // =======================================================================
1242 Standard_Boolean OSD_File::IsAtEnd()
1243 {
1244   if (!IsOpen())
1245   {
1246     throw Standard_ProgramError ("OSD_File::IsAtEnd(): file is not open");
1247   }
1248
1249 #ifdef _WIN32
1250   return (myIO & FLAG_EOF) != 0;
1251 #else
1252   return myIO == EOF;
1253 #endif
1254 }
1255
1256 // =======================================================================
1257 // function : Link
1258 // purpose  :
1259 // =======================================================================
1260 /*void OSD_File::Link (const TCollection_AsciiString& theToFile)
1261 {
1262   if (!IsOpen())
1263   {
1264     throw Standard_ProgramError ("OSD_File::Link(): file is not open");
1265   }
1266
1267   TCollection_AsciiString aFilePath;
1268   myPath.SystemName (aFilePath);
1269   link (aFilePath.ToCString(), theToFile.ToCString());
1270 }*/
1271
1272 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1273   #ifdef __try /* is defined on MinGw as either "try" or "if (true)" */
1274   #undef __try
1275   #endif
1276   #define __try
1277   #define __finally
1278   #define __leave return
1279 #endif
1280
1281 // =======================================================================
1282 // function : SetLock
1283 // purpose  :
1284 // =======================================================================
1285 void OSD_File::SetLock (const OSD_LockType theLock)
1286 {
1287   if (!IsOpen())
1288   {
1289     throw Standard_ProgramError("OSD_File::SetLock(): file is not open");
1290   }
1291 #ifdef _WIN32
1292   DWORD dwFlags = 0;
1293   myLock = theLock;
1294   if (theLock == OSD_NoLock)
1295   {
1296     UnLock();
1297     return;
1298   }
1299   else if (theLock == OSD_ReadLock
1300         || theLock == OSD_ExclusiveLock)
1301   {
1302     dwFlags = LOCKFILE_EXCLUSIVE_LOCK;
1303   }
1304
1305   OVERLAPPED anOverlapped;
1306   ZeroMemory (&anOverlapped, sizeof(OVERLAPPED));
1307   __try
1308   {
1309     LARGE_INTEGER aSize;
1310     aSize.QuadPart = Size();
1311     if (!LockFileEx (myFileHandle, dwFlags, 0, aSize.LowPart, aSize.HighPart, &anOverlapped))
1312     {
1313       _osd_wnt_set_error (myError, OSD_WFile);
1314       __leave;
1315     }
1316     ImperativeFlag = Standard_True;
1317   }
1318   __finally {}
1319
1320 #elif defined(POSIX)
1321   int aLock = 0;
1322   switch (theLock)
1323   {
1324     case OSD_ExclusiveLock:
1325     case OSD_WriteLock:
1326       aLock = F_LOCK;
1327       break;
1328     case OSD_ReadLock:
1329       return;
1330     default:
1331       myError.SetValue (EINVAL, Iam, "SetLock");
1332       return;
1333   }
1334
1335   struct stat aStatBuf;
1336   if (fstat (myFileChannel, &aStatBuf) == -1)
1337   {
1338     myError.SetValue (errno, Iam, "SetLock");
1339     return;
1340   }
1341
1342   const int aStatus = lockf (myFileChannel, aLock, aStatBuf.st_size);
1343   if (aStatus == -1)
1344   {
1345     myError.SetValue (errno, Iam, "SetLock");
1346   }
1347   else
1348   {
1349     myLock = theLock;
1350   }
1351 #elif defined(SYSV)
1352   struct flock aLockKey;
1353   aLockKey.l_whence = 0;
1354   aLockKey.l_start = 0;
1355   aLockKey.l_len = 0;
1356   switch (theLock)
1357   {
1358     case OSD_ExclusiveLock:
1359     case OSD_WriteLock:
1360       aLockKey.l_type = F_WRLCK;
1361       break;
1362     case OSD_ReadLock:
1363       aLockKey.l_type = F_RDLCK;
1364       break;
1365     case OSD_NoLock:
1366       return;
1367     //default: myError.SetValue (EINVAL, Iam, "SetLock");
1368   }
1369
1370   const int aStatus = fcntl (myFileChannel, F_SETLKW, &aLockKey);
1371   if (aStatus == -1)
1372   {
1373     myError.SetValue (errno, Iam, "SetLock");
1374   }
1375   else
1376   {
1377     myLock = theLock;
1378   }
1379
1380   if (theLock == OSD_ExclusiveLock)
1381   {
1382     struct stat aStatBuf;
1383     fstat (myFileChannel, &aStatBuf);
1384     TCollection_AsciiString aFilePath;
1385     myPath.SystemName (aFilePath);
1386     chmod (aFilePath.ToCString(), aStatBuf.st_mode | S_ISGID);
1387     ImperativeFlag = Standard_True;
1388   }
1389 #else   /* BSD */
1390   int aLock = 0;
1391   switch (theLock)
1392   {
1393     case OSD_ExclusiveLock:
1394     case OSD_WriteLock:
1395       aLock = F_WRLCK;
1396       break;
1397     case OSD_ReadLock:
1398       aLock = F_RDLCK;
1399       break;
1400     default:
1401       myError.SetValue (EINVAL, Iam, "SetLock");
1402       return;
1403   }
1404
1405   const int aStatus = flock (myFileChannel, aLock);
1406   if (aStatus == -1)
1407   {
1408     myError.SetValue (errno, Iam, "SetLock");
1409   }
1410   else
1411   {
1412     myLock = theLock;
1413   }
1414 #endif
1415 }
1416
1417 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1418   #undef __try
1419   #undef __finally
1420   #undef __leave
1421 #endif
1422
1423 // =======================================================================
1424 // function : UnLock
1425 // purpose  :
1426 // =======================================================================
1427 void OSD_File::UnLock()
1428 {
1429   if (!IsOpen())
1430   {
1431     throw Standard_ProgramError ("OSD_File::UnLock(): file is not open");
1432   }
1433 #ifdef _WIN32
1434   if (ImperativeFlag)
1435   {
1436     LARGE_INTEGER aSize;
1437     aSize.QuadPart = Size();
1438
1439     OVERLAPPED anOverlappedArea;
1440     anOverlappedArea.Offset = 0;
1441     anOverlappedArea.OffsetHigh = 0;
1442     if (!UnlockFileEx (myFileHandle, 0, aSize.LowPart, aSize.HighPart, &anOverlappedArea))
1443     {
1444       _osd_wnt_set_error (myError, OSD_WFile);
1445     }
1446     ImperativeFlag = Standard_False;
1447   }
1448 #elif defined(POSIX)
1449   struct stat aStatBuf;
1450   if (fstat (myFileChannel, &aStatBuf) == -1)
1451   {
1452     myError.SetValue (errno, Iam, "UnsetLock");
1453     return;
1454   }
1455
1456   const int aStatus = lockf (myFileChannel, F_ULOCK, aStatBuf.st_size);
1457   if (aStatus == -1)
1458   {
1459     myError.SetValue (errno, Iam, "SetLock");
1460   }
1461   else
1462   {
1463     myLock = OSD_NoLock;
1464   }
1465 #elif defined(SYSV)
1466   if (ImperativeFlag)
1467   {
1468     struct stat aStatBuf;
1469     fstat (myFileChannel, &aStatBuf);
1470     TCollection_AsciiString aBuffer;
1471     myPath.SystemName (aBuffer);
1472     chmod (aBuffer.ToCString(), aStatBuf.st_mode & ~S_ISGID);
1473     ImperativeFlag = Standard_False;
1474   }
1475
1476   struct flock aLockKey;
1477   aLockKey.l_type = F_UNLCK;
1478   const int aStatus = fcntl (myFileChannel, F_SETLK, &aLockKey);
1479   if (aStatus == -1)
1480   {
1481     myError.SetValue (errno, Iam, "UnSetLock");
1482   }
1483   else
1484   {
1485     myLock = OSD_NoLock;
1486   }
1487 #else
1488   const int aStatus = flock (myFileChannel, LOCK_UN);
1489   if (aStatus == -1)
1490   {
1491     myError.SetValue (errno, Iam, "UnSetLock");
1492   }
1493   else
1494   {
1495     myLock = OSD_NoLock;
1496   }
1497 #endif
1498 }
1499
1500 // =======================================================================
1501 // function : Size
1502 // purpose  :
1503 // =======================================================================
1504 Standard_Size OSD_File::Size()
1505 {
1506 #ifdef _WIN32
1507   if (!IsOpen())
1508   {
1509     throw Standard_ProgramError ("OSD_File::Size(): file is not open");
1510   }
1511 #if (_WIN32_WINNT >= 0x0500)
1512   LARGE_INTEGER aSize;
1513   aSize.QuadPart = 0;
1514   if (GetFileSizeEx (myFileHandle, &aSize) == 0)
1515   {
1516     _osd_wnt_set_error (myError, OSD_WFile);
1517   }
1518   return (Standard_Size )aSize.QuadPart;
1519 #else
1520   DWORD aSize = GetFileSize (myFileHandle, NULL);
1521   if (aSize == INVALID_FILE_SIZE)
1522   {
1523     _osd_wnt_set_error (myError, OSD_WFile);
1524   }
1525   return aSize;
1526 #endif
1527 #else
1528   if (myPath.Name().Length() == 0)
1529   {
1530     throw Standard_ProgramError ("OSD_File::Size(): empty file name");
1531   }
1532
1533   TCollection_AsciiString aFilePath;
1534   myPath.SystemName (aFilePath);
1535
1536   struct stat aStatBuf;
1537   const int aStatus = stat (aFilePath.ToCString(), &aStatBuf);
1538   if (aStatus == -1)
1539   {
1540     myError.SetValue (errno, Iam, "Size");
1541     return 0;
1542   }
1543   return (Standard_Size )aStatBuf.st_size;
1544 #endif
1545 }
1546
1547 // =======================================================================
1548 // function : IsOpen
1549 // purpose  :
1550 // =======================================================================
1551 Standard_Boolean OSD_File::IsOpen() const
1552 {
1553 #ifdef _WIN32
1554   return myFileHandle != INVALID_HANDLE_VALUE;
1555 #else
1556   return myFileChannel != -1;
1557 #endif
1558 }
1559
1560 // =======================================================================
1561 // function : IsReadable
1562 // purpose  :
1563 // =======================================================================
1564 Standard_Boolean OSD_File::IsReadable()
1565 {
1566   TCollection_AsciiString aFileName;
1567   myPath.SystemName (aFileName);
1568 #ifdef _WIN32
1569   HANDLE aChannel = OSD_File_openFile (aFileName, OSD_ReadOnly, OPEN_OLD);
1570   if (aChannel == INVALID_HANDLE_VALUE)
1571   {
1572     return Standard_False;
1573   }
1574
1575   CloseHandle (aChannel);
1576   return Standard_True;
1577 #else
1578   return access (aFileName.ToCString(), F_OK | R_OK) == 0;
1579 #endif
1580 }
1581
1582 // =======================================================================
1583 // function : IsWriteable
1584 // purpose  :
1585 // =======================================================================
1586 Standard_Boolean OSD_File::IsWriteable()
1587 {
1588   TCollection_AsciiString aFileName;
1589   myPath.SystemName (aFileName);
1590 #ifdef _WIN32
1591   HANDLE aChannel = OSD_File_openFile (aFileName, OSD_ReadWrite, OPEN_OLD);
1592   if (aChannel == INVALID_HANDLE_VALUE)
1593   {
1594     return Standard_False;
1595   }
1596
1597   CloseHandle (aChannel);
1598   return Standard_True;
1599 #else
1600   return access (aFileName.ToCString(), F_OK | R_OK | W_OK) == 0;
1601 #endif
1602 }
1603
1604 // =======================================================================
1605 // function : IsExecutable
1606 // purpose  :
1607 // =======================================================================
1608 Standard_Boolean OSD_File::IsExecutable()
1609 {
1610 #ifdef _WIN32
1611   return IsReadable();
1612 #else
1613   TCollection_AsciiString aFileName;
1614   myPath.SystemName (aFileName);
1615   return access (aFileName.ToCString(), F_OK | X_OK) == 0;
1616 #endif
1617 }
1618
1619 // =======================================================================
1620 // function : Rewind
1621 // purpose  :
1622 // =======================================================================
1623 void OSD_File::Rewind()
1624 {
1625 #ifdef _WIN32
1626   LARGE_INTEGER aDistanceToMove;
1627   aDistanceToMove.QuadPart = 0;
1628   SetFilePointerEx (myFileHandle, aDistanceToMove, NULL, FILE_BEGIN);
1629 #else
1630   rewind ((FILE* )myFILE);
1631 #endif
1632 }
1633
1634 // =======================================================================
1635 // function : ReadLastLine
1636 // purpose  :
1637 // =======================================================================
1638 Standard_Boolean OSD_File::ReadLastLine (TCollection_AsciiString& theLine,
1639                                          const Standard_Integer theDelay,
1640                                          const Standard_Integer theNbTries)
1641 {
1642   if (theNbTries <= 0)
1643   {
1644     return Standard_False;
1645   }
1646
1647   const Standard_Integer TheMaxLength = 1000;
1648   for (Standard_Integer Count = theNbTries; Count > 0; --Count)
1649   {
1650     Standard_Integer aLen = 0;
1651     ReadLine (theLine, TheMaxLength, aLen);
1652     if (!theLine.IsEmpty())
1653     {
1654       return Standard_True;
1655     }
1656     OSD::SecSleep (theDelay);
1657   }
1658   return Standard_False;
1659 }
1660
1661 // =======================================================================
1662 // function : Edit
1663 // purpose  :
1664 // =======================================================================
1665 Standard_Boolean OSD_File::Edit()
1666 {
1667   std::cout << "Function OSD_File::Edit() not yet implemented.\n";
1668   return Standard_False;
1669 }
1670
1671
1672 // None of the existing security APIs are supported in a UWP applications
1673 #ifdef _WIN32
1674 #ifndef OCCT_UWP
1675
1676 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1677   #define __try
1678   #define __finally
1679   #define __leave return retVal
1680 #endif
1681
1682 PSECURITY_DESCRIPTOR __fastcall _osd_wnt_protection_to_sd (const OSD_Protection& theProtection, BOOL theIsDir, const wchar_t* theFileName)
1683 {
1684   BOOL                 fOK      = FALSE;
1685   PACL                 pACL     = NULL;
1686   HANDLE               hProcess = NULL;
1687   PSID                 pSIDowner;
1688   DWORD                dwACLsize       = sizeof(ACL);
1689   DWORD                dwIndex         = 0;
1690   PTOKEN_OWNER         pTkOwner        = NULL;
1691   PTOKEN_GROUPS        pTkGroups       = NULL;
1692   PTOKEN_PRIMARY_GROUP pTkPrimaryGroup = NULL;
1693   PSECURITY_DESCRIPTOR retVal = NULL;
1694   PSECURITY_DESCRIPTOR pfSD = NULL;
1695   BOOL                 fDummy;
1696   PFILE_ACE            pFileACE;
1697
1698   __try
1699   {
1700     const int j = theIsDir ? 1 : 0;
1701     if (!OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &hProcess))
1702     {
1703        __leave;
1704     }
1705     if ((pTkGroups = (PTOKEN_GROUPS )GetTokenInformationEx (hProcess, TokenGroups)) == NULL)
1706     {
1707       __leave;
1708     }
1709     if ((pTkOwner = (PTOKEN_OWNER )GetTokenInformationEx (hProcess, TokenOwner)) == NULL)
1710     {
1711       __leave;
1712     }
1713     if ((pTkPrimaryGroup = (PTOKEN_PRIMARY_GROUP )GetTokenInformationEx (hProcess, TokenPrimaryGroup)) == NULL)
1714     {
1715       __leave;
1716     }
1717
1718 retry:
1719     if (theFileName == NULL)
1720     {
1721       pSIDowner = pTkOwner->Owner;
1722     }
1723     else
1724     {
1725       pfSD = GetFileSecurityEx (theFileName, OWNER_SECURITY_INFORMATION);
1726       if (pfSD == NULL || !GetSecurityDescriptorOwner (pfSD, &pSIDowner, &fDummy))
1727       {
1728         theFileName = NULL;
1729         goto retry;
1730       }
1731     }
1732
1733     PSID pSIDadmin = AdminSid();
1734     PSID pSIDworld = WorldSid();
1735
1736     DWORD dwAccessAdmin = OSD_File_getAccessMask (theProtection.System());
1737     DWORD dwAccessGroup = OSD_File_getAccessMask (theProtection.Group());
1738     DWORD dwAccessOwner = OSD_File_getAccessMask (theProtection.User());
1739     DWORD dwAccessWorld = OSD_File_getAccessMask (theProtection.World());
1740
1741     DWORD dwAccessAdminDir = OSD_File_getDirAccessMask (theProtection.System());
1742   //DWORD dwAccessGroupDir = OSD_File_getDirAccessMask (theProtection.Group());
1743     DWORD dwAccessOwnerDir = OSD_File_getDirAccessMask (theProtection.User());
1744   //DWORD dwAccessWorldDir = OSD_File_getDirAccessMask (theProtection.World());
1745     if (dwAccessGroup != 0)
1746     {
1747       for (int aGroupIter = 0; aGroupIter < (int )pTkGroups->GroupCount; ++aGroupIter)
1748       {
1749         PSID pSIDtemp = pTkGroups->Groups[aGroupIter].Sid;
1750         if (!NtPredefinedSid (pSIDtemp)
1751          && !EqualSid        (pSIDtemp, pSIDworld)
1752          && !EqualSid        (pSIDtemp, pTkPrimaryGroup->PrimaryGroup)
1753          &&  IsValidSid      (pSIDtemp))
1754         {
1755           dwACLsize += ((GetLengthSid (pSIDtemp) + ACE_HEADER_SIZE) << j);
1756         }
1757       }
1758     }
1759
1760     dwACLsize += (((GetLengthSid (pSIDowner) + ACE_HEADER_SIZE) << j)
1761                 + ((GetLengthSid (pSIDadmin) + ACE_HEADER_SIZE) << j)
1762                 + ((GetLengthSid (pSIDworld) + ACE_HEADER_SIZE) << j));
1763     if ((pACL = CreateAcl (dwACLsize)) == NULL)
1764     {
1765       __leave;
1766     }
1767
1768     if (dwAccessAdmin != 0)
1769     {
1770       if ((pFileACE = (PFILE_ACE )AllocAccessAllowedAce (dwAccessAdmin, 0, pSIDadmin)) != NULL)
1771       {
1772         AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1773         if (theIsDir)
1774         {
1775           pFileACE->dwMask = dwAccessAdminDir;
1776           pFileACE->header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1777           AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1778         }
1779         FreeAce (pFileACE);
1780       }
1781     }
1782
1783     if (dwAccessOwner != 0)
1784     {
1785       if ((pFileACE = (PFILE_ACE )AllocAccessAllowedAce (dwAccessOwner, 0, pSIDowner)) != NULL)
1786       {
1787         AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1788         if (theIsDir)
1789         {
1790           pFileACE->dwMask = dwAccessOwnerDir;
1791           pFileACE->header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1792           AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1793         }
1794         FreeAce (pFileACE);
1795       }
1796     }
1797
1798     if (dwAccessWorld != 0)
1799     {
1800       if ((pFileACE = (PFILE_ACE )AllocAccessAllowedAce (dwAccessWorld, 0, pSIDworld)) != NULL)
1801       {
1802         AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1803         if (theIsDir)
1804         {
1805           pFileACE->header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1806           AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1807         }
1808         FreeAce (pFileACE);
1809       }
1810     }
1811
1812     if (dwAccessGroup != 0)
1813     {
1814       for (int aGroupIter = 0; aGroupIter < (int )pTkGroups->GroupCount; ++aGroupIter)
1815       {
1816         PSID pSIDtemp = pTkGroups->Groups[aGroupIter].Sid;
1817         if (!NtPredefinedSid(pSIDtemp)
1818          && !EqualSid       (pSIDtemp, pSIDworld)
1819          && !EqualSid       (pSIDtemp, pTkPrimaryGroup->PrimaryGroup)
1820          && IsValidSid      (pSIDtemp))
1821         {
1822           if (dwAccessGroup != 0)
1823           {
1824             if ((pFileACE = (PFILE_ACE )AllocAccessAllowedAce (dwAccessGroup, 0, pSIDtemp)) != NULL)
1825             {
1826               AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1827               if (theIsDir)
1828               {
1829                 pFileACE->header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1830                 AddAce (pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE->header.AceSize);
1831               }
1832               FreeAce (pFileACE);
1833             }
1834           }
1835         }
1836       }
1837     }
1838
1839     if ((retVal = AllocSD()) == NULL)
1840     {
1841       __leave;
1842     }
1843
1844     if (!SetSecurityDescriptorDacl (retVal, TRUE, pACL, TRUE))
1845     {
1846       __leave;
1847     }
1848     fOK = TRUE;
1849   }  // end __try
1850
1851   __finally
1852   {
1853     if (!fOK)
1854     {
1855       if (retVal != NULL)
1856       {
1857         FreeSD (retVal);
1858       }
1859       else if (pACL != NULL)
1860       {
1861         FreeAcl (pACL);
1862       }
1863       retVal = NULL;
1864     }
1865
1866     if (hProcess != NULL)
1867     {
1868       CloseHandle (hProcess);
1869     }
1870     if (pTkOwner != NULL)
1871     {
1872       FreeTokenInformation (pTkOwner);
1873     }
1874     if (pTkGroups != NULL)
1875     {
1876       FreeTokenInformation (pTkGroups);
1877     }
1878     if (pTkPrimaryGroup != NULL)
1879     {
1880       FreeTokenInformation (pTkPrimaryGroup);
1881     }
1882     if (pfSD            != NULL)
1883     {
1884       FreeFileSecurity (pfSD);
1885     }
1886   }
1887
1888   return retVal;
1889 }
1890
1891 BOOL __fastcall _osd_wnt_sd_to_protection (PSECURITY_DESCRIPTOR pSD, OSD_Protection& theProtection, BOOL theIsDir)
1892 {
1893   BOOL fPresent = FALSE;
1894   BOOL fDefaulted = FALSE;
1895   PACL pACL;
1896   PSID pSIDowner;
1897   BOOL retVal = FALSE;
1898   __try
1899   {
1900     if (!GetSecurityDescriptorOwner (pSD, &pSIDowner, &fDefaulted))
1901     {
1902       __leave;
1903     }
1904     if (!GetSecurityDescriptorDacl (pSD, &fPresent, &pACL, &fDefaulted)
1905      || !fPresent)
1906     {
1907       __leave;
1908     }
1909     if (pSIDowner == NULL || pACL == NULL)
1910     {
1911       SetLastError (ERROR_NO_SECURITY_ON_OBJECT);
1912       __leave;
1913     }
1914
1915     PSID pSIDadmin = AdminSid();
1916     PSID pSIDworld = WorldSid();
1917     DWORD dwAccessOwner = 0;
1918     DWORD dwAccessGroup = 0;
1919     DWORD dwAccessAdmin = 0;
1920     DWORD dwAccessWorld = 0;
1921     for (DWORD anAceIter = 0; anAceIter < pACL->AceCount; ++anAceIter)
1922     {
1923       LPVOID pACE;
1924       if (GetAce (pACL, anAceIter, &pACE))
1925       {
1926         const DWORD dwAccess = ((PACE_HEADER )pACE)->AceType == ACCESS_DENIED_ACE_TYPE
1927                              ?  0
1928                              : *GET_MSK(pACE);
1929         if (EqualSid (pSIDowner, GET_SID(pACE)))
1930         {
1931           dwAccessOwner = dwAccess;
1932         }
1933         else if (EqualSid (pSIDadmin, GET_SID(pACE)))
1934         {
1935           dwAccessAdmin = dwAccess;
1936         }
1937         else if (EqualSid (pSIDworld, GET_SID(pACE)))
1938         {
1939           dwAccessWorld = dwAccess;
1940         }
1941         else
1942         {
1943           dwAccessGroup = dwAccess;
1944         }
1945       }
1946     }
1947
1948     typedef OSD_SingleProtection (*OSD_File_getProtection_t)(DWORD );
1949     OSD_File_getProtection_t aGetProtFunc = theIsDir ? &OSD_File_getProtectionDir : &OSD_File_getProtection;
1950     theProtection.SetValues (aGetProtFunc (dwAccessAdmin),
1951                              aGetProtFunc (dwAccessOwner),
1952                              aGetProtFunc (dwAccessGroup),
1953                              aGetProtFunc (dwAccessWorld));
1954     retVal = TRUE;
1955   }  // end __try
1956   __finally {}
1957
1958   return retVal;
1959 }  // end _osd_wnt_sd_to_protection
1960
1961 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1962   #undef __try
1963   #undef __finally
1964   #undef __leave
1965 #endif
1966
1967 #endif
1968 #endif /* _WIN32 */