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