?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Branch libreoffice-6-3
[LibreOffice.git] / sal / osl / w32 / file_dirvol.cxx
blob36a4b5d4013db15975b7eb2cc3e2af4c40352c5a
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <systools/win32/uwinapi.h>
21
22 #include "file_url.hxx"
23 #include "filetime.hxx"
24 #include "file_error.hxx"
25
26 #include "path_helper.hxx"
27
28 #include <rtl/alloc.h>
29 #include <rtl/ustring.hxx>
30 #include <rtl/character.hxx>
31 #include <sal/log.hxx>
32 #include <o3tl/char16_t2wchar_t.hxx>
33
34 static const wchar_t UNC_PREFIX[] = L"\\\\";
35 static const wchar_t BACKSLASH = '\\';
36 static const wchar_t SLASH = '/';
37
38 BOOL TimeValueToFileTime(const TimeValue *cpTimeVal, FILETIME *pFTime)
39 {
40 SYSTEMTIME BaseSysTime;
41 FILETIME BaseFileTime;
42 FILETIME FTime;
43 BOOL fSuccess = FALSE;
44
45 BaseSysTime.wYear = 1970;
46 BaseSysTime.wMonth = 1;
47 BaseSysTime.wDayOfWeek = 0;
48 BaseSysTime.wDay = 1;
49 BaseSysTime.wHour = 0;
50 BaseSysTime.wMinute = 0;
51 BaseSysTime.wSecond = 0;
52 BaseSysTime.wMilliseconds = 0;
53
54 if (cpTimeVal==nullptr)
55 return fSuccess;
56
57 if ( SystemTimeToFileTime(&BaseSysTime, &BaseFileTime) )
58 {
59 __int64 timeValue;
60
61 __int64 localTime = cpTimeVal->Seconds*__int64(10000000)+cpTimeVal->Nanosec/100;
62 osl::detail::setFiletime(FTime, localTime);
63 fSuccess = 0 <= (timeValue= osl::detail::getFiletime(BaseFileTime) + osl::detail::getFiletime(FTime));
64 if (fSuccess)
65 osl::detail::setFiletime(*pFTime, timeValue);
66 }
67 return fSuccess;
68 }
69
70 BOOL FileTimeToTimeValue(const FILETIME *cpFTime, TimeValue *pTimeVal)
71 {
72 SYSTEMTIME BaseSysTime;
73 FILETIME BaseFileTime;
74 BOOL fSuccess = FALSE; /* Assume failure */
75
76 BaseSysTime.wYear = 1970;
77 BaseSysTime.wMonth = 1;
78 BaseSysTime.wDayOfWeek = 0;
79 BaseSysTime.wDay = 1;
80 BaseSysTime.wHour = 0;
81 BaseSysTime.wMinute = 0;
82 BaseSysTime.wSecond = 0;
83 BaseSysTime.wMilliseconds = 0;
84
85 if ( SystemTimeToFileTime(&BaseSysTime, &BaseFileTime) )
86 {
87 __int64 Value;
88
89 fSuccess = 0 <= (Value = osl::detail::getFiletime(*cpFTime) - osl::detail::getFiletime(BaseFileTime));
90
91 if ( fSuccess )
92 {
93 pTimeVal->Seconds = static_cast<unsigned long>(Value / 10000000L);
94 pTimeVal->Nanosec = static_cast<unsigned long>((Value % 10000000L) * 100);
95 }
96 }
97 return fSuccess;
98 }
99
100 namespace
101 {
102
103 struct Component
104 {
105 Component() :
106 begin_(nullptr), end_(nullptr)
107 {}
108
109 bool isPresent() const
110 { return (static_cast<sal_IntPtr>(end_ - begin_) > 0); }
111
112 const sal_Unicode* begin_;
113 const sal_Unicode* end_;
114 };
115
116 struct UNCComponents
117 {
118 Component server_;
119 Component share_;
120 Component resource_;
121 };
122
123 bool is_UNC_path(const sal_Unicode* path)
124 { return (0 == wcsncmp(UNC_PREFIX, o3tl::toW(path), SAL_N_ELEMENTS(UNC_PREFIX) - 1)); }
125
126 void parse_UNC_path(const sal_Unicode* path, UNCComponents* puncc)
127 {
128 OSL_PRECOND(is_UNC_path(path), "Precondition violated: No UNC path");
129 OSL_PRECOND(rtl_ustr_indexOfChar(path, SLASH) == -1, "Path must not contain slashes");
130
131 const sal_Unicode* pend = path + rtl_ustr_getLength(path);
132 const sal_Unicode* ppos = path + 2;
133
134 puncc->server_.begin_ = ppos;
135 while ((ppos < pend) && (*ppos != BACKSLASH))
136 ppos++;
137
138 puncc->server_.end_ = ppos;
139
140 if (BACKSLASH == *ppos)
141 {
142 puncc->share_.begin_ = ++ppos;
143 while ((ppos < pend) && (*ppos != BACKSLASH))
144 ppos++;
145
146 puncc->share_.end_ = ppos;
147
148 if (BACKSLASH == *ppos)
149 {
150 puncc->resource_.begin_ = ++ppos;
151 while (ppos < pend)
152 ppos++;
153
154 puncc->resource_.end_ = ppos;
155 }
156 }
157
158 SAL_WARN_IF(!puncc->server_.isPresent() || !puncc->share_.isPresent(),
159 "sal.osl",
160 "Postcondition violated: Invalid UNC path detected");
161 }
162
163 bool has_path_parent(const sal_Unicode* path)
164 {
165 // Has the given path a parent or are we already there,
166 // e.g. 'c:\' or '\\server\share\'?
167
168 bool has_parent = false;
169 if (is_UNC_path(path))
170 {
171 UNCComponents unc_comp;
172 parse_UNC_path(path, &unc_comp);
173 has_parent = unc_comp.resource_.isPresent();
174 }
175 else
176 {
177 has_parent = !osl::systemPathIsLogicalDrivePattern(path);
178 }
179 return has_parent;
180 }
181
182 bool has_path_parent(const OUString& path)
183 { return has_path_parent(path.getStr()); }
184
185 }
186
187 oslFileError SAL_CALL osl_acquireVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
188 {
189 if ( Handle )
190 {
191 rtl_uString_acquire( static_cast<rtl_uString *>(Handle) );
192 return osl_File_E_None;
193 }
194 else
195 return osl_File_E_INVAL;
196 }
197
198 oslFileError SAL_CALL osl_releaseVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
199 {
200 if ( Handle )
201 {
202 rtl_uString_release( static_cast<rtl_uString *>(Handle) );
203 return osl_File_E_None;
204 }
205 else
206 return osl_File_E_INVAL;
207 }
208
209 oslFileError SAL_CALL osl_getVolumeDeviceMountPath( oslVolumeDeviceHandle Handle, rtl_uString **pstrPath )
210 {
211 if ( Handle && pstrPath )
212 {
213 rtl_uString_assign( pstrPath, static_cast<rtl_uString *>(Handle) );
214 return osl_File_E_None;
215 }
216 else
217 return osl_File_E_INVAL;
218 }
219
220 #define DIRECTORYITEM_DRIVE 0
221 #define DIRECTORYITEM_FILE 1
222 #define DIRECTORYITEM_SERVER 2
223
224 struct DirectoryItem_Impl
225 {
226 UINT uType;
227 union {
228 WIN32_FIND_DATAW FindData;
229 WCHAR cDriveString[MAX_PATH];
230 };
231 rtl_uString* m_pFullPath;
232 BOOL bFullPathNormalized;
233 int nRefCount;
234 };
235
236 #define DIRECTORYTYPE_LOCALROOT 0
237 #define DIRECTORYTYPE_NETROOT 1
238 #define DIRECTORYTYPE_FILESYSTEM 3
239
240 struct Directory_Impl
241 {
242 UINT uType;
243 union {
244 HANDLE hDirectory;
245 HANDLE hEnumDrives;
246 };
247 rtl_uString* m_pDirectoryPath;
248 };
249
250 typedef struct tagDRIVEENUM
251 {
252 LPCWSTR lpIdent;
253 WCHAR cBuffer[/*('Z' - 'A' + 1) * sizeof("A:\\") + 1*/256];
254 LPCWSTR lpCurrent;
255 } DRIVEENUM, * PDRIVEENUM, FAR * LPDRIVEENUM;
256
257 static HANDLE WINAPI OpenLogicalDrivesEnum()
258 {
259 LPDRIVEENUM pEnum = static_cast<LPDRIVEENUM>(HeapAlloc( GetProcessHeap(), 0, sizeof(DRIVEENUM) ));
260 if ( pEnum )
261 {
262 DWORD dwNumCopied = GetLogicalDriveStringsW( SAL_N_ELEMENTS(pEnum->cBuffer) - 1, pEnum->cBuffer );
263
264 if ( dwNumCopied && dwNumCopied < SAL_N_ELEMENTS(pEnum->cBuffer) )
265 {
266 pEnum->lpCurrent = pEnum->cBuffer;
267 pEnum->lpIdent = L"tagDRIVEENUM";
268 }
269 else
270 {
271 HeapFree( GetProcessHeap(), 0, pEnum );
272 pEnum = nullptr;
273 }
274 }
275 return pEnum ? static_cast<HANDLE>(pEnum) : INVALID_HANDLE_VALUE;
276 }
277
278 static BOOL WINAPI EnumLogicalDrives(HANDLE hEnum, LPWSTR lpBuffer)
279 {
280 BOOL fSuccess = FALSE;
281 LPDRIVEENUM pEnum = static_cast<LPDRIVEENUM>(hEnum);
282
283 if ( pEnum )
284 {
285 int nLen = wcslen( pEnum->lpCurrent );
286
287 if ( nLen )
288 {
289 CopyMemory( lpBuffer, pEnum->lpCurrent, (nLen + 1) * sizeof(WCHAR) );
290 pEnum->lpCurrent += nLen + 1;
291 fSuccess = TRUE;
292 }
293 else
294 SetLastError( ERROR_NO_MORE_FILES );
295 }
296 else
297 SetLastError( ERROR_INVALID_HANDLE );
298
299 return fSuccess;
300 }
301
302 static BOOL WINAPI CloseLogicalDrivesEnum(HANDLE hEnum)
303 {
304 BOOL fSuccess = FALSE;
305 LPDRIVEENUM pEnum = static_cast<LPDRIVEENUM>(hEnum);
306
307 if ( pEnum )
308 {
309 HeapFree( GetProcessHeap(), 0, pEnum );
310 fSuccess = TRUE;
311 }
312 else
313 SetLastError( ERROR_INVALID_HANDLE );
314
315 return fSuccess;
316 }
317
318 typedef struct tagDIRECTORY
319 {
320 HANDLE hFind;
321 WIN32_FIND_DATAW aFirstData;
322 } DIRECTORY, *PDIRECTORY, FAR *LPDIRECTORY;
323
324 static HANDLE WINAPI OpenDirectory( rtl_uString* pPath)
325 {
326 LPDIRECTORY pDirectory = nullptr;
327
328 if ( pPath )
329 {
330 sal_uInt32 nLen = rtl_uString_getLength( pPath );
331 if ( nLen )
332 {
333 const WCHAR* pSuffix = nullptr;
334 sal_uInt32 nSuffLen = 0;
335
336 if ( pPath->buffer[nLen - 1] != L'\\' )
337 {
338 pSuffix = L"\\*.*";
339 nSuffLen = 4;
340 }
341 else
342 {
343 pSuffix = L"*.*";
344 nSuffLen = 3;
345 }
346
347 WCHAR* szFileMask = static_cast< WCHAR* >( malloc( sizeof( WCHAR ) * ( nLen + nSuffLen + 1 ) ) );
348 assert(szFileMask); // Don't handle OOM conditions
349 wcscpy( szFileMask, o3tl::toW(rtl_uString_getStr( pPath )) );
350 wcscat( szFileMask, pSuffix );
351
352 pDirectory = static_cast<LPDIRECTORY>(HeapAlloc(GetProcessHeap(), 0, sizeof(DIRECTORY)));
353 assert(pDirectory); // Don't handle OOM conditions
354 pDirectory->hFind = FindFirstFileW(szFileMask, &pDirectory->aFirstData);
355
356 if (!IsValidHandle(pDirectory->hFind))
357 {
358 if ( GetLastError() != ERROR_NO_MORE_FILES )
359 {
360 HeapFree(GetProcessHeap(), 0, pDirectory);
361 pDirectory = nullptr;
362 }
363 }
364 free(szFileMask);
365 }
366 }
367
368 return static_cast<HANDLE>(pDirectory);
369 }
370
371 static BOOL WINAPI EnumDirectory(HANDLE hDirectory, LPWIN32_FIND_DATAW pFindData)
372 {
373 BOOL fSuccess = FALSE;
374 LPDIRECTORY pDirectory = static_cast<LPDIRECTORY>(hDirectory);
375
376 if ( pDirectory )
377 {
378 BOOL fValid;
379
380 do
381 {
382 if ( pDirectory->aFirstData.cFileName[0] )
383 {
384 *pFindData = pDirectory->aFirstData;
385 fSuccess = TRUE;
386 pDirectory->aFirstData.cFileName[0] = 0;
387 }
388 else if ( IsValidHandle( pDirectory->hFind ) )
389 fSuccess = FindNextFileW( pDirectory->hFind, pFindData );
390 else
391 {
392 fSuccess = FALSE;
393 SetLastError( ERROR_NO_MORE_FILES );
394 }
395
396 fValid = fSuccess && wcscmp( L".", pFindData->cFileName ) != 0 && wcscmp( L"..", pFindData->cFileName ) != 0;
397
398 } while( fSuccess && !fValid );
399 }
400 else
401 SetLastError( ERROR_INVALID_HANDLE );
402
403 return fSuccess;
404 }
405
406 static BOOL WINAPI CloseDirectory(HANDLE hDirectory)
407 {
408 BOOL fSuccess = FALSE;
409 LPDIRECTORY pDirectory = static_cast<LPDIRECTORY>(hDirectory);
410
411 if (pDirectory)
412 {
413 if (IsValidHandle(pDirectory->hFind))
414 fSuccess = FindClose(pDirectory->hFind);
415
416 fSuccess = HeapFree(GetProcessHeap(), 0, pDirectory) && fSuccess;
417 }
418 else
419 SetLastError(ERROR_INVALID_HANDLE);
420
421 return fSuccess;
422 }
423
424 static oslFileError osl_openLocalRoot(
425 rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
426 {
427 rtl_uString *strSysPath = nullptr;
428 oslFileError error;
429
430 if ( !pDirectory )
431 return osl_File_E_INVAL;
432
433 *pDirectory = nullptr;
434
435 error = osl_getSystemPathFromFileURL_( strDirectoryPath, &strSysPath, false );
436 if ( osl_File_E_None == error )
437 {
438 Directory_Impl *pDirImpl;
439
440 pDirImpl = static_cast<Directory_Impl*>(malloc( sizeof(Directory_Impl)));
441 assert(pDirImpl); // Don't handle OOM conditions
442 ZeroMemory( pDirImpl, sizeof(Directory_Impl) );
443 rtl_uString_newFromString( &pDirImpl->m_pDirectoryPath, strSysPath );
444
445 /* Append backslash if necessary */
446
447 /* @@@ToDo
448 use function ensure backslash
449 */
450 sal_uInt32 nLen = rtl_uString_getLength( pDirImpl->m_pDirectoryPath );
451 if ( nLen && pDirImpl->m_pDirectoryPath->buffer[nLen - 1] != L'\\' )
452 {
453 rtl_uString* pCurDir = nullptr;
454 rtl_uString* pBackSlash = nullptr;
455
456 rtl_uString_assign( &pCurDir, pDirImpl->m_pDirectoryPath );
457 rtl_uString_newFromAscii( &pBackSlash, "\\" );
458 rtl_uString_newConcat( &pDirImpl->m_pDirectoryPath, pCurDir, pBackSlash );
459 rtl_uString_release( pBackSlash );
460 rtl_uString_release( pCurDir );
461 }
462
463 pDirImpl->uType = DIRECTORYTYPE_LOCALROOT;
464 pDirImpl->hEnumDrives = OpenLogicalDrivesEnum();
465
466 /* @@@ToDo
467 Use IsValidHandle(...)
468 */
469 if ( pDirImpl->hEnumDrives != INVALID_HANDLE_VALUE )
470 {
471 *pDirectory = static_cast<oslDirectory>(pDirImpl);
472 error = osl_File_E_None;
473 }
474 else
475 {
476 if ( pDirImpl )
477 {
478 if ( pDirImpl->m_pDirectoryPath )
479 {
480 rtl_uString_release( pDirImpl->m_pDirectoryPath );
481 pDirImpl->m_pDirectoryPath = nullptr;
482 }
483
484 free(pDirImpl);
485 pDirImpl = nullptr;
486 }
487
488 error = oslTranslateFileError( GetLastError() );
489 }
490
491 rtl_uString_release( strSysPath );
492 }
493 return error;
494 }
495
496 static oslFileError osl_openFileDirectory(
497 rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
498 {
499 oslFileError error = osl_File_E_None;
500
501 if ( !pDirectory )
502 return osl_File_E_INVAL;
503 *pDirectory = nullptr;
504
505 Directory_Impl *pDirImpl = static_cast<Directory_Impl*>(malloc(sizeof(Directory_Impl)));
506 assert(pDirImpl); // Don't handle OOM conditions
507 ZeroMemory( pDirImpl, sizeof(Directory_Impl) );
508 rtl_uString_newFromString( &pDirImpl->m_pDirectoryPath, strDirectoryPath );
509
510 /* Append backslash if necessary */
511
512 /* @@@ToDo
513 use function ensure backslash
514 */
515 sal_uInt32 nLen = rtl_uString_getLength( pDirImpl->m_pDirectoryPath );
516 if ( nLen && pDirImpl->m_pDirectoryPath->buffer[nLen - 1] != L'\\' )
517 {
518 rtl_uString* pCurDir = nullptr;
519 rtl_uString* pBackSlash = nullptr;
520
521 rtl_uString_assign( &pCurDir, pDirImpl->m_pDirectoryPath );
522 rtl_uString_newFromAscii( &pBackSlash, "\\" );
523 rtl_uString_newConcat( &pDirImpl->m_pDirectoryPath, pCurDir, pBackSlash );
524 rtl_uString_release( pBackSlash );
525 rtl_uString_release( pCurDir );
526 }
527
528 pDirImpl->uType = DIRECTORYTYPE_FILESYSTEM;
529 pDirImpl->hDirectory = OpenDirectory( pDirImpl->m_pDirectoryPath );
530
531 if ( !pDirImpl->hDirectory )
532 {
533 error = oslTranslateFileError( GetLastError() );
534
535 if ( pDirImpl->m_pDirectoryPath )
536 {
537 rtl_uString_release( pDirImpl->m_pDirectoryPath );
538 pDirImpl->m_pDirectoryPath = nullptr;
539 }
540
541 free(pDirImpl);
542 pDirImpl = nullptr;
543 }
544
545 *pDirectory = static_cast<oslDirectory>(pDirImpl);
546 return error;
547 }
548
549 static oslFileError osl_openNetworkServer(
550 rtl_uString *strSysDirPath, oslDirectory *pDirectory)
551 {
552 NETRESOURCEW aNetResource;
553 HANDLE hEnum;
554 DWORD dwError;
555
556 ZeroMemory( &aNetResource, sizeof(aNetResource) );
557
558 aNetResource.lpRemoteName = o3tl::toW(strSysDirPath->buffer);
559
560 dwError = WNetOpenEnumW(
561 RESOURCE_GLOBALNET,
562 RESOURCETYPE_DISK,
563 RESOURCEUSAGE_CONNECTABLE | RESOURCEUSAGE_CONTAINER,
564 &aNetResource,
565 &hEnum );
566
567 if ( ERROR_SUCCESS == dwError )
568 {
569 Directory_Impl *pDirImpl;
570
571 pDirImpl = static_cast<Directory_Impl*>(malloc(sizeof(Directory_Impl)));
572 assert(pDirImpl); // Don't handle OOM conditions
573 ZeroMemory( pDirImpl, sizeof(Directory_Impl) );
574 pDirImpl->uType = DIRECTORYTYPE_NETROOT;
575 pDirImpl->hDirectory = hEnum;
576 *pDirectory = static_cast<oslDirectory>(pDirImpl);
577 }
578 return oslTranslateFileError( dwError );
579 }
580
581 static DWORD create_dir_with_callback(
582 rtl_uString * dir_path,
583 oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
584 void* pData)
585 {
586 // Create the specified directory and call the
587 // user specified callback function. On success
588 // the function returns ERROR_SUCCESS else a Win32 error code.
589
590 BOOL bCreated = CreateDirectoryW( o3tl::toW(rtl_uString_getStr( dir_path )), nullptr );
591
592 if ( bCreated )
593 {
594 if (aDirectoryCreationCallbackFunc)
595 {
596 OUString url;
597 osl_getFileURLFromSystemPath(dir_path, &(url.pData));
598 aDirectoryCreationCallbackFunc(pData, url.pData);
599 }
600 return ERROR_SUCCESS;
601 }
602 return GetLastError();
603 }
604
605 static int path_make_parent(sal_Unicode* path)
606 {
607 /* Cut off the last part of the given path to
608 get the parent only, e.g. 'c:\dir\subdir' ->
609 'c:\dir' or '\\share\sub\dir' -> '\\share\sub'
610 @return The position where the path has been cut
611 off (this is the position of the last backslash).
612 If there are no more parents 0 will be returned,
613 e.g. 'c:\' or '\\Share' have no more parents */
614
615 OSL_PRECOND(rtl_ustr_indexOfChar(path, SLASH) == -1, "Path must not contain slashes");
616 OSL_PRECOND(has_path_parent(path), "Path must have a parent");
617
618 sal_Unicode* pos_last_backslash = path + rtl_ustr_lastIndexOfChar(path, BACKSLASH);
619 *pos_last_backslash = 0;
620 return (pos_last_backslash - path);
621 }
622
623 static DWORD create_dir_recursively_(
624 rtl_uString * dir_path,
625 oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
626 void* pData)
627 {
628 OSL_PRECOND(
629 rtl_ustr_lastIndexOfChar_WithLength(dir_path->buffer, dir_path->length, BACKSLASH) != dir_path->length,
630 "Path must not end with a backslash");
631
632 DWORD w32_error = create_dir_with_callback(
633 dir_path, aDirectoryCreationCallbackFunc, pData);
634 if (w32_error == ERROR_SUCCESS)
635 return ERROR_SUCCESS;
636
637 if ((w32_error != ERROR_PATH_NOT_FOUND) || !has_path_parent(dir_path->buffer))
638 return w32_error;
639
640 int pos = path_make_parent(dir_path->buffer); // dir_path->buffer[pos] = 0, restore below
641
642 w32_error = create_dir_recursively_(
643 dir_path, aDirectoryCreationCallbackFunc, pData);
644
645 dir_path->buffer[pos] = BACKSLASH; // restore
646
647 if (ERROR_SUCCESS != w32_error && ERROR_ALREADY_EXISTS != w32_error)
648 return w32_error;
649
650 return create_dir_recursively_(dir_path, aDirectoryCreationCallbackFunc, pData);
651 }
652
653 oslFileError SAL_CALL osl_createDirectoryPath(
654 rtl_uString* aDirectoryUrl,
655 oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
656 void* pData)
657 {
658 if (aDirectoryUrl == nullptr)
659 return osl_File_E_INVAL;
660
661 OUString sys_path;
662 oslFileError osl_error =
663 osl_getSystemPathFromFileURL_(aDirectoryUrl, &sys_path.pData, false);
664
665 if (osl_error != osl_File_E_None)
666 return osl_error;
667
668 osl::systemPathRemoveSeparator(sys_path);
669
670 // const_cast because sys_path is a local copy
671 // which we want to modify inplace instead of
672 // copy it into another buffer on the heap again
673 return oslTranslateFileError(create_dir_recursively_(
674 sys_path.pData, aDirectoryCreationCallbackFunc, pData));
675 }
676
677 oslFileError SAL_CALL osl_createDirectory(rtl_uString* strPath)
678 {
679 return osl_createDirectoryWithFlags(
680 strPath, osl_File_OpenFlag_Read | osl_File_OpenFlag_Write);
681 }
682
683 oslFileError osl_createDirectoryWithFlags(rtl_uString * strPath, sal_uInt32)
684 {
685 rtl_uString *strSysPath = nullptr;
686 oslFileError error = osl_getSystemPathFromFileURL_( strPath, &strSysPath, false );
687
688 if ( osl_File_E_None == error )
689 {
690 BOOL bCreated = CreateDirectoryW( o3tl::toW(rtl_uString_getStr( strSysPath )), nullptr );
691
692 if ( !bCreated )
693 {
694 /*@@@ToDo
695 The following case is a hack because the ucb or the webtop had some
696 problems with the error code that CreateDirectory returns in
697 case the path is only a logical drive, should be removed!
698 */
699
700 const sal_Unicode *pBuffer = rtl_uString_getStr( strSysPath );
701 sal_Int32 nLen = rtl_uString_getLength( strSysPath );
702
703 if (
704 ( ( pBuffer[0] >= 'A' && pBuffer[0] <= 'Z' ) ||
705 ( pBuffer[0] >= 'a' && pBuffer[0] <= 'z' ) ) &&
706 pBuffer[1] == ':' && ( nLen ==2 || ( nLen == 3 && pBuffer[2] == '\\' ) )
707 )
708 SetLastError( ERROR_ALREADY_EXISTS );
709
710 error = oslTranslateFileError( GetLastError() );
711 }
712
713 rtl_uString_release( strSysPath );
714 }
715 return error;
716 }
717
718 oslFileError SAL_CALL osl_removeDirectory(rtl_uString* strPath)
719 {
720 rtl_uString *strSysPath = nullptr;
721 oslFileError error = osl_getSystemPathFromFileURL_( strPath, &strSysPath, false );
722
723 if ( osl_File_E_None == error )
724 {
725 if ( RemoveDirectoryW( o3tl::toW(rtl_uString_getStr( strSysPath ) )) )
726 error = osl_File_E_None;
727 else
728 error = oslTranslateFileError( GetLastError() );
729
730 rtl_uString_release( strSysPath );
731 }
732 return error;
733 }
734
735 oslFileError SAL_CALL osl_openDirectory(rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
736 {
737 oslFileError error;
738
739 if ( 0 == rtl_ustr_ascii_compareIgnoreAsciiCase( strDirectoryPath->buffer, "file:///" ) )
740 error = osl_openLocalRoot( strDirectoryPath, pDirectory );
741 else
742 {
743 rtl_uString *strSysDirectoryPath = nullptr;
744 DWORD dwPathType;
745
746 error = osl_getSystemPathFromFileURL_( strDirectoryPath, &strSysDirectoryPath, false );
747
748 if ( osl_File_E_None != error )
749 return error;
750
751 dwPathType = IsValidFilePath( strSysDirectoryPath, VALIDATEPATH_NORMAL, nullptr );
752
753 if ( dwPathType & PATHTYPE_IS_SERVER )
754 {
755 error = osl_openNetworkServer( strSysDirectoryPath, pDirectory );
756 }
757 else
758 error = osl_openFileDirectory( strSysDirectoryPath, pDirectory );
759
760 rtl_uString_release( strSysDirectoryPath );
761 }
762 return error;
763 }
764
765 static oslFileError osl_getNextNetResource(
766 oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 /*uHint*/ )
767 {
768 Directory_Impl *pDirImpl = static_cast<Directory_Impl *>(Directory);
769 DirectoryItem_Impl *pItemImpl = nullptr;
770 BYTE buffer[16384];
771 LPNETRESOURCEW lpNetResource = reinterpret_cast<LPNETRESOURCEW>(buffer);
772 DWORD dwError, dwCount, dwBufSize;
773
774 if ( !pItem )
775 return osl_File_E_INVAL;
776 *pItem = nullptr;
777
778 if ( !pDirImpl )
779 return osl_File_E_INVAL;
780
781 dwCount = 1;
782 dwBufSize = sizeof(buffer);
783 dwError = WNetEnumResourceW( pDirImpl->hDirectory, &dwCount, lpNetResource, &dwBufSize );
784
785 switch ( dwError )
786 {
787 case NO_ERROR:
788 case ERROR_MORE_DATA:
789 {
790 pItemImpl = static_cast<DirectoryItem_Impl*>(malloc(sizeof(DirectoryItem_Impl)));
791 if ( !pItemImpl )
792 return osl_File_E_NOMEM;
793
794 ZeroMemory( pItemImpl, sizeof(DirectoryItem_Impl) );
795 pItemImpl->uType = DIRECTORYITEM_DRIVE;
796 osl_acquireDirectoryItem( static_cast<oslDirectoryItem>(pItemImpl) );
797
798 wcscpy( pItemImpl->cDriveString, lpNetResource->lpRemoteName );
799
800 *pItem = pItemImpl;
801 }
802 return osl_File_E_None;
803 case ERROR_NO_MORE_ITEMS:
804 return osl_File_E_NOENT;
805 default:
806 return oslTranslateFileError( dwError );
807 }
808 }
809
810 static oslFileError osl_getNextDrive(
811 oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 /*uHint*/ )
812 {
813 Directory_Impl *pDirImpl = static_cast<Directory_Impl *>(Directory);
814 DirectoryItem_Impl *pItemImpl = nullptr;
815 BOOL fSuccess;
816
817 if ( !pItem )
818 return osl_File_E_INVAL;
819 *pItem = nullptr;
820
821 if ( !pDirImpl )
822 return osl_File_E_INVAL;
823
824 pItemImpl = static_cast<DirectoryItem_Impl*>(malloc(sizeof(DirectoryItem_Impl)));
825 if ( !pItemImpl )
826 return osl_File_E_NOMEM;
827
828 ZeroMemory( pItemImpl, sizeof(DirectoryItem_Impl) );
829 pItemImpl->uType = DIRECTORYITEM_DRIVE;
830 osl_acquireDirectoryItem( static_cast<oslDirectoryItem>(pItemImpl) );
831 fSuccess = EnumLogicalDrives( pDirImpl->hEnumDrives, pItemImpl->cDriveString );
832
833 if ( fSuccess )
834 {
835 *pItem = pItemImpl;
836 return osl_File_E_None;
837 }
838 else
839 {
840 if ( pItemImpl->m_pFullPath )
841 {
842 rtl_uString_release( pItemImpl->m_pFullPath );
843 pItemImpl->m_pFullPath = nullptr;
844 }
845
846 free( pItemImpl );
847 return oslTranslateFileError( GetLastError() );
848 }
849 }
850
851 static oslFileError osl_getNextFileItem(
852 oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 /*uHint*/)
853 {
854 Directory_Impl *pDirImpl = static_cast<Directory_Impl *>(Directory);
855 DirectoryItem_Impl *pItemImpl = nullptr;
856 BOOL fFound;
857
858 if ( !pItem )
859 return osl_File_E_INVAL;
860 *pItem = nullptr;
861
862 if ( !pDirImpl )
863 return osl_File_E_INVAL;
864
865 pItemImpl = static_cast<DirectoryItem_Impl*>(malloc(sizeof(DirectoryItem_Impl)));
866 if ( !pItemImpl )
867 return osl_File_E_NOMEM;
868
869 memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
870 fFound = EnumDirectory( pDirImpl->hDirectory, &pItemImpl->FindData );
871
872 if ( fFound )
873 {
874 pItemImpl->uType = DIRECTORYITEM_FILE;
875 pItemImpl->nRefCount = 1;
876
877 rtl_uString* pTmpFileName = nullptr;
878 rtl_uString_newFromStr( &pTmpFileName, o3tl::toU(pItemImpl->FindData.cFileName) );
879 rtl_uString_newConcat( &pItemImpl->m_pFullPath, pDirImpl->m_pDirectoryPath, pTmpFileName );
880 rtl_uString_release( pTmpFileName );
881
882 pItemImpl->bFullPathNormalized = FALSE;
883 *pItem = static_cast<oslDirectoryItem>(pItemImpl);
884 return osl_File_E_None;
885 }
886 else
887 {
888 if ( pItemImpl->m_pFullPath )
889 {
890 rtl_uString_release( pItemImpl->m_pFullPath );
891 pItemImpl->m_pFullPath = nullptr;
892 }
893
894 free( pItemImpl );
895 return oslTranslateFileError( GetLastError() );
896 }
897 }
898
899 oslFileError SAL_CALL osl_getNextDirectoryItem(
900 oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 uHint)
901 {
902 Directory_Impl *pDirImpl = static_cast<Directory_Impl *>(Directory);
903
904 /* Assume failure */
905
906 if ( !pItem )
907 return osl_File_E_INVAL;
908 *pItem = nullptr;
909
910 if ( !pDirImpl )
911 return osl_File_E_INVAL;
912
913 switch ( pDirImpl->uType )
914 {
915 case DIRECTORYTYPE_LOCALROOT:
916 return osl_getNextDrive( Directory, pItem, uHint );
917 case DIRECTORYTYPE_NETROOT:
918 return osl_getNextNetResource( Directory, pItem, uHint );
919 case DIRECTORYTYPE_FILESYSTEM:
920 return osl_getNextFileItem( Directory, pItem, uHint );
921 default:
922 return osl_File_E_INVAL;
923 }
924 }
925
926 oslFileError SAL_CALL osl_closeDirectory(oslDirectory Directory)
927 {
928 Directory_Impl *pDirImpl = static_cast<Directory_Impl *>(Directory);
929 oslFileError eError = osl_File_E_INVAL;
930
931 if ( pDirImpl )
932 {
933 switch ( pDirImpl->uType )
934 {
935 case DIRECTORYTYPE_FILESYSTEM:
936 eError = CloseDirectory( pDirImpl->hDirectory ) ? osl_File_E_None : oslTranslateFileError( GetLastError() );
937 break;
938 case DIRECTORYTYPE_LOCALROOT:
939 eError = CloseLogicalDrivesEnum( pDirImpl->hEnumDrives ) ? osl_File_E_None : oslTranslateFileError( GetLastError() );
940 break;
941 case DIRECTORYTYPE_NETROOT:
942 {
943 DWORD err = WNetCloseEnum(pDirImpl->hDirectory);
944 eError = (err == NO_ERROR) ? osl_File_E_None : oslTranslateFileError(err);
945 }
946 break;
947 default:
948 OSL_FAIL( "Invalid directory type" );
949 break;
950 }
951
952 if ( pDirImpl->m_pDirectoryPath )
953 {
954 rtl_uString_release( pDirImpl->m_pDirectoryPath );
955 pDirImpl->m_pDirectoryPath = nullptr;
956 }
957
958 free(pDirImpl);
959 }
960 return eError;
961 }
962
963 /* Different types of paths */
964 enum PATHTYPE
965 {
966 PATHTYPE_SYNTAXERROR = 0,
967 PATHTYPE_NETROOT,
968 PATHTYPE_NETSERVER,
969 PATHTYPE_VOLUME,
970 PATHTYPE_FILE
971 };
972
973 oslFileError SAL_CALL osl_getDirectoryItem(rtl_uString *strFilePath, oslDirectoryItem *pItem)
974 {
975 oslFileError error = osl_File_E_None;
976 rtl_uString* strSysFilePath = nullptr;
977 PATHTYPE type = PATHTYPE_FILE;
978 DWORD dwPathType;
979
980 /* Assume failure */
981
982 if ( !pItem )
983 return osl_File_E_INVAL;
984
985 *pItem = nullptr;
986
987 error = osl_getSystemPathFromFileURL_( strFilePath, &strSysFilePath, false );
988
989 if ( osl_File_E_None != error )
990 return error;
991
992 dwPathType = IsValidFilePath( strSysFilePath, VALIDATEPATH_NORMAL, nullptr );
993
994 if ( dwPathType & PATHTYPE_IS_VOLUME )
995 type = PATHTYPE_VOLUME;
996 else if ( dwPathType & PATHTYPE_IS_SERVER )
997 type = PATHTYPE_NETSERVER;
998 else
999 type = PATHTYPE_FILE;
1000
1001 switch ( type )
1002 {
1003 case PATHTYPE_NETSERVER:
1004 {
1005 DirectoryItem_Impl* pItemImpl =
1006 static_cast<DirectoryItem_Impl*>(malloc(sizeof(DirectoryItem_Impl)));
1007
1008 if ( !pItemImpl )
1009 error = osl_File_E_NOMEM;
1010
1011 if ( osl_File_E_None == error )
1012 {
1013 ZeroMemory( pItemImpl, sizeof(DirectoryItem_Impl) );
1014 pItemImpl->uType = DIRECTORYITEM_SERVER;
1015
1016 osl_acquireDirectoryItem( static_cast<oslDirectoryItem>(pItemImpl) );
1017 rtl_uString_newFromString( &pItemImpl->m_pFullPath, strSysFilePath );
1018
1019 // Assign a title anyway
1020 {
1021 int iSrc = 2;
1022 int iDst = 0;
1023
1024 while( iSrc < strSysFilePath->length && strSysFilePath->buffer[iSrc] && strSysFilePath->buffer[iSrc] != '\\' )
1025 {
1026 pItemImpl->FindData.cFileName[iDst++] = strSysFilePath->buffer[iSrc++];
1027 }
1028 }
1029
1030 *pItem = pItemImpl;
1031 }
1032 }
1033 break;
1034 case PATHTYPE_VOLUME:
1035 {
1036 DirectoryItem_Impl* pItemImpl =
1037 static_cast<DirectoryItem_Impl*>(malloc(sizeof(DirectoryItem_Impl)));
1038
1039 if ( !pItemImpl )
1040 error = osl_File_E_NOMEM;
1041
1042 if ( osl_File_E_None == error )
1043 {
1044 ZeroMemory( pItemImpl, sizeof(DirectoryItem_Impl) );
1045 pItemImpl->uType = DIRECTORYITEM_DRIVE;
1046
1047 osl_acquireDirectoryItem( static_cast<oslDirectoryItem>(pItemImpl) );
1048
1049 wcscpy( pItemImpl->cDriveString, o3tl::toW(strSysFilePath->buffer) );
1050 pItemImpl->cDriveString[0] = rtl::toAsciiUpperCase( pItemImpl->cDriveString[0] );
1051
1052 if ( pItemImpl->cDriveString[wcslen(pItemImpl->cDriveString) - 1] != '\\' )
1053 wcscat( pItemImpl->cDriveString, L"\\" );
1054
1055 *pItem = pItemImpl;
1056 }
1057 }
1058 break;
1059 case PATHTYPE_SYNTAXERROR:
1060 case PATHTYPE_NETROOT:
1061 case PATHTYPE_FILE:
1062 {
1063 HANDLE hFind;
1064 WIN32_FIND_DATAW aFindData;
1065
1066 if ( strSysFilePath->length > 0 && strSysFilePath->buffer[strSysFilePath->length - 1] == '\\' )
1067 rtl_uString_newFromStr_WithLength( &strSysFilePath, strSysFilePath->buffer, strSysFilePath->length - 1 );
1068
1069 hFind = FindFirstFileW( o3tl::toW(rtl_uString_getStr(strSysFilePath)), &aFindData );
1070
1071 if ( hFind != INVALID_HANDLE_VALUE )
1072 {
1073 DirectoryItem_Impl *pItemImpl =
1074 static_cast<DirectoryItem_Impl*>(malloc(sizeof(DirectoryItem_Impl)));
1075 if (!pItemImpl)
1076 error = osl_File_E_NOMEM;
1077
1078 if (osl_File_E_None == error)
1079 {
1080 ZeroMemory(pItemImpl, sizeof(DirectoryItem_Impl));
1081 osl_acquireDirectoryItem(static_cast<oslDirectoryItem>(pItemImpl));
1082
1083 CopyMemory(&pItemImpl->FindData, &aFindData, sizeof(WIN32_FIND_DATAW));
1084 rtl_uString_newFromString(&pItemImpl->m_pFullPath, strSysFilePath);
1085
1086 // MT: This costs 600ms startup time on fast v60x!
1087 // GetCaseCorrectPathName( pItemImpl->szFullPath, pItemImpl->szFullPath, sizeof(pItemImpl->szFullPath) );
1088
1089 pItemImpl->uType = DIRECTORYITEM_FILE;
1090 *pItem = pItemImpl;
1091 }
1092
1093 FindClose( hFind );
1094 }
1095 else
1096 error = oslTranslateFileError( GetLastError() );
1097 }
1098 break;
1099 }
1100
1101 if ( strSysFilePath )
1102 rtl_uString_release( strSysFilePath );
1103
1104 return error;
1105 }
1106
1107 oslFileError SAL_CALL osl_acquireDirectoryItem( oslDirectoryItem Item )
1108 {
1109 DirectoryItem_Impl *pItemImpl = static_cast<DirectoryItem_Impl *>(Item);
1110
1111 if ( !pItemImpl )
1112 return osl_File_E_INVAL;
1113
1114 pItemImpl->nRefCount++;
1115 return osl_File_E_None;
1116 }
1117
1118 oslFileError SAL_CALL osl_releaseDirectoryItem( oslDirectoryItem Item )
1119 {
1120 DirectoryItem_Impl *pItemImpl = static_cast<DirectoryItem_Impl *>(Item);
1121
1122 if ( !pItemImpl )
1123 return osl_File_E_INVAL;
1124
1125 if ( ! --pItemImpl->nRefCount )
1126 {
1127 if ( pItemImpl->m_pFullPath )
1128 {
1129 rtl_uString_release( pItemImpl->m_pFullPath );
1130 pItemImpl->m_pFullPath = nullptr;
1131 }
1132
1133 free( pItemImpl );
1134 }
1135
1136 return osl_File_E_None;
1137 }
1138
1139 sal_Bool
1140 SAL_CALL osl_identicalDirectoryItem( oslDirectoryItem a, oslDirectoryItem b)
1141 {
1142 DirectoryItem_Impl *pA = static_cast<DirectoryItem_Impl *>(a);
1143 DirectoryItem_Impl *pB = static_cast<DirectoryItem_Impl *>(b);
1144 if (a == b)
1145 return true;
1146 /* same name => same item, unless renaming / moving madness has occurred */
1147 if (pA->m_pFullPath == pB->m_pFullPath)
1148 return true;
1149
1150 // FIXME: as/when/if this is used in anger on Windows we could
1151 // do better here.
1152
1153 return false;
1154 }
1155
1156 static bool is_floppy_A_present()
1157 { return (GetLogicalDrives() & 1); }
1158
1159 static bool is_floppy_B_present()
1160 { return (GetLogicalDrives() & 2); }
1161
1162 static bool is_floppy_volume_mount_point(const OUString& path)
1163 {
1164 // determines if a volume mount point shows to a floppy
1165 // disk by comparing the unique volume names
1166 static const LPCWSTR FLOPPY_A = L"A:\\";
1167 static const LPCWSTR FLOPPY_B = L"B:\\";
1168
1169 OUString p(path);
1170 osl::systemPathEnsureSeparator(p);
1171
1172 WCHAR vn[51];
1173 if (GetVolumeNameForVolumeMountPointW(o3tl::toW(p.getStr()), vn, SAL_N_ELEMENTS(vn)))
1174 {
1175 WCHAR vnfloppy[51];
1176 if (is_floppy_A_present() &&
1177 GetVolumeNameForVolumeMountPointW(FLOPPY_A, vnfloppy, SAL_N_ELEMENTS(vnfloppy)) &&
1178 (0 == wcscmp(vn, vnfloppy)))
1179 return true;
1180
1181 if (is_floppy_B_present() &&
1182 GetVolumeNameForVolumeMountPointW(FLOPPY_B, vnfloppy, SAL_N_ELEMENTS(vnfloppy)) &&
1183 (0 == wcscmp(vn, vnfloppy)))
1184 return true;
1185 }
1186 return false;
1187 }
1188
1189 static bool is_floppy_drive(const OUString& path)
1190 {
1191 static const LPCWSTR FLOPPY_DRV_LETTERS = L"AaBb";
1192
1193 // we must take into account that even a floppy
1194 // drive may be mounted to a directory so checking
1195 // for the drive letter alone is not sufficient
1196 // we must compare the unique volume name with
1197 // that of the available floppy disks
1198
1199 const sal_Unicode* pszPath = path.getStr();
1200 return ((wcschr(FLOPPY_DRV_LETTERS, pszPath[0]) && (L':' == pszPath[1])) || is_floppy_volume_mount_point(path));
1201 }
1202
1203 static bool is_volume_mount_point(const OUString& path)
1204 {
1205 OUString p(path);
1206 osl::systemPathRemoveSeparator(p);
1207
1208 bool is_volume_root = false;
1209
1210 if (!is_floppy_drive(p))
1211 {
1212 DWORD fattr = GetFileAttributesW(o3tl::toW(p.getStr()));
1213
1214 if ((INVALID_FILE_ATTRIBUTES != fattr) &&
1215 (FILE_ATTRIBUTE_REPARSE_POINT & fattr))
1216 {
1217 WIN32_FIND_DATAW find_data;
1218 HANDLE h_find = FindFirstFileW(o3tl::toW(p.getStr()), &find_data);
1219
1220 if (IsValidHandle(h_find) &&
1221 (FILE_ATTRIBUTE_REPARSE_POINT & find_data.dwFileAttributes) &&
1222 (IO_REPARSE_TAG_MOUNT_POINT == find_data.dwReserved0))
1223 {
1224 is_volume_root = true;
1225 }
1226 if (IsValidHandle(h_find))
1227 FindClose(h_find);
1228 }
1229 }
1230 return is_volume_root;
1231 }
1232
1233 static UINT get_volume_mount_point_drive_type(const OUString& path)
1234 {
1235 if (0 == path.getLength())
1236 return GetDriveTypeW(nullptr);
1237
1238 OUString p(path);
1239 osl::systemPathEnsureSeparator(p);
1240
1241 WCHAR vn[51];
1242 if (GetVolumeNameForVolumeMountPointW(o3tl::toW(p.getStr()), vn, SAL_N_ELEMENTS(vn)))
1243 return GetDriveTypeW(vn);
1244
1245 return DRIVE_NO_ROOT_DIR;
1246 }
1247
1248 static bool is_drivetype_request(sal_uInt32 field_mask)
1249 {
1250 return (field_mask & osl_VolumeInfo_Mask_Attributes);
1251 }
1252
1253 static oslFileError osl_get_drive_type(
1254 const OUString& path, oslVolumeInfo* pInfo)
1255 {
1256 // GetDriveType fails on empty volume mount points
1257 // see Knowledge Base Q244089
1258 UINT drive_type;
1259 if (is_volume_mount_point(path))
1260 drive_type = get_volume_mount_point_drive_type(path);
1261 else
1262 drive_type = GetDriveTypeW(o3tl::toW(path.getStr()));
1263
1264 if (DRIVE_NO_ROOT_DIR == drive_type)
1265 return oslTranslateFileError(ERROR_INVALID_DRIVE);
1266
1267 pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
1268
1269 switch (drive_type)
1270 {
1271 case DRIVE_CDROM:
1272 pInfo->uAttributes |= osl_Volume_Attribute_CompactDisc | osl_Volume_Attribute_Removeable;
1273 break;
1274 case DRIVE_REMOVABLE:
1275 pInfo->uAttributes |= osl_Volume_Attribute_Removeable;
1276 if (is_floppy_drive(path))
1277 pInfo->uAttributes |= osl_Volume_Attribute_FloppyDisk;
1278 break;
1279 case DRIVE_FIXED:
1280 pInfo->uAttributes |= osl_Volume_Attribute_FixedDisk;
1281 break;
1282 case DRIVE_RAMDISK:
1283 pInfo->uAttributes |= osl_Volume_Attribute_RAMDisk;
1284 break;
1285 case DRIVE_REMOTE:
1286 pInfo->uAttributes |= osl_Volume_Attribute_Remote;
1287 break;
1288 case DRIVE_UNKNOWN:
1289 pInfo->uAttributes = 0;
1290 break;
1291 default:
1292 pInfo->uValidFields &= ~osl_VolumeInfo_Mask_Attributes;
1293 pInfo->uAttributes = 0;
1294 break;
1295 }
1296 return osl_File_E_None;
1297 }
1298
1299 static bool is_volume_space_info_request(sal_uInt32 field_mask)
1300 {
1301 return (field_mask &
1302 (osl_VolumeInfo_Mask_TotalSpace |
1303 osl_VolumeInfo_Mask_UsedSpace |
1304 osl_VolumeInfo_Mask_FreeSpace));
1305 }
1306
1307 static void get_volume_space_information(
1308 const OUString& path, oslVolumeInfo *pInfo)
1309 {
1310 BOOL ret = GetDiskFreeSpaceExW(
1311 o3tl::toW(path.getStr()),
1312 reinterpret_cast<PULARGE_INTEGER>(&pInfo->uFreeSpace),
1313 reinterpret_cast<PULARGE_INTEGER>(&pInfo->uTotalSpace),
1314 nullptr);
1315
1316 if (ret)
1317 {
1318 pInfo->uUsedSpace = pInfo->uTotalSpace - pInfo->uFreeSpace;
1319 pInfo->uValidFields |= osl_VolumeInfo_Mask_TotalSpace |
1320 osl_VolumeInfo_Mask_UsedSpace |
1321 osl_VolumeInfo_Mask_FreeSpace;
1322 }
1323 }
1324
1325 static bool is_filesystem_attributes_request(sal_uInt32 field_mask)
1326 {
1327 return (field_mask &
1328 (osl_VolumeInfo_Mask_MaxNameLength |
1329 osl_VolumeInfo_Mask_MaxPathLength |
1330 osl_VolumeInfo_Mask_FileSystemName |
1331 osl_VolumeInfo_Mask_FileSystemCaseHandling));
1332 }
1333
1334 static oslFileError get_filesystem_attributes(
1335 const OUString& path, sal_uInt32 field_mask, oslVolumeInfo* pInfo)
1336 {
1337 pInfo->uAttributes = 0;
1338
1339 // osl_get_drive_type must be called first because
1340 // this function resets osl_VolumeInfo_Mask_Attributes
1341 // on failure
1342 if (is_drivetype_request(field_mask))
1343 {
1344 oslFileError osl_error = osl_get_drive_type(path, pInfo);
1345 if (osl_File_E_None != osl_error)
1346 return osl_error;
1347 }
1348 if (is_filesystem_attributes_request(field_mask))
1349 {
1350 /* the following two parameters can not be longer than MAX_PATH+1 */
1351 WCHAR vn[MAX_PATH+1];
1352 WCHAR fsn[MAX_PATH+1];
1353
1354 DWORD serial;
1355 DWORD mcl;
1356 DWORD flags;
1357
1358 LPCWSTR pszPath = o3tl::toW(path.getStr());
1359 if (GetVolumeInformationW(pszPath, vn, MAX_PATH+1, &serial, &mcl, &flags, fsn, MAX_PATH+1))
1360 {
1361 // Currently sal does not use this value, instead MAX_PATH is used
1362 pInfo->uValidFields |= osl_VolumeInfo_Mask_MaxNameLength;
1363 pInfo->uMaxNameLength = mcl;
1364
1365 // Should the uMaxPathLength be set to 32767, "\\?\" prefix allowes it
1366 pInfo->uValidFields |= osl_VolumeInfo_Mask_MaxPathLength;
1367 pInfo->uMaxPathLength = MAX_PATH;
1368
1369 pInfo->uValidFields |= osl_VolumeInfo_Mask_FileSystemName;
1370 rtl_uString_newFromStr(&pInfo->ustrFileSystemName, o3tl::toU(fsn));
1371
1372 // volumes (even NTFS) will always be considered case
1373 // insensitive because the Win32 API is not able to
1374 // deal with case sensitive volumes see M$ Knowledge Base
1375 // article 100625 that's why we never set the attribute
1376 // osl_Volume_Attribute_Case_Sensitive
1377
1378 if (flags & FS_CASE_IS_PRESERVED)
1379 pInfo->uAttributes |= osl_Volume_Attribute_Case_Is_Preserved;
1380
1381 pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
1382 }
1383 }
1384 return osl_File_E_None;
1385 }
1386
1387 static bool path_get_parent(OUString& path)
1388 {
1389 OSL_PRECOND(path.lastIndexOf(SLASH) == -1, "Path must not have slashes");
1390
1391 if (!has_path_parent(path))
1392 {
1393 sal_Int32 i = path.lastIndexOf(BACKSLASH);
1394 if (-1 < i)
1395 {
1396 path = OUString(path.getStr(), i);
1397 return true;
1398 }
1399 }
1400 return false;
1401 }
1402
1403 static void path_travel_to_volume_root(const OUString& system_path, OUString& volume_root)
1404 {
1405 OUString sys_path(system_path);
1406
1407 while(!is_volume_mount_point(sys_path) && path_get_parent(sys_path))
1408 /**/;
1409
1410 volume_root = sys_path;
1411 osl::systemPathEnsureSeparator(volume_root);
1412 }
1413
1414 oslFileError SAL_CALL osl_getVolumeInformation(
1415 rtl_uString *ustrURL, oslVolumeInfo *pInfo, sal_uInt32 uFieldMask )
1416 {
1417 if (!pInfo)
1418 return osl_File_E_INVAL;
1419
1420 OUString system_path;
1421 oslFileError error = osl_getSystemPathFromFileURL_(ustrURL, &system_path.pData, false);
1422
1423 if (osl_File_E_None != error)
1424 return error;
1425
1426 OUString volume_root;
1427 path_travel_to_volume_root(system_path, volume_root);
1428
1429 pInfo->uValidFields = 0;
1430
1431 if ((error = get_filesystem_attributes(volume_root, uFieldMask, pInfo)) != osl_File_E_None)
1432 return error;
1433
1434 if (is_volume_space_info_request(uFieldMask))
1435 get_volume_space_information(volume_root, pInfo);
1436
1437 if (uFieldMask & osl_VolumeInfo_Mask_DeviceHandle)
1438 {
1439 error = osl_getFileURLFromSystemPath(volume_root.pData, reinterpret_cast<rtl_uString**>(&pInfo->pDeviceHandle));
1440 if (error != osl_File_E_None)
1441 return error;
1442 pInfo->uValidFields |= osl_VolumeInfo_Mask_DeviceHandle;
1443 }
1444
1445 return osl_File_E_None;
1446 }
1447
1448 static oslFileError osl_getDriveInfo(
1449 oslDirectoryItem Item, oslFileStatus *pStatus, sal_uInt32 uFieldMask)
1450 {
1451 DirectoryItem_Impl *pItemImpl = static_cast<DirectoryItem_Impl *>(Item);
1452 WCHAR cDrive[3] = L"A:";
1453 WCHAR cRoot[4] = L"A:\\";
1454
1455 if ( !pItemImpl )
1456 return osl_File_E_INVAL;
1457
1458 pStatus->uValidFields = 0;
1459
1460 cDrive[0] = pItemImpl->cDriveString[0];
1461 cRoot[0] = pItemImpl->cDriveString[0];
1462
1463 if ( uFieldMask & osl_FileStatus_Mask_FileName )
1464 {
1465 if ( pItemImpl->cDriveString[0] == '\\' && pItemImpl->cDriveString[1] == '\\' )
1466 {
1467 LPCWSTR lpFirstBkSlash = wcschr( &pItemImpl->cDriveString[2], '\\' );
1468
1469 if ( lpFirstBkSlash && lpFirstBkSlash[1] )
1470 {
1471 LPCWSTR lpLastBkSlash = wcschr( &lpFirstBkSlash[1], '\\' );
1472
1473 if ( lpLastBkSlash )
1474 rtl_uString_newFromStr_WithLength( &pStatus->ustrFileName, o3tl::toU(&lpFirstBkSlash[1]), lpLastBkSlash - lpFirstBkSlash - 1 );
1475 else
1476 rtl_uString_newFromStr( &pStatus->ustrFileName, o3tl::toU(&lpFirstBkSlash[1]) );
1477 pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1478 }
1479 }
1480 else switch ( GetDriveTypeW( cRoot ) )
1481 {
1482 case DRIVE_REMOTE:
1483 {
1484 WCHAR szBuffer[1024];
1485 DWORD const dwBufsizeConst = SAL_N_ELEMENTS(szBuffer);
1486 DWORD dwBufsize = dwBufsizeConst;
1487
1488 DWORD dwResult = WNetGetConnectionW( cDrive, szBuffer, &dwBufsize );
1489 if ( NO_ERROR == dwResult )
1490 {
1491 WCHAR szFileName[dwBufsizeConst + 16];
1492
1493 swprintf( szFileName, L"%s [%s]", cDrive, szBuffer );
1494 rtl_uString_newFromStr( &pStatus->ustrFileName, o3tl::toU(szFileName) );
1495 }
1496 else
1497 rtl_uString_newFromStr( &pStatus->ustrFileName, o3tl::toU(cDrive) );
1498 }
1499 pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1500 break;
1501 case DRIVE_FIXED:
1502 {
1503 WCHAR szVolumeNameBuffer[1024];
1504 DWORD const dwBufsizeConst = SAL_N_ELEMENTS(szVolumeNameBuffer);
1505
1506 if ( GetVolumeInformationW( cRoot, szVolumeNameBuffer, dwBufsizeConst, nullptr, nullptr, nullptr, nullptr, 0 ) )
1507 {
1508 WCHAR szFileName[dwBufsizeConst + 16];
1509
1510 swprintf( szFileName, L"%s [%s]", cDrive, szVolumeNameBuffer );
1511 rtl_uString_newFromStr( &pStatus->ustrFileName, o3tl::toU(szFileName) );
1512 }
1513 else
1514 rtl_uString_newFromStr( &pStatus->ustrFileName, o3tl::toU(cDrive) );
1515 }
1516 pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1517 break;
1518 case DRIVE_CDROM:
1519 case DRIVE_REMOVABLE:
1520 pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1521 rtl_uString_newFromStr( &pStatus->ustrFileName, o3tl::toU(cRoot) );
1522 break;
1523 case DRIVE_UNKNOWN:
1524 default:
1525 break;
1526 }
1527 }
1528
1529 pStatus->eType = osl_File_Type_Volume;
1530 pStatus->uValidFields |= osl_FileStatus_Mask_Type;
1531
1532 if ( uFieldMask & osl_FileStatus_Mask_FileURL )
1533 {
1534 rtl_uString *ustrSystemPath = nullptr;
1535
1536 rtl_uString_newFromStr( &ustrSystemPath, o3tl::toU(pItemImpl->cDriveString) );
1537 oslFileError error = osl_getFileURLFromSystemPath( ustrSystemPath, &pStatus->ustrFileURL );
1538 rtl_uString_release( ustrSystemPath );
1539 if (error != osl_File_E_None)
1540 return error;
1541 pStatus->uValidFields |= osl_FileStatus_Mask_FileURL;
1542 }
1543 return osl_File_E_None;
1544 }
1545
1546 static oslFileError osl_getServerInfo(
1547 oslDirectoryItem Item, oslFileStatus *pStatus, sal_uInt32 uFieldMask )
1548 {
1549 DirectoryItem_Impl *pItemImpl = static_cast<DirectoryItem_Impl *>(Item);
1550 if ( !pItemImpl )
1551 return osl_File_E_INVAL;
1552
1553 pStatus->uValidFields = 0;
1554 pStatus->eType = osl_File_Type_Directory;
1555 pStatus->uValidFields |= osl_FileStatus_Mask_Type;
1556
1557 if ( uFieldMask & osl_FileStatus_Mask_FileURL )
1558 {
1559 oslFileError error = osl_getFileURLFromSystemPath( pItemImpl->m_pFullPath, &pStatus->ustrFileURL );
1560 if (error != osl_File_E_None)
1561 return error;
1562 pStatus->uValidFields |= osl_FileStatus_Mask_FileURL;
1563 }
1564 return osl_File_E_None;
1565 }
1566
1567 oslFileError SAL_CALL osl_getFileStatus(
1568 oslDirectoryItem Item,
1569 oslFileStatus *pStatus,
1570 sal_uInt32 uFieldMask )
1571 {
1572 DirectoryItem_Impl *pItemImpl = static_cast<DirectoryItem_Impl *>(Item);
1573
1574 if ( !pItemImpl )
1575 return osl_File_E_INVAL;
1576
1577 switch ( pItemImpl->uType )
1578 {
1579 case DIRECTORYITEM_DRIVE:
1580 return osl_getDriveInfo( Item, pStatus, uFieldMask );
1581 case DIRECTORYITEM_SERVER:
1582 return osl_getServerInfo( Item, pStatus, uFieldMask );
1583 default:
1584 break;
1585 }
1586
1587 OUString sFullPath(pItemImpl->m_pFullPath);
1588
1589 // Prefix long paths, windows API calls expect this prefix
1590 // (only local paths starting with something like C: or D:)
1591 if (sFullPath.getLength() >= MAX_PATH && isalpha(sFullPath[0]) && sFullPath[1] == ':')
1592 sFullPath = "\\\\?\\" + sFullPath;
1593
1594 if ( uFieldMask & osl_FileStatus_Mask_Validate )
1595 {
1596 HANDLE hFind = FindFirstFileW( o3tl::toW(sFullPath.getStr() ), &pItemImpl->FindData );
1597
1598 if ( hFind != INVALID_HANDLE_VALUE )
1599 FindClose( hFind );
1600 else
1601 return oslTranslateFileError( GetLastError() );
1602
1603 uFieldMask &= ~ osl_FileStatus_Mask_Validate;
1604 }
1605
1606 /* If no fields to retrieve left ignore pStatus */
1607 if ( !uFieldMask )
1608 return osl_File_E_None;
1609
1610 /* Otherwise, this must be a valid pointer */
1611 if ( !pStatus )
1612 return osl_File_E_INVAL;
1613
1614 if ( pStatus->uStructSize != sizeof(oslFileStatus) )
1615 return osl_File_E_INVAL;
1616
1617 pStatus->uValidFields = 0;
1618
1619 /* File time stamps */
1620
1621 if ( (uFieldMask & osl_FileStatus_Mask_ModifyTime) &&
1622 FileTimeToTimeValue( &pItemImpl->FindData.ftLastWriteTime, &pStatus->aModifyTime ) )
1623 pStatus->uValidFields |= osl_FileStatus_Mask_ModifyTime;
1624
1625 if ( (uFieldMask & osl_FileStatus_Mask_AccessTime) &&
1626 FileTimeToTimeValue( &pItemImpl->FindData.ftLastAccessTime, &pStatus->aAccessTime ) )
1627 pStatus->uValidFields |= osl_FileStatus_Mask_AccessTime;
1628
1629 if ( (uFieldMask & osl_FileStatus_Mask_CreationTime) &&
1630 FileTimeToTimeValue( &pItemImpl->FindData.ftCreationTime, &pStatus->aCreationTime ) )
1631 pStatus->uValidFields |= osl_FileStatus_Mask_CreationTime;
1632
1633 /* Most of the fields are already set, regardless of required fields */
1634
1635 rtl_uString_newFromStr( &pStatus->ustrFileName, o3tl::toU(pItemImpl->FindData.cFileName) );
1636 pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1637
1638 if ((FILE_ATTRIBUTE_REPARSE_POINT & pItemImpl->FindData.dwFileAttributes) &&
1639 (IO_REPARSE_TAG_MOUNT_POINT == pItemImpl->FindData.dwReserved0))
1640 pStatus->eType = osl_File_Type_Volume;
1641 else if (pItemImpl->FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1642 pStatus->eType = osl_File_Type_Directory;
1643 else
1644 pStatus->eType = osl_File_Type_Regular;
1645
1646 pStatus->uValidFields |= osl_FileStatus_Mask_Type;
1647
1648 pStatus->uAttributes = pItemImpl->FindData.dwFileAttributes;
1649 pStatus->uValidFields |= osl_FileStatus_Mask_Attributes;
1650
1651 pStatus->uFileSize = static_cast<sal_uInt64>(pItemImpl->FindData.nFileSizeLow) + (static_cast<sal_uInt64>(pItemImpl->FindData.nFileSizeHigh) << 32);
1652 pStatus->uValidFields |= osl_FileStatus_Mask_FileSize;
1653
1654 if ( uFieldMask & osl_FileStatus_Mask_LinkTargetURL )
1655 {
1656 oslFileError error = osl_getFileURLFromSystemPath( sFullPath.pData, &pStatus->ustrLinkTargetURL );
1657 if (error != osl_File_E_None)
1658 return error;
1659
1660 pStatus->uValidFields |= osl_FileStatus_Mask_LinkTargetURL;
1661 }
1662
1663 if ( uFieldMask & osl_FileStatus_Mask_FileURL )
1664 {
1665 if ( !pItemImpl->bFullPathNormalized )
1666 {
1667 ::osl::LongPathBuffer< sal_Unicode > aBuffer( MAX_LONG_PATH );
1668 sal_uInt32 nNewLen = GetCaseCorrectPathName( o3tl::toW( sFullPath.getStr() ),
1669 o3tl::toW( aBuffer ),
1670 aBuffer.getBufSizeInSymbols(),
1671 true );
1672
1673 if ( nNewLen )
1674 {
1675 rtl_uString_newFromStr( &pItemImpl->m_pFullPath, aBuffer );
1676 sFullPath = OUString( pItemImpl->m_pFullPath );
1677 pItemImpl->bFullPathNormalized = TRUE;
1678 }
1679 }
1680
1681 oslFileError error = osl_getFileURLFromSystemPath( sFullPath.pData, &pStatus->ustrFileURL );
1682 if (error != osl_File_E_None)
1683 return error;
1684 pStatus->uValidFields |= osl_FileStatus_Mask_FileURL;
1685 }
1686
1687 return osl_File_E_None;
1688 }
1689
1690 oslFileError SAL_CALL osl_setFileAttributes(
1691 rtl_uString *ustrFileURL,
1692 sal_uInt64 uAttributes )
1693 {
1694 oslFileError error;
1695 rtl_uString *ustrSysPath = nullptr;
1696 DWORD dwFileAttributes;
1697 BOOL fSuccess;
1698
1699 // Converts the normalized path into a systempath
1700 error = osl_getSystemPathFromFileURL_( ustrFileURL, &ustrSysPath, false );
1701
1702 if ( osl_File_E_None != error )
1703 return error;
1704
1705 dwFileAttributes = GetFileAttributesW( o3tl::toW(rtl_uString_getStr(ustrSysPath)) );
1706
1707 if ( DWORD(-1) != dwFileAttributes )
1708 {
1709 dwFileAttributes &= ~(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN);
1710
1711 if ( uAttributes & osl_File_Attribute_ReadOnly )
1712 dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
1713
1714 if ( uAttributes & osl_File_Attribute_Hidden )
1715 dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
1716
1717 fSuccess = SetFileAttributesW( o3tl::toW(rtl_uString_getStr(ustrSysPath)), dwFileAttributes );
1718 }
1719 else
1720 {
1721 fSuccess = FALSE;
1722 }
1723
1724 if ( !fSuccess )
1725 error = oslTranslateFileError( GetLastError() );
1726
1727 rtl_uString_release( ustrSysPath );
1728
1729 return error;
1730 }
1731
1732 oslFileError SAL_CALL osl_setFileTime(
1733 rtl_uString *filePath,
1734 const TimeValue *aCreationTime,
1735 const TimeValue *aLastAccessTime,
1736 const TimeValue *aLastWriteTime)
1737 {
1738 oslFileError error;
1739 rtl_uString *sysPath=nullptr;
1740 FILETIME *lpCreationTime=nullptr;
1741 FILETIME *lpLastAccessTime=nullptr;
1742 FILETIME *lpLastWriteTime=nullptr;
1743 FILETIME ftCreationTime;
1744 FILETIME ftLastAccessTime;
1745 FILETIME ftLastWriteTime;
1746 HANDLE hFile;
1747 BOOL fSuccess;
1748
1749 error=osl_getSystemPathFromFileURL_(filePath, &sysPath, false);
1750
1751 if (error==osl_File_E_INVAL)
1752 return error;
1753
1754 hFile=CreateFileW(o3tl::toW(rtl_uString_getStr(sysPath)), GENERIC_WRITE, 0, nullptr , OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
1755 rtl_uString_release(sysPath);
1756
1757 if (hFile==INVALID_HANDLE_VALUE)
1758 return osl_File_E_NOENT;
1759
1760 if (TimeValueToFileTime(aCreationTime, &ftCreationTime))
1761 lpCreationTime=&ftCreationTime;
1762
1763 if (TimeValueToFileTime(aLastAccessTime, &ftLastAccessTime))
1764 lpLastAccessTime=&ftLastAccessTime;
1765
1766 if (TimeValueToFileTime(aLastWriteTime, &ftLastWriteTime))
1767 lpLastWriteTime=&ftLastWriteTime;
1768
1769 fSuccess=SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
1770
1771 CloseHandle(hFile);
1772
1773 if (!fSuccess)
1774 return osl_File_E_INVAL;
1775 else
1776 return osl_File_E_None;
1777 }
1778
1779 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE