0022651: Impossible to build OCC as static library due to using Standard_EXPORT inste...
[occt.git] / src / OSD / OSD_WNT.cxx
1 // Created by: PLOTNIKOV Eugeny
2 // Copyright (c) 1996-1999 Matra Datavision
3 // Copyright (c) 1999-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifdef _WIN32
17
18 /******************************************************************************/
19 /* File:      OSD_WNT.cxx                                                     */
20 /* Purpose:   Security management routines ( more convinient than WIN32       */
21 /*            ones ) and other convinient functions.                          */
22 /******************************************************************************/
23 /***/
24 #include <OSD_WNT.hxx>
25
26 #include <Strsafe.h>
27 #include <wchar.h>
28 #include <stdlib.h>
29
30 #include <Standard_Macro.hxx>
31
32 /***/
33 #ifndef OCCT_UWP
34 static void Init ( void );
35 /***/
36 class Init_OSD_WNT {  // provides initialization
37
38  public:
39
40   Init_OSD_WNT () { Init (); }
41
42 }; // end Init_OSD_WNT
43
44 static Init_OSD_WNT initOsdWnt;
45 #endif
46 /***/
47 static BOOL   fInit = FALSE;
48 static PSID*  predefinedSIDs;
49 static HANDLE hHeap;
50 /***/
51 static MOVE_DIR_PROC     _move_dir_proc;
52 static COPY_DIR_PROC     _copy_dir_proc;
53 static RESPONSE_DIR_PROC _response_dir_proc;
54 /***/
55 #define PREDEFINED_SIDs_COUNT           9
56 #define UNIVERSAL_PREDEFINED_SIDs_COUNT 5
57 /***/
58 #define SID_INTERACTIVE   0
59 #define SID_NETWORK       1
60 #define SID_LOCAL         2
61 #define SID_DIALUP        3
62 #define SID_BATCH         4
63 #define SID_CREATOR_OWNER 5
64 #define SID_ADMIN         6
65 #define SID_WORLD         7
66 #define SID_NULL          8
67 /***/
68 #ifndef OCCT_UWP
69 // None of the existing security APIs are supported in a UWP applications
70 /******************************************************************************/
71 /* Function : AllocSD                                                       */
72 /* Purpose  : Allocates and initializes security identifier                 */
73 /* Returns  : Pointer to allocated SID on success, NULL otherwise           */
74 /* Warning  : Allocated SID must be deallocated by 'FreeSD' function        */
75 /******************************************************************************/
76 /***/
77 PSECURITY_DESCRIPTOR AllocSD ( void ) {
78
79  PSECURITY_DESCRIPTOR retVal =
80   ( PSECURITY_DESCRIPTOR )HeapAlloc (
81                            hHeap, 0, sizeof ( SECURITY_DESCRIPTOR )
82                           );
83
84  if ( retVal != NULL &&
85       !InitializeSecurityDescriptor ( retVal, SECURITY_DESCRIPTOR_REVISION )
86  ) {
87  
88   HeapFree (  hHeap, 0, ( PVOID )retVal  );
89   retVal = NULL;
90  
91  }  /* end if */
92
93  return retVal; 
94
95 }  /* end AllocSD */
96 /***/
97 /******************************************************************************/
98 /* Function : FreeSD                                                        */
99 /* Purpose  : Deallocates security identifier which was allocated by the    */
100 /*            'AllocSD' function                                            */
101 /******************************************************************************/
102 /***/
103 void FreeSD ( PSECURITY_DESCRIPTOR pSD ) {
104
105  BOOL   fPresent;
106  BOOL   fDaclDefaulted;
107  PACL   pACL;
108  
109  if (  GetSecurityDescriptorDacl ( pSD, &fPresent, &pACL, &fDaclDefaulted ) &&
110        fPresent
111  )
112
113   HeapFree (  hHeap, 0, ( PVOID )pACL  );
114
115  HeapFree (  hHeap, 0, ( PVOID )pSD  );
116
117 }  /* end FreeSD */
118 /***/
119 /******************************************************************************/
120 /* Function : GetTokenInformationEx                                         */
121 /* Purpose  : Allocates and fills out access token                          */
122 /* Returns  : Pointer to the access token on success, NULL otherwise        */
123 /* Warning  : Allocated access token  must be deallocated by                */
124 /*            'FreeTokenInformation' function                               */
125 /******************************************************************************/
126 /***/
127
128 #if defined(__CYGWIN32__) || defined(__MINGW32__)
129 #define __try
130 #define __finally
131 #define __leave return buffer
132 #endif
133
134 LPVOID GetTokenInformationEx ( HANDLE hToken, TOKEN_INFORMATION_CLASS tic ) {
135
136  DWORD  errVal;
137  DWORD  dwSize;
138  DWORD  dwSizeNeeded = 0;
139  LPVOID buffer       = NULL;
140  BOOL   fOK          = FALSE;
141
142  __try {
143
144   do {
145
146    dwSize = dwSizeNeeded;
147    errVal = ERROR_SUCCESS;
148  
149    if (  !GetTokenInformation ( hToken, tic, buffer, dwSize, &dwSizeNeeded )  ) {
150
151     if (   (  errVal = GetLastError ()  ) != ERROR_INSUFFICIENT_BUFFER   )
152         
153      __leave;
154
155     if (  ( buffer = HeapAlloc (  hHeap, 0, dwSizeNeeded  ) ) == NULL  )
156
157      __leave;
158
159    }  /* end if */
160  
161   } while ( errVal != ERROR_SUCCESS );
162
163   fOK = TRUE;
164
165  }  /* end __try */
166
167  __finally {
168  
169   if ( !fOK && buffer != NULL ) {
170   
171    HeapFree ( hHeap, 0, buffer );
172    buffer = NULL;
173   
174   }  /* end if */
175  
176  }  /* end __finally */
177
178 #ifdef VAC
179 leave: ;     // added for VisualAge
180 #endif
181
182  return buffer;
183
184 }  /* end GetTokenInformationEx */
185
186 #if defined(__CYGWIN32__) || defined(__MINGW32__)
187 #undef __try
188 #undef __finally
189 #undef __leave
190 #endif
191
192 /***/
193 /******************************************************************************/
194 /* Function : FreeTokenInformation                                          */
195 /* Purpose  : Deallocates access token which was allocated by the           */
196 /*            'GetTokenInformationEx' function                              */
197 /******************************************************************************/
198 /***/
199 void FreeTokenInformation ( LPVOID lpvTkInfo ) {
200
201  HeapFree (  hHeap, 0, lpvTkInfo  );
202
203 }  /* end FreeTokenInformation */
204 /***/
205 /******************************************************************************/
206 /* Function : Init                                                          */
207 /* Purpose  : Allocates and initializes predefined security identifiers     */
208 /* Warning  : Generates 'STATUS_NO_MEMORY' software exception if there are  */
209 /*            insufficient of memory. This exception can be caught by using */
210 /*            software exception handling ( SEH ) mechanism                 */
211 /*            ( __try / __except )                                          */
212 /******************************************************************************/
213 /***/
214 static void Init ( void ) {
215
216  SID_IDENTIFIER_AUTHORITY sidIDAnull    = SECURITY_NULL_SID_AUTHORITY;
217  SID_IDENTIFIER_AUTHORITY sidIDAworld   = SECURITY_WORLD_SID_AUTHORITY;
218  SID_IDENTIFIER_AUTHORITY sidIDANT      = SECURITY_NT_AUTHORITY;
219  SID_IDENTIFIER_AUTHORITY sidIDAlocal   = SECURITY_LOCAL_SID_AUTHORITY;
220  SID_IDENTIFIER_AUTHORITY sidIDAcreator = SECURITY_CREATOR_SID_AUTHORITY;
221
222  if ( !fInit ) {
223
224   predefinedSIDs = ( PSID* )HeapAlloc (
225                              hHeap = GetProcessHeap (),
226                              HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY,
227                              PREDEFINED_SIDs_COUNT * sizeof ( PSID* )
228                             );
229
230   AllocateAndInitializeSid (
231    &sidIDANT, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
232    0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_ADMIN ]
233   );
234
235   AllocateAndInitializeSid (
236    &sidIDAworld, 1, SECURITY_WORLD_RID,
237    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_WORLD ]
238   );
239
240   AllocateAndInitializeSid (
241    &sidIDANT, 1, SECURITY_INTERACTIVE_RID,
242    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_INTERACTIVE ]
243   );
244
245   AllocateAndInitializeSid (
246    &sidIDANT, 1, SECURITY_NETWORK_RID,
247    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_NETWORK ]
248   );
249
250   AllocateAndInitializeSid (
251    &sidIDAlocal, 1, SECURITY_LOCAL_RID,
252    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_LOCAL ]
253   );
254
255   AllocateAndInitializeSid (
256    &sidIDANT, 1, SECURITY_DIALUP_RID,
257    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_DIALUP ]
258   );
259
260   AllocateAndInitializeSid (
261    &sidIDANT, 1, SECURITY_BATCH_RID,
262    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_BATCH ]
263   );
264
265   AllocateAndInitializeSid (
266    &sidIDAcreator, 1, SECURITY_CREATOR_OWNER_RID,
267    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_CREATOR_OWNER ]
268   );
269
270   AllocateAndInitializeSid (
271    &sidIDAnull, 1, SECURITY_NULL_RID,
272    0, 0, 0, 0, 0, 0, 0, &predefinedSIDs[ SID_NULL ]
273   );
274
275   fInit = TRUE;
276
277  }  /* end if */
278
279 }  /* end init */
280 /***/
281 /******************************************************************************/
282 /* Function : PredefinedSid                                                 */
283 /* Purpose  : Checks whether specified SID predefined or not                */
284 /* Returns  : TRUE if specified SID is predefined, FALSE otherwise          */
285 /******************************************************************************/
286 /***/
287 BOOL PredefinedSid ( PSID pSID ) {
288
289  int i;
290
291  for ( i = 0; i < PREDEFINED_SIDs_COUNT; ++i )
292  
293   if (  EqualSid ( pSID, predefinedSIDs[ i ] )  )
294
295    return TRUE;
296  
297  return FALSE;
298
299 }  /* end PredefinedSid */
300 /***/
301 /******************************************************************************/
302 /* Function : NtPredefinedSid                                               */
303 /* Purpose  : Checks whether specified SID universal or not                 */
304 /* Returns  : TRUE if specified SID is NOT universal, FALSE otherwise       */
305 /******************************************************************************/
306 /***/
307 BOOL NtPredefinedSid ( PSID pSID ) {
308
309  int                       i;
310  PSID_IDENTIFIER_AUTHORITY pTestIDA;
311  SID_IDENTIFIER_AUTHORITY  ntIDA = SECURITY_NT_AUTHORITY;
312  PDWORD                    pdwTestSA;
313
314  for ( i = 0; i < UNIVERSAL_PREDEFINED_SIDs_COUNT; ++i )
315
316   if (  EqualSid ( pSID, predefinedSIDs[ i ] )  )
317
318    return TRUE;
319
320  pTestIDA = GetSidIdentifierAuthority ( pSID );
321
322  if (   memcmp (  pTestIDA, &ntIDA, sizeof ( SID_IDENTIFIER_AUTHORITY )  ) == 0   ) {
323  
324   pdwTestSA = GetSidSubAuthority ( pSID, 0 );
325
326   if ( *pdwTestSA == SECURITY_LOGON_IDS_RID )
327
328    return TRUE;
329      
330  }  /* end if */
331
332  return FALSE;
333
334 }  /* end NtPredefinedSid */
335 /***/
336 /******************************************************************************/
337 /* Function : AdminSid                                                      */
338 /* Purpose  : Returns SID of the administrative user account                */
339 /******************************************************************************/
340 /***/
341 PSID AdminSid ( void ) {
342
343  return predefinedSIDs[ SID_ADMIN ];
344
345 }  /* end AdminSid */
346 /***/
347 /******************************************************************************/
348 /* Function : WorldSid                                                      */
349 /* Purpose  : Returns SID of group that includes all users                  */
350 /******************************************************************************/
351 /***/
352 PSID WorldSid ( void ) {
353
354  return predefinedSIDs[ SID_WORLD ];
355
356 }  /* end WorldSid */
357 /***/
358 /******************************************************************************/
359 /* Function : InteractiveSid                                                */
360 /* Purpose  : Returns SID of group that includes all users logged on for    */
361 /*            interactive operation                                         */
362 /******************************************************************************/
363 /***/
364 PSID InteractiveSid ( void ) {
365
366  return predefinedSIDs[ SID_INTERACTIVE ];
367
368 }  /* end InteractiveSID */
369 /***/
370 /******************************************************************************/
371 /* Function : NetworkSid                                                    */
372 /* Purpose  : Returns SID of group that includes all users logged on across */
373 /*            a network                                                     */
374 /******************************************************************************/
375 /***/
376 PSID NetworkSid ( void ) {
377
378  return predefinedSIDs[ SID_NETWORK ];
379
380 }  /* end NetworkSid */
381 /***/
382 /******************************************************************************/
383 /* Function : LocalSid                                                      */
384 /* Purpose  : Returns SID of group that includes all users logged on locally*/
385 /******************************************************************************/
386 /***/
387 PSID LocalSid ( void ) {
388
389  return predefinedSIDs[ SID_LOCAL ];
390
391 }  /* end LocalSid */
392 /***/
393 /******************************************************************************/
394 /* Function : DialupSid                                                     */
395 /* Purpose  : Returns SID of group that includes all users logged on to     */
396 /*            terminals using a dialup modem                                */
397 /******************************************************************************/
398 /***/
399 PSID DialupSid ( void ) {
400
401  return predefinedSIDs[ SID_DIALUP ];
402           
403 }  /* end DialupSid */
404 /***/
405 /******************************************************************************/
406 /* Function : BatchSid                                                      */
407 /* Purpose  : Returns SID of group that includes all users logged on using  */
408 /*            a batch queue facility                                        */
409 /******************************************************************************/
410 /***/
411 PSID BatchSid ( void ) {
412
413  return predefinedSIDs[ SID_BATCH ];
414
415 }  /* end BatchSid */
416 /***/
417 /******************************************************************************/
418 /* Function : CreatorOwnerSid                                               */
419 /* Purpose  : Returns SID of 'CREATOR OWNER' special group                  */
420 /******************************************************************************/
421 /***/
422 PSID CreatorOwnerSid ( void ) {
423
424  return predefinedSIDs[ SID_CREATOR_OWNER ];
425
426 }  /* end CreatorOwnerSid */
427 /***/
428 /******************************************************************************/
429 /* Function : NullSid                                                       */
430 /* Purpose  : Returns null SID                                              */
431 /******************************************************************************/
432 /***/
433 PSID NullSid ( void ) {
434
435  return predefinedSIDs[ SID_NULL ];
436
437 }  /* end NullSid */
438 /***/
439 /******************************************************************************/
440 /* Function : GetFileSecurityEx                                             */
441 /* Purpose  : Allocates a security descriptor and fills it out by security  */
442 /*            information which belongs to the specified file               */
443 /* Returns  : Pointer to the allocated security descriptor on success       */
444 /*            NULL otherwise                                                */
445 /* Warning  : Allocated security descriptor must be deallocated by          */
446 /*            'FreeFileSecurity' function                                   */
447 /******************************************************************************/
448 /***/
449
450
451 #if defined(__CYGWIN32__) || defined(__MINGW32__)
452 #define __try
453 #define __finally
454 #define __leave return retVal
455 #endif
456
457 PSECURITY_DESCRIPTOR GetFileSecurityEx ( LPCWSTR fileName, SECURITY_INFORMATION si ) {
458
459  DWORD                errVal;
460  DWORD                dwSize;
461  DWORD                dwSizeNeeded = 0;
462  PSECURITY_DESCRIPTOR retVal = NULL;
463  BOOL                 fOK    = FALSE;
464
465  __try {
466
467   do {
468
469    dwSize = dwSizeNeeded;
470    errVal = ERROR_SUCCESS;
471
472    if (  !GetFileSecurityW (
473            fileName, si,
474            retVal, dwSize, &dwSizeNeeded
475           )
476    ) {
477  
478     if (   (  errVal = GetLastError ()  ) != ERROR_INSUFFICIENT_BUFFER   ) __leave;
479
480     if (   (  retVal = ( PSECURITY_DESCRIPTOR )HeapAlloc ( hHeap, 0, dwSizeNeeded )
481            ) == NULL
482     ) __leave;
483
484    }  /* end if */
485  
486   } while ( errVal != ERROR_SUCCESS );
487
488   fOK = TRUE;
489
490  }  /* end __try */
491
492  __finally {
493  
494   if ( !fOK && retVal != NULL ) {
495   
496    HeapFree ( hHeap, 0, retVal );
497    retVal = NULL;
498   
499   }  /* end if */
500  
501  }  /* end __finally */
502
503 #ifdef VAC
504 leave: ;        // added for VisualAge
505 #endif
506
507  return retVal;
508
509 }  /* end GetFileSecurityEx */
510
511 #if defined(__CYGWIN32__) || defined(__MINGW32__)
512 #undef __try
513 #undef __finally
514 #undef __leave
515 #endif
516
517 /***/
518 /******************************************************************************/
519 /* Function : FreeFileSecurity                                              */
520 /* Purpose  : Deallocates security descriptor which was allocated by the    */
521 /*            'GetFileSecurityEx' function                                  */
522 /******************************************************************************/
523 /***/
524 void FreeFileSecurity ( PSECURITY_DESCRIPTOR pSD ) {
525
526  HeapFree (  hHeap, 0, ( LPVOID )pSD  );
527
528 }  /* end FreeFileSecurity */
529
530
531 /******************************************************************************/
532 /* Function : CreateAcl                                                     */
533 /* Purpose  : Allocates and initializes access-control list                 */
534 /* Returns  : Pointer to the allocated and initialized ACL on success,      */
535 /*            NULL otherwise                                                */
536 /* Warning  : Allocated ACL must be deallocated by 'FreeAcl' function       */
537 /******************************************************************************/
538 /***/
539 PACL CreateAcl ( DWORD dwAclSize ) {
540
541  PACL retVal;
542
543  retVal = ( PACL )HeapAlloc ( hHeap, 0, dwAclSize );
544
545  if ( retVal != NULL )
546
547   InitializeAcl ( retVal, dwAclSize, ACL_REVISION );
548
549  return retVal;
550
551 }  /* end CreateAcl */
552 /***/
553 /******************************************************************************/
554 /* Function : FreeAcl                                                       */
555 /* Purpose  : Deallocates access-control list which was allocated by the    */
556 /*            'CreateAcl' function                                          */
557 /******************************************************************************/
558 /***/
559 void FreeAcl ( PACL pACL ) {
560
561  HeapFree (  hHeap, 0, ( PVOID )pACL  );
562
563 }  /* end FreeAcl */
564
565 /******************************************************************************/
566 /* Function : AllocAccessAllowedAce                                         */
567 /* Purpose  : Allocates and initializes access-control entry                */
568 /* Returns  : Pointer to the ACE on success, NULL othrwise                  */
569 /* Warning  : Allocated ACE must be deallocated by the 'FreeAce' function   */
570 /******************************************************************************/
571 /***/
572 PVOID AllocAccessAllowedAce ( DWORD dwMask, BYTE flags, PSID pSID ) {
573
574  PFILE_ACE retVal;
575  WORD      wSize;
576
577  wSize = (WORD)( sizeof ( ACE_HEADER ) + sizeof ( DWORD ) + GetLengthSid ( pSID ) );
578
579  retVal = ( PFILE_ACE )HeapAlloc ( hHeap, 0, wSize );
580
581  if ( retVal != NULL ) {
582  
583   retVal -> header.AceType  = ACCESS_ALLOWED_ACE_TYPE;
584   retVal -> header.AceFlags = flags;
585   retVal -> header.AceSize  = wSize;
586
587   retVal -> dwMask = dwMask;
588
589   CopySid (  GetLengthSid ( pSID ), &retVal -> pSID, pSID  );
590  
591  }  /* end if */
592
593  return retVal;
594
595 }  /* end AllocAccessAllowedAce */
596 /***/
597 /******************************************************************************/
598 /* Function : FreeAce                                                       */
599 /* Purpose  : Deallocates an ACE which was allocated by the                 */
600 /*            'AllocAccessAllowedAce ' function                             */
601 /******************************************************************************/
602 /***/
603 void FreeAce ( PVOID pACE ) {
604
605  HeapFree ( hHeap, 0, pACE );
606
607 }  /* end FreeAce */
608 #endif
609 #define WILD_CARD     L"/*.*"
610 #define WILD_CARD_LEN (  sizeof ( WILD_CARD )  )
611
612 /***/
613 /******************************************************************************/
614 /* Function : MoveDirectory                                                 */
615 /* Purpose  : Moves specified directory tree to the new location            */
616 /* Returns  : TRUE on success, FALSE otherwise                              */
617 /******************************************************************************/
618 /***/
619 static BOOL MoveDirectory (const wchar_t* oldDir, const wchar_t* newDir, DWORD& theRecurseLevel)
620 {
621   wchar_t* driveSrc = NULL;
622   wchar_t* driveDst = NULL;
623   wchar_t* pathSrc = NULL;
624   wchar_t* pathDst = NULL;
625   BOOL     retVal = FALSE;
626   if (theRecurseLevel == 0)
627   {
628     ++theRecurseLevel;
629     BOOL fFind = FALSE;
630     if ((driveSrc = (wchar_t* )HeapAlloc (hHeap, 0, _MAX_DRIVE * sizeof(wchar_t))) != NULL
631      && (driveDst = (wchar_t* )HeapAlloc (hHeap, 0, _MAX_DRIVE * sizeof(wchar_t))) != NULL
632      && (pathSrc  = (wchar_t* )HeapAlloc (hHeap, 0, _MAX_DIR   * sizeof(wchar_t))) != NULL
633      && (pathDst  = (wchar_t* )HeapAlloc (hHeap, 0, _MAX_DIR   * sizeof(wchar_t))) != NULL)
634     {
635       _wsplitpath (oldDir, driveSrc, pathSrc, NULL, NULL);
636       _wsplitpath (newDir, driveDst, pathDst, NULL, NULL);
637       if (wcscmp (driveSrc, driveDst) == 0
638        && wcscmp (pathSrc,  pathDst ) == 0)
639       {
640 retry:
641         retVal = MoveFileExW (oldDir, newDir, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED);
642         fFind  = TRUE;
643         if (!retVal)
644         {
645           if (_response_dir_proc != NULL)
646           {
647             const DIR_RESPONSE response = _response_dir_proc (oldDir);
648             if (response == DIR_RETRY)
649             {
650               goto retry;
651             }
652             else if (response == DIR_IGNORE)
653             {
654               retVal = TRUE;
655             }
656           }
657         }
658         else if (_move_dir_proc != NULL)
659         {
660           _move_dir_proc (oldDir, newDir);
661         }
662       }
663     }
664
665     if (pathDst  != NULL)
666     {
667       HeapFree (hHeap, 0, pathDst);
668     }
669     if (pathSrc  != NULL)
670     {
671       HeapFree (hHeap, 0, pathSrc);
672     }
673     if (driveDst != NULL)
674     {
675       HeapFree (hHeap, 0, driveDst);
676     }
677     if (driveSrc != NULL)
678     {
679       HeapFree (hHeap, 0, driveSrc);
680     }
681
682     if (fFind)
683     {
684       --theRecurseLevel;
685       return retVal;
686     }
687   }
688   else
689   {
690     ++theRecurseLevel;
691   }
692
693   WIN32_FIND_DATAW* pFD = NULL;
694   wchar_t* pName = NULL;
695   wchar_t* pFullNameSrc = NULL;
696   wchar_t* pFullNameDst = NULL;
697   HANDLE hFindFile = INVALID_HANDLE_VALUE;
698   retVal = CreateDirectoryW (newDir, NULL);
699   if (retVal || (!retVal && GetLastError() == ERROR_ALREADY_EXISTS))
700   {
701     size_t anOldDirLength;
702     StringCchLengthW (oldDir, sizeof(oldDir) / sizeof(oldDir[0]), &anOldDirLength);
703     if ((pFD = (WIN32_FIND_DATAW* )HeapAlloc (hHeap, 0, sizeof(WIN32_FIND_DATAW))) != NULL
704      && (pName =        (wchar_t* )HeapAlloc (hHeap, 0, anOldDirLength + WILD_CARD_LEN + sizeof(L'\x00'))) != NULL)
705     {
706       StringCchCopyW (pName, sizeof(pName) / sizeof(pName[0]), oldDir);
707       StringCchCatW  (pName, sizeof(pName), WILD_CARD);
708       retVal = TRUE;
709       hFindFile = FindFirstFileExW (pName, FindExInfoStandard, pFD, FindExSearchNameMatch, NULL, 0);
710       for (BOOL fFind = hFindFile != INVALID_HANDLE_VALUE; fFind; fFind = FindNextFileW (hFindFile, pFD))
711       {
712         if ((pFD->cFileName[0] == L'.' && pFD->cFileName[1] == L'\0')
713          || (pFD->cFileName[0] == L'.' && pFD->cFileName[1] == L'.' && pFD->cFileName[2] == L'\0'))
714         {
715           continue;
716         }
717
718         size_t anOldDirLength2 = 0, aNewDirLength = 0, aFileNameLength = 0;
719         StringCchLengthW (oldDir, sizeof(oldDir) / sizeof(oldDir[0]), &anOldDirLength2);
720         StringCchLengthW (newDir, sizeof(newDir) / sizeof(newDir[0]), &aNewDirLength);
721         StringCchLengthW (pFD->cFileName, sizeof(pFD->cFileName) / sizeof(pFD->cFileName[0]), &aFileNameLength);
722         if ((pFullNameSrc = (wchar_t* )HeapAlloc (hHeap, 0, anOldDirLength2 + aFileNameLength + sizeof(L'/') + sizeof(L'\x00'))) == NULL
723           || (pFullNameDst = (wchar_t* )HeapAlloc (hHeap, 0, aNewDirLength   + aFileNameLength + sizeof(L'/') + sizeof(L'\x00'))) == NULL)
724         {
725           break;
726         }
727
728         StringCchCopyW (pFullNameSrc, sizeof(pFullNameSrc) / sizeof(pFullNameSrc[0]), oldDir);
729         StringCchCatW  (pFullNameSrc, sizeof(pFullNameSrc) / sizeof(pFullNameSrc[0]), L"/");
730         StringCchCatW  (pFullNameSrc, sizeof(pFullNameSrc) / sizeof(pFullNameSrc[0]), pFD->cFileName);
731
732         StringCchCopyW (pFullNameDst, sizeof(pFullNameDst) / sizeof(pFullNameDst[0]), newDir);
733         StringCchCatW  (pFullNameDst, sizeof(pFullNameDst) / sizeof(pFullNameDst[0]), L"/");
734         StringCchCatW  (pFullNameDst, sizeof(pFullNameDst) / sizeof(pFullNameDst[0]), pFD->cFileName);
735
736         if ((pFD->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
737         {
738           retVal = MoveDirectory (pFullNameSrc, pFullNameDst, theRecurseLevel);
739           if (!retVal)
740           {
741             break;
742           }
743         }
744         else
745         {
746 retry_1:
747           retVal = MoveFileExW (pFullNameSrc, pFullNameDst, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED);
748           if (!retVal)
749           {
750             if (_response_dir_proc != NULL)
751             {
752               const DIR_RESPONSE response = _response_dir_proc (pFullNameSrc);
753               if (response == DIR_ABORT)
754               {
755                 break;
756               }
757               else if (response == DIR_RETRY)
758               {
759                 goto retry_1;
760               }
761               else if (response == DIR_IGNORE)
762               {
763                 retVal = TRUE;
764               }
765               else
766               {
767                 break;
768               }
769             }
770           }
771           else if (_move_dir_proc != NULL)
772           {
773             _move_dir_proc (pFullNameSrc, pFullNameDst);
774           }
775         }
776
777         HeapFree (hHeap, 0, pFullNameDst);
778         HeapFree (hHeap, 0, pFullNameSrc);
779         pFullNameSrc = pFullNameDst = NULL;
780       }
781     }
782   }
783
784   if (hFindFile != INVALID_HANDLE_VALUE)
785   {
786     FindClose (hFindFile);
787   }
788
789   if (pFullNameSrc != NULL)
790   {
791     HeapFree (hHeap, 0, pFullNameSrc);
792   }
793   if (pFullNameDst != NULL)
794   {
795     HeapFree (hHeap, 0, pFullNameDst);
796   }
797   if (pName != NULL)
798   {
799     HeapFree (hHeap, 0, pName);
800   }
801   if (pFD != NULL)
802   {
803     HeapFree (hHeap, 0, pFD);
804   }
805
806   if (retVal)
807   {
808 retry_2:
809     retVal = RemoveDirectoryW (oldDir);
810     if (!retVal)
811     {
812       if (_response_dir_proc != NULL)
813       {
814         const DIR_RESPONSE response = _response_dir_proc (oldDir);
815         if (response == DIR_RETRY)
816         {
817           goto retry_2;
818         }
819         else if (response == DIR_IGNORE)
820         {
821           retVal = TRUE;
822         }
823       }
824     }
825   }
826
827   --theRecurseLevel;
828   return retVal;
829 }
830
831 BOOL MoveDirectory (const wchar_t* oldDir, const wchar_t* newDir)
832 {
833   DWORD aRecurseLevel = 0;
834   return MoveDirectory (oldDir, newDir, aRecurseLevel);
835 }
836
837 /***/
838 /******************************************************************************/
839 /* Function : CopyDirectory                                                 */
840 /* Purpose  : Copies specified directory tree to the new location           */
841 /* Returns  : TRUE on success, FALSE otherwise                              */
842 /******************************************************************************/
843 /***/
844 BOOL CopyDirectory (const wchar_t* dirSrc, const wchar_t* dirDst)
845 {
846   WIN32_FIND_DATAW* pFD = NULL;
847   wchar_t* pName = NULL;
848   wchar_t* pFullNameSrc = NULL;
849   wchar_t* pFullNameDst = NULL;
850   HANDLE   hFindFile = INVALID_HANDLE_VALUE;
851
852   BOOL retVal = CreateDirectoryW (dirDst, NULL);
853   if (retVal || (!retVal && GetLastError() == ERROR_ALREADY_EXISTS))
854   {
855     size_t aDirSrcLength = 0;
856     StringCchLengthW (dirSrc, sizeof(dirSrc) / sizeof(dirSrc[0]), &aDirSrcLength);
857     if ((pFD = (WIN32_FIND_DATAW* )HeapAlloc (hHeap, 0, sizeof(WIN32_FIND_DATAW))) != NULL
858      && (pName = (wchar_t* )HeapAlloc (hHeap, 0, aDirSrcLength + WILD_CARD_LEN + sizeof(L'\x00'))) != NULL)
859     {
860       StringCchCopyW(pName, sizeof(pName) / sizeof(pName[0]), dirSrc);
861       StringCchCatW (pName, sizeof(pName) / sizeof(pName[0]), WILD_CARD);
862
863       retVal = TRUE;
864       hFindFile = FindFirstFileExW (pName, FindExInfoStandard, pFD, FindExSearchNameMatch, NULL, 0);
865       for (BOOL fFind = hFindFile != INVALID_HANDLE_VALUE; fFind; fFind = FindNextFileW (hFindFile, pFD))
866       {
867         if ((pFD->cFileName[0] == L'.' && pFD->cFileName[1] == L'\0')
868          || (pFD->cFileName[0] == L'.' && pFD->cFileName[1] == L'.' && pFD->cFileName[2] == L'\0'))
869         {
870           continue;
871         }
872
873         size_t aDirSrcLength2 = 0, aDirDstLength = 0, aFileNameLength = 0;
874         StringCchLengthW (dirSrc, sizeof(dirSrc) / sizeof(dirSrc[0]), &aDirSrcLength2);
875         StringCchLengthW (dirDst, sizeof(dirDst) / sizeof(dirDst[0]), &aDirDstLength);
876         StringCchLengthW (pFD->cFileName, sizeof(pFD->cFileName) / sizeof(pFD->cFileName[0]), &aFileNameLength);
877         if ((pFullNameSrc = (wchar_t* )HeapAlloc (hHeap, 0, aDirSrcLength2 + aFileNameLength + sizeof(L'/') + sizeof(L'\x00'))) == NULL
878          || (pFullNameDst = (wchar_t* )HeapAlloc (hHeap, 0, aDirDstLength  + aFileNameLength + sizeof(L'/') + sizeof(L'\x00'))) == NULL)
879         {
880           break;
881         }
882
883         StringCchCopyW (pFullNameSrc, sizeof(pFullNameSrc) / sizeof(pFullNameSrc[0]), dirSrc);
884         StringCchCatW  (pFullNameSrc, sizeof(pFullNameSrc) / sizeof(pFullNameSrc[0]), L"/");
885         StringCchCatW  (pFullNameSrc, sizeof(pFullNameSrc) / sizeof(pFullNameSrc[0]), pFD->cFileName);
886
887         StringCchCopyW (pFullNameDst, sizeof(pFullNameDst) / sizeof(pFullNameDst[0]), dirDst);
888         StringCchCatW  (pFullNameDst, sizeof(pFullNameDst) / sizeof(pFullNameDst[0]), L"/");
889         StringCchCatW  (pFullNameDst, sizeof(pFullNameDst) / sizeof(pFullNameDst[0]), pFD->cFileName);
890         if ((pFD->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
891         {
892           retVal = CopyDirectory (pFullNameSrc, pFullNameDst);
893           if (!retVal)
894           {
895             break;
896           }
897         }
898         else
899         {
900 retry:
901         #ifndef OCCT_UWP
902           retVal = CopyFileW (pFullNameSrc, pFullNameDst, FALSE);
903         #else
904           retVal = (CopyFile2 (pFullNameSrc, pFullNameDst, FALSE) == S_OK) ? TRUE : FALSE;
905         #endif
906           if (!retVal)
907           {
908             if (_response_dir_proc != NULL)
909             {
910               const DIR_RESPONSE response = _response_dir_proc (pFullNameSrc);
911               if (response == DIR_ABORT)
912               {
913                 break;
914               }
915               else if (response == DIR_RETRY)
916               {
917                 goto retry;
918               }
919               else if (response == DIR_IGNORE)
920               {
921                 retVal = TRUE;
922               }
923               else
924               {
925                 break;
926               }
927             }
928           }
929           else if (_copy_dir_proc != NULL)
930           {
931             _copy_dir_proc (pFullNameSrc, pFullNameDst);
932           }
933         }
934
935         HeapFree (hHeap, 0, pFullNameDst);
936         HeapFree (hHeap, 0, pFullNameSrc);
937         pFullNameSrc = pFullNameDst = NULL;
938       }
939     }
940   }
941
942   if (hFindFile != INVALID_HANDLE_VALUE)
943   {
944     FindClose (hFindFile);
945   }
946
947   if (pFullNameSrc != NULL)
948   {
949     HeapFree (hHeap, 0, pFullNameSrc);
950   }
951   if (pFullNameDst != NULL)
952   {
953     HeapFree (hHeap, 0, pFullNameDst);
954   }
955   if (pName != NULL)
956   {
957     HeapFree (hHeap, 0, pName);
958   }
959   if (pFD != NULL)
960   {
961     HeapFree (hHeap, 0, pFD);
962   }
963
964   return retVal;
965 }  /* end CopyDirectory */
966 /***/
967 /******************************************************************************/
968 /* Function : SetMoveDirectoryProc                                          */
969 /* Purpose  : Sets callback procedure which is calling by the               */ 
970 /*            'MoveDirectory' after moving of each item in the              */
971 /*            directory. To unregister this callback function supply NULL   */
972 /*            pointer                                                       */
973 /******************************************************************************/
974 /***/
975 void SetMoveDirectoryProc ( MOVE_DIR_PROC proc ) {
976
977  _move_dir_proc = proc;
978
979 }  /* end SetMoveDirectoryProc */
980 /***/
981 /******************************************************************************/
982 /* Function : SetCopyDirectoryProc                                          */
983 /* Purpose  : Sets callback procedure which is calling by the               */ 
984 /*            'CopyDirectory' after copying of each item in the             */
985 /*            directory. To unregister this callback function supply NULL   */
986 /*            pointer                                                       */
987 /******************************************************************************/
988 /***/
989 void SetCopyDirectoryProc ( COPY_DIR_PROC proc ) {
990
991  _copy_dir_proc = proc;
992
993 }  /* end SetCopyDirectoryProc */
994 /***/
995 /******************************************************************************/
996 /* Function : SetResponseDirectoryProc                                      */
997 /* Purpose  : Sets callback procedure which is calling by the               */ 
998 /*            directoy processing function if an error was occur.           */
999 /*            The return value of that callback procedure determines        */
1000 /*            behaviour of directoy processing functions in case of error.  */
1001 /*            To unregister this callback function supply NULL pointer      */
1002 /******************************************************************************/
1003 /***/
1004 void SetResponseDirectoryProc ( RESPONSE_DIR_PROC proc ) {
1005
1006  _response_dir_proc = proc;
1007
1008 }  /* end SetResponseDirectoryProc */
1009 /***/
1010 /******************************************************************************/
1011 /******************************************************************************/
1012 /******************************************************************************/
1013 #endif