sal/osl/os2/file.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: file.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 /************************************************************************
  33  *   ToDo
  34  *
  35  *   Fix osl_getCanonicalName
  36  *
  37  *   - Fix: check for corresponding struct sizes in exported functions
  38  *   - check size/use of oslDirectory
  39  *   - check size/use of oslDirectoryItem
  40  *   - check size/use of oslFileStatus
  41  *   - check size/use of oslVolumeDeviceHandle
  42  *   - check size/use of oslVolumeInfo
  43  *   - check size/use of oslFileHandle
  44  ***********************************************************************/
  45
  46 #define INCL_DOSDEVIOCTL                        // OS2 device definitions
  47
  48 #include "system.h"
  49 #include <rtl/alloc.h>
  50
  51 #include "osl/file.hxx"
  52
  53
  54 #include <sal/types.h>
  55 #include <osl/thread.h>
  56 #include <osl/diagnose.h>
  57 #include "file_error_transl.h"
  58 #include <osl/time.h>
  59
  60 #ifndef _FILE_URL_H_
  61 #include "file_url.h"
  62 #endif
  63
  64 #include "file_path_helper.hxx"
  65 #include "uunxapi.hxx"
  66
  67 #ifndef _STRING_H_
  68 #include <string.h>
  69 #endif
  70
  71 #ifndef _CTYPE_H_
  72 #include <ctype.h>
  73 #endif
  74
  75 #ifndef _WCHAR_H_
  76 #include <wchar.h>
  77 #endif
  78
  79 #if OSL_DEBUG_LEVEL > 1
  80     extern void debug_ustring(rtl_uString*);
  81 #endif
  82
  83
  84 #ifdef DEBUG_OSL_FILE
  85 #       define PERROR( a, b ) perror( a ); fprintf( stderr, b )
  86 #else
  87 #       define PERROR( a, b )
  88 #endif
  89
  90 extern "C" oslFileHandle osl_createFileHandleFromFD( int fd );
  91
  92     struct errentry errtable[] = {
  93         {  NO_ERROR,                     osl_File_E_None     },  /* 0 */
  94         {  ERROR_INVALID_FUNCTION,       osl_File_E_INVAL    },  /* 1 */
  95         {  ERROR_FILE_NOT_FOUND,         osl_File_E_NOENT    },  /* 2 */
  96         {  ERROR_PATH_NOT_FOUND,         osl_File_E_NOENT    },  /* 3 */
  97         {  ERROR_TOO_MANY_OPEN_FILES,    osl_File_E_MFILE    },  /* 4 */
  98         {  ERROR_ACCESS_DENIED,          osl_File_E_ACCES    },  /* 5 */
  99         {  ERROR_INVALID_HANDLE,         osl_File_E_BADF     },  /* 6 */
 100         {  ERROR_ARENA_TRASHED,          osl_File_E_NOMEM    },  /* 7 */
 101         {  ERROR_NOT_ENOUGH_MEMORY,      osl_File_E_NOMEM    },  /* 8 */
 102         {  ERROR_INVALID_BLOCK,          osl_File_E_NOMEM    },  /* 9 */
 103         {  ERROR_BAD_ENVIRONMENT,        osl_File_E_2BIG     },  /* 10 */
 104         {  ERROR_BAD_FORMAT,             osl_File_E_NOEXEC   },  /* 11 */
 105         {  ERROR_INVALID_ACCESS,         osl_File_E_INVAL    },  /* 12 */
 106         {  ERROR_INVALID_DATA,           osl_File_E_INVAL    },  /* 13 */
 107         {  ERROR_INVALID_DRIVE,          osl_File_E_NOENT    },  /* 15 */
 108         {  ERROR_CURRENT_DIRECTORY,      osl_File_E_ACCES    },  /* 16 */
 109         {  ERROR_NOT_SAME_DEVICE,        osl_File_E_XDEV     },  /* 17 */
 110         {  ERROR_NO_MORE_FILES,          osl_File_E_NOENT    },  /* 18 */
 111         {  ERROR_NOT_READY,              osl_File_E_NOTREADY },  /* 21 */
 112         {  ERROR_LOCK_VIOLATION,         osl_File_E_ACCES    },  /* 33 */
 113         {  ERROR_BAD_NETPATH,            osl_File_E_NOENT    },  /* 53 */
 114         {  ERROR_NETWORK_ACCESS_DENIED,  osl_File_E_ACCES    },  /* 65 */
 115         {  ERROR_BAD_NET_NAME,           osl_File_E_NOENT    },  /* 67 */
 116         {  ERROR_FILE_EXISTS,            osl_File_E_EXIST    },  /* 80 */
 117         {  ERROR_CANNOT_MAKE,            osl_File_E_ACCES    },  /* 82 */
 118         {  ERROR_FAIL_I24,               osl_File_E_ACCES    },  /* 83 */
 119         {  ERROR_INVALID_PARAMETER,      osl_File_E_INVAL    },  /* 87 */
 120         {  ERROR_NO_PROC_SLOTS,          osl_File_E_AGAIN    },  /* 89 */
 121         {  ERROR_DRIVE_LOCKED,           osl_File_E_ACCES    },  /* 108 */
 122         {  ERROR_BROKEN_PIPE,            osl_File_E_PIPE     },  /* 109 */
 123         {  ERROR_DISK_FULL,              osl_File_E_NOSPC    },  /* 112 */
 124         {  ERROR_INVALID_TARGET_HANDLE,  osl_File_E_BADF     },  /* 114 */
 125         {  ERROR_INVALID_HANDLE,         osl_File_E_INVAL    },  /* 124 */
 126         {  ERROR_WAIT_NO_CHILDREN,       osl_File_E_CHILD    },  /* 128 */
 127         {  ERROR_CHILD_NOT_COMPLETE,     osl_File_E_CHILD    },  /* 129 */
 128         {  ERROR_DIRECT_ACCESS_HANDLE,   osl_File_E_BADF     },  /* 130 */
 129         {  ERROR_NEGATIVE_SEEK,          osl_File_E_INVAL    },  /* 131 */
 130         {  ERROR_SEEK_ON_DEVICE,         osl_File_E_ACCES    },  /* 132 */
 131         {  ERROR_DIR_NOT_EMPTY,          osl_File_E_NOTEMPTY },  /* 145 */
 132         {  ERROR_NOT_LOCKED,             osl_File_E_ACCES    },  /* 158 */
 133         {  ERROR_BAD_PATHNAME,           osl_File_E_NOENT    },  /* 161 */
 134         {  ERROR_MAX_THRDS_REACHED,      osl_File_E_AGAIN    },  /* 164 */
 135         {  ERROR_LOCK_FAILED,            osl_File_E_ACCES    },  /* 167 */
 136         {  ERROR_ALREADY_EXISTS,         osl_File_E_EXIST    },  /* 183 */
 137         {  ERROR_FILENAME_EXCED_RANGE,   osl_File_E_NOENT    },  /* 206 */
 138         {  ERROR_NESTING_NOT_ALLOWED,    osl_File_E_AGAIN    },  /* 215 */
 139         {  ERROR_DIRECTORY,              osl_File_E_NOENT    },  /* 267 */
 140         //{  ERROR_NOT_ENOUGH_QUOTA,       osl_File_E_NOMEM    }    /* 1816 */
 141     };
 142
 143     #define ELEMENTS_OF_ARRAY(arr) (sizeof(arr)/(sizeof((arr)[0])))
 144
 145     //#####################################################
 146     oslFileError MapError(APIRET dwError)
 147     {
 148         for (int i = 0; i < ELEMENTS_OF_ARRAY(errtable); ++i )
 149         {
 150             if (dwError == errtable[i].oscode)
 151                 return static_cast<oslFileError>(errtable[i].errnocode);
 152         }
 153         return osl_File_E_INVAL;
 154     }
 155
 156 /******************************************************************************
 157  *
 158  *                  static members
 159  *
 160  *****************************************************************************/
 161
 162 static const char * pFileLockEnvVar = (char *) -1;
 163
 164
 165 /******************************************************************************
 166  *
 167  *                  C-String Function Declarations
 168  *
 169  *****************************************************************************/
 170
 171 static oslFileError osl_psz_getVolumeInformation(const sal_Char* , oslVolumeInfo* pInfo, sal_uInt32 uFieldMask);
 172 static oslFileError osl_psz_removeFile(const sal_Char* pszPath);
 173 static oslFileError osl_psz_createDirectory(const sal_Char* pszPath);
 174 static oslFileError osl_psz_removeDirectory(const sal_Char* pszPath);
 175 static oslFileError osl_psz_copyFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
 176 static oslFileError osl_psz_moveFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
 177 static oslFileError osl_psz_setFileTime(const sal_Char* strFilePath, const TimeValue* pCreationTime, const TimeValue* pLastAccessTime, const TimeValue* pLastWriteTime);
 178
 179
 180 /******************************************************************************
 181  *
 182  *                  Static Module Utility Function Declarations
 183  *
 184  *****************************************************************************/
 185
 186 static oslFileError  oslDoCopy(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, mode_t nMode, size_t nSourceSize, int DestFileExists);
 187 static oslFileError  oslChangeFileModes(const sal_Char* pszFileName, mode_t nMode, time_t nAcTime, time_t nModTime, uid_t nUID, gid_t nGID);
 188 static int           oslDoCopyLink(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName);
 189 static int           oslDoCopyFile(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, size_t nSourceSize, mode_t mode);
 190 static oslFileError  oslDoMoveFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
 191 rtl_uString*  oslMakeUStrFromPsz(const sal_Char* pszStr,rtl_uString** uStr);
 192
 193 /******************************************************************************
 194  *
 195  *                  Non-Static Utility Function Declarations
 196  *
 197  *****************************************************************************/
 198
 199 extern "C" int UnicodeToText( char *, size_t, const sal_Unicode *, sal_Int32 );
 200 extern "C" int TextToUnicode(
 201     const char* text, size_t text_buffer_size,  sal_Unicode* unic_text, sal_Int32 unic_text_buffer_size);
 202
 203 /******************************************************************************
 204  *
 205  *                  'removeable device' aka floppy functions
 206  *
 207  *****************************************************************************/
 208
 209 static oslVolumeDeviceHandle  osl_isFloppyDrive(const sal_Char* pszPath);
 210 static oslFileError   osl_mountFloppy(oslVolumeDeviceHandle hFloppy);
 211 static oslFileError   osl_unmountFloppy(oslVolumeDeviceHandle hFloppy);
 212
 213 #ifdef DEBUG_OSL_FILE
 214 static void           osl_printFloppyHandle(oslVolumeDeviceHandleImpl* hFloppy);
 215 #endif
 216
 217 /**********************************************
 218  * _osl_openLocalRoot
 219  * enumerate available drives
 220  *********************************************/
 221 static oslFileError _osl_openLocalRoot( rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
 222 {
 223     rtl_uString         *ustrSystemPath = NULL;
 224     oslFileError        error;
 225
 226     if ( !pDirectory )
 227         return osl_File_E_INVAL;
 228
 229     *pDirectory = NULL;
 230
 231     error = osl_getSystemPathFromFileURL_Ex( strDirectoryPath, &ustrSystemPath, sal_False );
 232
 233     if ( osl_File_E_None == error )
 234     {
 235         /* create and initialize impl structure */
 236         DirectoryImpl* pDirImpl = (DirectoryImpl*) rtl_allocateMemory( sizeof(DirectoryImpl) );
 237         if( pDirImpl )
 238         {
 239             ULONG   ulDriveNum;
 240             APIRET  rc;
 241             pDirImpl->uType = DIRECTORYTYPE_LOCALROOT;
 242             pDirImpl->ustrPath = ustrSystemPath;
 243             rc = DosQueryCurrentDisk (&ulDriveNum, &pDirImpl->ulDriveMap);
 244             pDirImpl->pDirStruct = 0;
 245             pDirImpl->ulNextDrive = 1;
 246             pDirImpl->ulNextDriveMask = 1;
 247
 248             // determine number of floppy-drives
 249             BYTE nFloppies;
 250             rc = DosDevConfig( (void*) &nFloppies, DEVINFO_FLOPPY );
 251             if (nFloppies == 0) {
 252                 // if no floppies, start with 3rd drive (C:)
 253                 pDirImpl->ulNextDrive = 3;
 254                 pDirImpl->ulNextDriveMask <<= 2;
 255             } else if (nFloppies == 1) {
 256                 // mask drive B (second bit) in this case
 257                 pDirImpl->ulDriveMap &= ~0x02;
 258             }
 259             *pDirectory = (oslDirectory) pDirImpl;
 260             return osl_File_E_None;
 261         }
 262         else
 263         {
 264             errno = osl_File_E_NOMEM;
 265         }
 266
 267     }
 268
 269     rtl_uString_release( ustrSystemPath );
 270     return error;
 271 }
 272
 273 /**********************************************
 274  * _osl_getNextDrive
 275  *********************************************/
 276 static oslFileError SAL_CALL _osl_getNextDrive(
 277     oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 uHint )
 278 {
 279     DirectoryImpl       *pDirImpl = (DirectoryImpl *)Directory;
 280     DirectoryItem_Impl  *pItemImpl = NULL;
 281     rtl_uString                 * ustrDrive = NULL;
 282     BOOL                                fSuccess;
 283     char                                buffer[3];
 284
 285     uHint = uHint; /* avoid warnings */
 286
 287     if ( !pItem )
 288         return osl_File_E_INVAL;
 289
 290     *pItem = NULL;
 291
 292     if ( !pDirImpl )
 293         return osl_File_E_INVAL;
 294
 295     while( pDirImpl->ulNextDrive <= 26)
 296     {
 297         // exit if  bit==1 -> drive found
 298         if (pDirImpl->ulDriveMap & pDirImpl->ulNextDriveMask) {
 299
 300             /* convert file name to unicode */
 301             buffer[0] = '@' + pDirImpl->ulNextDrive;
 302             buffer[1] = ':';
 303             buffer[2] = 0;
 304
 305             pItemImpl = (DirectoryItem_Impl*) rtl_allocateMemory(sizeof(DirectoryItem_Impl));
 306             if ( !pItemImpl )
 307                 return osl_File_E_NOMEM;
 308
 309             memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
 310             pItemImpl->uType = DIRECTORYITEM_DRIVE;
 311             pItemImpl->nRefCount = 1;
 312
 313             rtl_string2UString( &pItemImpl->ustrDrive, buffer, 3,
 314                 osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
 315             OSL_ASSERT(pItemImpl->ustrDrive != 0);
 316
 317             /* use drive as directory item */
 318             *pItem = (oslDirectoryItem) pItemImpl;
 319         }
 320         // scan next bit position
 321         pDirImpl->ulNextDrive++;
 322         pDirImpl->ulNextDriveMask <<= 1;
 323
 324         if (*pItem)     // item assigned, return now.
 325             return osl_File_E_None;
 326     }
 327
 328     // no more items
 329     return osl_File_E_NOENT;
 330 }
 331
 332 /**********************************************
 333  * _osl_readdir_impl_
 334  *
 335  * readdir wrapper, filters out "." and ".."
 336  * on request
 337  *********************************************/
 338
 339 static struct dirent* _osl_readdir_impl_(DIR* pdir, sal_Bool bFilterLocalAndParentDir)
 340 {
 341     struct dirent* pdirent;
 342
 343     while ((pdirent = readdir(pdir)) != NULL)
 344     {
 345         if (bFilterLocalAndParentDir &&
 346             ((0 == strcmp(pdirent->d_name, ".")) || (0 == strcmp(pdirent->d_name, ".."))))
 347             continue;
 348         else
 349             break;
 350     }
 351
 352     return pdirent;
 353 }
 354
 355 /*******************************************************************
 356  *      osl_openDirectory
 357  ******************************************************************/
 358
 359 oslFileError SAL_CALL osl_openDirectory(rtl_uString* ustrDirectoryURL, oslDirectory* pDirectory)
 360 {
 361     rtl_uString* ustrSystemPath = NULL;
 362     oslFileError eRet;
 363
 364     char path[PATH_MAX];
 365
 366     OSL_ASSERT(ustrDirectoryURL && (ustrDirectoryURL->length > 0));
 367     OSL_ASSERT(pDirectory);
 368
 369     if (0 == ustrDirectoryURL->length )
 370         return osl_File_E_INVAL;
 371
 372     if ( 0 == rtl_ustr_compareIgnoreAsciiCase( ustrDirectoryURL->buffer, (const sal_Unicode*)L"file:///" ) )
 373         return _osl_openLocalRoot( ustrDirectoryURL, pDirectory );
 374
 375     /* convert file URL to system path */
 376     eRet = osl_getSystemPathFromFileURL_Ex(ustrDirectoryURL, &ustrSystemPath, sal_False);
 377
 378     if( osl_File_E_None != eRet )
 379         return eRet;
 380
 381     osl_systemPathRemoveSeparator(ustrSystemPath);
 382
 383     /* convert unicode path to text */
 384     if ( UnicodeToText( path, PATH_MAX, ustrSystemPath->buffer, ustrSystemPath->length ) )
 385     {
 386         // if only the drive is specified (x:), add a \ (x:\) otherwise current
 387         // directory is browsed instead of root.
 388         if (strlen( path) == 2 && path[1] == ':')
 389             strcat( path, "\\");
 390         /* open directory */
 391         DIR *pdir = opendir( path );
 392
 393         if( pdir )
 394         {
 395             /* create and initialize impl structure */
 396             DirectoryImpl* pDirImpl = (DirectoryImpl*) rtl_allocateMemory( sizeof(DirectoryImpl) );
 397
 398             if( pDirImpl )
 399             {
 400                 pDirImpl->uType = DIRECTORYTYPE_FILESYSTEM;
 401                 pDirImpl->pDirStruct = pdir;
 402                 pDirImpl->ustrPath = ustrSystemPath;
 403
 404                 *pDirectory = (oslDirectory) pDirImpl;
 405                 return osl_File_E_None;
 406             }
 407             else
 408             {
 409                 errno = ENOMEM;
 410                 closedir( pdir );
 411             }
 412         }
 413         else
 414             /* should be removed by optimizer in product version */
 415             PERROR( "osl_openDirectory", path );
 416     }
 417
 418     rtl_uString_release( ustrSystemPath );
 419
 420     return oslTranslateFileError(OSL_FET_ERROR, errno);
 421 }
 422
 423
 424 /****************************************************************************
 425  *      osl_getNextDirectoryItem
 426  ***************************************************************************/
 427
 428 oslFileError SAL_CALL osl_getNextDirectoryItem(oslDirectory Directory, oslDirectoryItem* pItem, sal_uInt32 uHint)
 429 {
 430     DirectoryImpl* pDirImpl     = (DirectoryImpl*)Directory;
 431     DirectoryItem_Impl  *pItemImpl = NULL;
 432     rtl_uString*      ustrFileName = NULL;
 433     rtl_uString*      ustrFilePath = NULL;
 434     struct dirent*    pEntry;
 435
 436     OSL_ASSERT(Directory);
 437     OSL_ASSERT(pItem);
 438
 439     if ((NULL == Directory) || (NULL == pItem))
 440         return osl_File_E_INVAL;
 441
 442     if ( pDirImpl->uType == DIRECTORYTYPE_LOCALROOT)
 443         return _osl_getNextDrive( Directory, pItem, uHint );
 444
 445     pEntry = _osl_readdir_impl_(pDirImpl->pDirStruct, sal_True);
 446
 447     if (NULL == pEntry)
 448         return osl_File_E_NOENT;
 449
 450     pItemImpl = (DirectoryItem_Impl*) rtl_allocateMemory(sizeof(DirectoryItem_Impl));
 451     if ( !pItemImpl )
 452         return osl_File_E_NOMEM;
 453
 454     memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
 455     pItemImpl->uType = DIRECTORYITEM_FILE;
 456     pItemImpl->nRefCount = 1;
 457     pItemImpl->d_attr = pEntry->d_attr;
 458
 459     /* convert file name to unicode */
 460     rtl_string2UString( &ustrFileName, pEntry->d_name, strlen( pEntry->d_name ),
 461         osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
 462     OSL_ASSERT(ustrFileName != 0);
 463
 464     osl_systemPathMakeAbsolutePath(pDirImpl->ustrPath, ustrFileName, &pItemImpl->ustrFilePath);
 465     rtl_uString_release( ustrFileName );
 466
 467     *pItem = (oslDirectoryItem)pItemImpl;
 468     return osl_File_E_None;
 469 }
 470
 471 /****************************************************************************/
 472 /*      osl_closeDirectory */
 473 /****************************************************************************/
 474
 475 oslFileError SAL_CALL osl_closeDirectory( oslDirectory Directory )
 476 {
 477     DirectoryImpl* pDirImpl = (DirectoryImpl*) Directory;
 478     oslFileError err = osl_File_E_None;
 479
 480     OSL_ASSERT( Directory );
 481
 482     if( NULL == pDirImpl )
 483         return osl_File_E_INVAL;
 484
 485     switch ( pDirImpl->uType )
 486     {
 487     case DIRECTORYTYPE_FILESYSTEM:
 488         if( closedir( pDirImpl->pDirStruct ) )
 489             err = oslTranslateFileError(OSL_FET_ERROR, errno);
 490         break;
 491     case DIRECTORYTYPE_LOCALROOT:
 492         err = osl_File_E_None;
 493         break;
 494 #if 0
 495     case DIRECTORYTYPE_NETROOT:
 496         {
 497             DWORD err = WNetCloseEnum(pDirImpl->hDirectory);
 498             eError = (err == NO_ERROR) ? osl_File_E_None : MapError(err);
 499         }
 500         break;
 501 #endif
 502     default:
 503         OSL_ENSURE( 0, "Invalid directory type" );
 504         break;
 505     }
 506
 507     /* cleanup members */
 508     rtl_uString_release( pDirImpl->ustrPath );
 509
 510     rtl_freeMemory( pDirImpl );
 511
 512     return err;
 513 }
 514
 515 /****************************************************************************/
 516 /*      osl_getDirectoryItem */
 517 /****************************************************************************/
 518
 519 oslFileError SAL_CALL osl_getDirectoryItem( rtl_uString* ustrFileURL, oslDirectoryItem* pItem )
 520 {
 521     rtl_uString*        strSysFilePath = NULL;
 522     oslFileError        error      = osl_File_E_INVAL;
 523     ULONG                       dwPathType;
 524     PATHTYPE            type = PATHTYPE_FILE;
 525
 526     OSL_ASSERT(ustrFileURL);
 527     OSL_ASSERT(pItem);
 528
 529     /* Assume failure */
 530     if ( !pItem )
 531         return osl_File_E_INVAL;
 532     *pItem = NULL;
 533
 534     if (0 == ustrFileURL->length || NULL == pItem)
 535         return osl_File_E_INVAL;
 536
 537     error = osl_getSystemPathFromFileURL_Ex(ustrFileURL, &strSysFilePath, sal_False);
 538
 539     if (osl_File_E_None != error)
 540         return error;
 541
 542     dwPathType = IsValidFilePath( strSysFilePath->buffer, NULL, VALIDATEPATH_NORMAL );
 543
 544     if ( dwPathType & PATHTYPE_IS_VOLUME )
 545         type = PATHTYPE_VOLUME;
 546     else if ( dwPathType & PATHTYPE_IS_SERVER )
 547         type = PATHTYPE_NETSERVER;
 548     else
 549         type = PATHTYPE_FILE;
 550
 551     switch ( type )
 552     {
 553     case PATHTYPE_NETSERVER:
 554         {
 555             DirectoryItem_Impl* pItemImpl =
 556                 reinterpret_cast<DirectoryItem_Impl*>(rtl_allocateMemory(sizeof(DirectoryItem_Impl)));
 557
 558             if ( !pItemImpl )
 559                 error = osl_File_E_NOMEM;
 560
 561             if ( osl_File_E_None == error )
 562             {
 563                 memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
 564                 pItemImpl->uType = DIRECTORYITEM_SERVER;
 565                 pItemImpl->nRefCount = 1;
 566                 rtl_uString_assign( &pItemImpl->ustrFilePath, strSysFilePath );
 567
 568                 *pItem = pItemImpl;
 569             }
 570         }
 571         break;
 572     case PATHTYPE_VOLUME:
 573         {
 574             DirectoryItem_Impl* pItemImpl =
 575                 reinterpret_cast<DirectoryItem_Impl*>(rtl_allocateMemory(sizeof(DirectoryItem_Impl)));
 576
 577             if ( !pItemImpl )
 578                 error = osl_File_E_NOMEM;
 579
 580             if ( osl_File_E_None == error )
 581             {
 582                 memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
 583                 pItemImpl->uType = DIRECTORYITEM_DRIVE;
 584                 pItemImpl->nRefCount = 1;
 585                 rtl_uString_assign( &pItemImpl->ustrDrive, strSysFilePath );
 586
 587                 if ( pItemImpl->ustrDrive->buffer[pItemImpl->ustrDrive->length-1] != sal_Unicode('\\') )
 588                     rtl_uString_newConcat( &pItemImpl->ustrDrive,
 589                                             pItemImpl->ustrDrive, rtl::OUString::createFromAscii( "\\" ).pData);
 590
 591                 *pItem = pItemImpl;
 592             }
 593         }
 594         break;
 595     default:
 596     case PATHTYPE_FILE:
 597         {
 598             if ( strSysFilePath->length > 0 && strSysFilePath->buffer[strSysFilePath->length - 1] == '\\' )
 599                 rtl_uString_newFromStr_WithLength( &strSysFilePath, strSysFilePath->buffer, strSysFilePath->length - 1 );
 600
 601             if (0 == access_u(strSysFilePath, F_OK))
 602             {
 603                 DirectoryItem_Impl      *pItemImpl =
 604                     reinterpret_cast<DirectoryItem_Impl*>(rtl_allocateMemory(sizeof(DirectoryItem_Impl)));
 605
 606                 memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
 607                 pItemImpl->uType = DIRECTORYITEM_FILE;
 608                 pItemImpl->nRefCount = 1;
 609                 rtl_uString_assign( &pItemImpl->ustrFilePath, strSysFilePath );
 610
 611                 *pItem = pItemImpl;
 612             }
 613             else
 614                 error = oslTranslateFileError(OSL_FET_ERROR, errno);
 615         }
 616         break;
 617     }
 618
 619     if ( strSysFilePath )
 620         rtl_uString_release( strSysFilePath );
 621
 622     return error;
 623 }
 624
 625 /****************************************************************************/
 626 /*      osl_acquireDirectoryItem */
 627 /****************************************************************************/
 628
 629 oslFileError osl_acquireDirectoryItem( oslDirectoryItem Item )
 630 {
 631     OSL_ASSERT( Item );
 632     DirectoryItem_Impl  *pItemImpl = (DirectoryItem_Impl *)Item;
 633
 634     if ( !pItemImpl )
 635         return osl_File_E_INVAL;
 636
 637     pItemImpl->nRefCount++;
 638     return osl_File_E_None;
 639 }
 640
 641 /****************************************************************************/
 642 /*      osl_releaseDirectoryItem */
 643 /****************************************************************************/
 644
 645 oslFileError osl_releaseDirectoryItem( oslDirectoryItem Item )
 646 {
 647     OSL_ASSERT( Item );
 648     DirectoryItem_Impl  *pItemImpl = (DirectoryItem_Impl *)Item;
 649
 650     if ( !pItemImpl )
 651         return osl_File_E_INVAL;
 652
 653     if ( ! --pItemImpl->nRefCount )
 654     {
 655         if (pItemImpl->ustrFilePath)
 656             rtl_uString_release( pItemImpl->ustrFilePath );
 657         if (pItemImpl->ustrDrive)
 658             rtl_uString_release( pItemImpl->ustrDrive );
 659         rtl_freeMemory( pItemImpl );
 660     }
 661     return osl_File_E_None;
 662 }
 663
 664 /****************************************************************************
 665  *      osl_createFileHandleFromFD
 666  ***************************************************************************/
 667
 668 oslFileHandle osl_createFileHandleFromFD( int fd )
 669 {
 670     oslFileHandleImpl* pHandleImpl = NULL;
 671
 672     if ( fd >= 0 )
 673     {
 674         pHandleImpl = (oslFileHandleImpl*) rtl_allocateMemory( sizeof(oslFileHandleImpl) );
 675
 676         if( pHandleImpl )
 677         {
 678             pHandleImpl->ustrFilePath = NULL;
 679             rtl_uString_new( &pHandleImpl->ustrFilePath );
 680             pHandleImpl->fd = fd;
 681
 682             /* FIXME: should detect whether the file has been locked */
 683             pHandleImpl->bLocked = sal_True;
 684         }
 685     }
 686
 687     return (oslFileHandle)pHandleImpl;
 688 }
 689
 690 /****************************************************************************
 691  *      osl_openFile
 692  ***************************************************************************/
 693
 694 oslFileError osl_openFile( rtl_uString* ustrFileURL, oslFileHandle* pHandle, sal_uInt32 uFlags )
 695 {
 696     oslFileHandleImpl* pHandleImpl = NULL;
 697     oslFileError eRet;
 698     rtl_uString* ustrFilePath = NULL;
 699
 700     char buffer[PATH_MAX];
 701     int  fd;
 702     int  mode  = S_IRUSR | S_IRGRP | S_IROTH;
 703     int  flags = O_RDONLY;
 704
 705     struct flock aflock;
 706
 707     /* locking the complete file */
 708     aflock.l_type = 0;
 709     aflock.l_whence = SEEK_SET;
 710     aflock.l_start = 0;
 711     aflock.l_len = 0;
 712
 713     OSL_ASSERT( ustrFileURL );
 714     OSL_ASSERT( pHandle );
 715
 716     if( ( 0 == ustrFileURL->length ) )
 717         return osl_File_E_INVAL;
 718
 719     /* convert file URL to system path */
 720     eRet = osl_getSystemPathFromFileURL( ustrFileURL, &ustrFilePath );
 721
 722     if( osl_File_E_None != eRet )
 723         return eRet;
 724
 725     osl_systemPathRemoveSeparator(ustrFilePath);
 726
 727     /* convert unicode path to text */
 728     if( UnicodeToText( buffer, PATH_MAX, ustrFilePath->buffer, ustrFilePath->length ) )
 729     {
 730         /* we do not open devices or such here */
 731         if( !( uFlags & osl_File_OpenFlag_Create ) )
 732         {
 733             struct stat aFileStat;
 734
 735             if( 0 > stat( buffer, &aFileStat ) )
 736             {
 737                 PERROR( "osl_openFile", buffer );
 738                 eRet = oslTranslateFileError(OSL_FET_ERROR, errno );
 739             }
 740
 741             else if( !S_ISREG( aFileStat.st_mode ) )
 742             {
 743                 eRet = osl_File_E_INVAL;
 744             }
 745         }
 746
 747         if( osl_File_E_None == eRet )
 748         {
 749             /*
 750              * set flags and mode
 751              */
 752
 753             if ( uFlags & osl_File_OpenFlag_Write )
 754             {
 755                 mode |= S_IWUSR | S_IWGRP | S_IWOTH;
 756                 flags = O_RDWR;
 757                 aflock.l_type = F_WRLCK;
 758             }
 759
 760             if ( uFlags & osl_File_OpenFlag_Create )
 761             {
 762                 mode |= S_IWUSR | S_IWGRP | S_IWOTH;
 763                 flags = O_CREAT | O_EXCL | O_RDWR;
 764             }
 765
 766             /* open the file */
 767             fd = open( buffer, flags | O_BINARY, mode);
 768             if ( fd >= 0 )
 769             {
 770                 sal_Bool bNeedsLock = ( ( uFlags & osl_File_OpenFlag_NoLock ) == 0 );
 771                 sal_Bool bLocked = sal_False;
 772                 if( bNeedsLock )
 773                 {
 774                     /* check if file lock is enabled and clear l_type member of flock otherwise */
 775                     if( (char *) -1 == pFileLockEnvVar )
 776                     {
 777                         /* FIXME: this is not MT safe */
 778                         pFileLockEnvVar = getenv("SAL_ENABLE_FILE_LOCKING");
 779
 780                         if( NULL == pFileLockEnvVar)
 781                             pFileLockEnvVar = getenv("STAR_ENABLE_FILE_LOCKING");
 782                     }
 783
 784                     if( NULL == pFileLockEnvVar )
 785                         aflock.l_type = 0;
 786
 787                     /* lock the file if flock.l_type is set */
 788                     bLocked = ( F_WRLCK != aflock.l_type || -1 != fcntl( fd, F_SETLK, &aflock ) );
 789                 }
 790
 791                 if ( !bNeedsLock || bLocked )
 792                 {
 793                     /* allocate memory for impl structure */
 794                     pHandleImpl = (oslFileHandleImpl*) rtl_allocateMemory( sizeof(oslFileHandleImpl) );
 795                     if( pHandleImpl )
 796                     {
 797                         pHandleImpl->ustrFilePath = ustrFilePath;
 798                         pHandleImpl->fd = fd;
 799                         pHandleImpl->bLocked = bLocked;
 800
 801                         *pHandle = (oslFileHandle) pHandleImpl;
 802
 803                         return osl_File_E_None;
 804                     }
 805                     else
 806                     {
 807                         errno = ENOMEM;
 808                     }
 809                 }
 810
 811                 close( fd );
 812             }
 813
 814             PERROR( "osl_openFile", buffer );
 815             eRet = oslTranslateFileError(OSL_FET_ERROR, errno );
 816         }
 817     }
 818     else
 819         eRet = osl_File_E_INVAL;
 820
 821     rtl_uString_release( ustrFilePath );
 822     return eRet;
 823 }
 824
 825 /****************************************************************************/
 826 /*      osl_closeFile */
 827 /****************************************************************************/
 828
 829 oslFileError osl_closeFile( oslFileHandle Handle )
 830 {
 831     oslFileHandleImpl* pHandleImpl = (oslFileHandleImpl *) Handle;
 832     oslFileError eRet = osl_File_E_INVAL;
 833
 834     OSL_ASSERT( Handle );
 835
 836     if( pHandleImpl )
 837     {
 838         rtl_uString_release( pHandleImpl->ustrFilePath );
 839
 840         /* release file lock if locking is enabled */
 841         if( pFileLockEnvVar )
 842         {
 843             struct flock aflock;
 844
 845             aflock.l_type = F_UNLCK;
 846             aflock.l_whence = SEEK_SET;
 847             aflock.l_start = 0;
 848             aflock.l_len = 0;
 849
 850             if ( pHandleImpl->bLocked )
 851             {
 852                 /* FIXME: check if file is really locked ?  */
 853
 854                 /* release the file share lock on this file */
 855                 if( -1 == fcntl( pHandleImpl->fd, F_SETLK, &aflock ) )
 856                     PERROR( "osl_closeFile", "unlock failed" );
 857             }
 858         }
 859
 860         if( 0 > close( pHandleImpl->fd ) )
 861         {
 862             eRet = oslTranslateFileError(OSL_FET_ERROR, errno );
 863         }
 864         else
 865             eRet = osl_File_E_None;
 866
 867         rtl_freeMemory( pHandleImpl );
 868     }
 869
 870     return eRet;
 871 }
 872
 873 /****************************************************************************/
 874 /*      osl_isEndOfFile */
 875 /****************************************************************************/
 876
 877 oslFileError SAL_CALL osl_isEndOfFile( oslFileHandle Handle, sal_Bool *pIsEOF )
 878 {
 879     oslFileHandleImpl* pHandleImpl = (oslFileHandleImpl *) Handle;
 880     oslFileError eRet = osl_File_E_INVAL;
 881
 882     if ( pHandleImpl)
 883     {
 884         long curPos = lseek( pHandleImpl->fd, 0, SEEK_CUR );
 885
 886         if ( curPos >= 0 )
 887         {
 888             long endPos = lseek( pHandleImpl->fd, 0, SEEK_END  );
 889
 890             if ( endPos >= 0 )
 891             {
 892                 *pIsEOF = ( curPos == endPos );
 893                 curPos = lseek( pHandleImpl->fd, curPos, SEEK_SET );
 894
 895                 if ( curPos >= 0 )
 896                     eRet = osl_File_E_None;
 897                 else
 898                     eRet = oslTranslateFileError(OSL_FET_ERROR, errno );
 899             }
 900             else
 901                 eRet = oslTranslateFileError(OSL_FET_ERROR, errno );
 902         }
 903         else
 904             eRet = oslTranslateFileError(OSL_FET_ERROR, errno );
 905     }
 906
 907     return eRet;
 908 }
 909
 910
 911 /****************************************************************************/
 912 /*      osl_moveFile */
 913 /****************************************************************************/
 914
 915 oslFileError osl_moveFile( rtl_uString* ustrFileURL, rtl_uString* ustrDestURL )
 916 {
 917     char srcPath[PATH_MAX];
 918     char destPath[PATH_MAX];
 919     oslFileError eRet;
 920     APIRET rc;
 921
 922     OSL_ASSERT( ustrFileURL );
 923     OSL_ASSERT( ustrDestURL );
 924
 925     /* convert source url to system path */
 926     eRet = FileURLToPath( srcPath, PATH_MAX, ustrFileURL );
 927     if( eRet != osl_File_E_None )
 928         return eRet;
 929
 930     /* convert destination url to system path */
 931     eRet = FileURLToPath( destPath, PATH_MAX, ustrDestURL );
 932     if( eRet != osl_File_E_None )
 933         return eRet;
 934
 935     //YD 01/05/06 rename() can overwrite existing files.
 936     rc = DosDelete( (PCSZ)destPath);
 937     rc = DosMove( (PCSZ)srcPath, (PCSZ)destPath);
 938     if (!rc)
 939         eRet = osl_File_E_None;
 940     else
 941         eRet = MapError( rc);
 942
 943     return eRet;
 944 }
 945
 946 /****************************************************************************/
 947 /*      osl_copyFile */
 948 /****************************************************************************/
 949
 950 #define TMP_DEST_FILE_EXTENSION ".osl-tmp"
 951
 952 static oslFileError oslDoCopy(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, mode_t nMode, size_t nSourceSize, int DestFileExists)
 953 {
 954     int      nRet=0;
 955     sal_Char pszTmpDestFile[PATH_MAX];
 956     size_t   size_tmp_dest_buff = sizeof(pszTmpDestFile);
 957
 958     /* Quick fix for #106048, the whole copy file function seems
 959        to be erroneous anyway and needs to be rewritten.
 960        Besides osl_copyFile     is currently not used from OO/SO code.
 961     */
 962     memset(pszTmpDestFile, 0, size_tmp_dest_buff);
 963
 964     if ( DestFileExists )
 965     {
 966         strncpy(pszTmpDestFile, pszDestFileName, size_tmp_dest_buff - 1);
 967
 968         if ((strlen(pszTmpDestFile) + strlen(TMP_DEST_FILE_EXTENSION)) >= size_tmp_dest_buff)
 969             return osl_File_E_NAMETOOLONG;
 970
 971         strncat(pszTmpDestFile, TMP_DEST_FILE_EXTENSION, strlen(TMP_DEST_FILE_EXTENSION));
 972
 973         /* FIXME: what if pszTmpDestFile already exists? */
 974         /*        with getcanonical??? */
 975         nRet=rename(pszDestFileName,pszTmpDestFile);
 976     }
 977
 978     /* mfe: should be S_ISREG */
 979     if ( !S_ISLNK(nMode) )
 980     {
 981         /* copy SourceFile to DestFile */
 982         nRet = oslDoCopyFile(pszSourceFileName,pszDestFileName,nSourceSize, nMode);
 983     }
 984     /* mfe: OK redundant at the moment */
 985     else if ( S_ISLNK(nMode) )
 986     {
 987         nRet = oslDoCopyLink(pszSourceFileName,pszDestFileName);
 988     }
 989     else
 990     {
 991         /* mfe: what to do here? */
 992         nRet=ENOSYS;
 993     }
 994
 995     if ( nRet > 0 && DestFileExists == 1 )
 996     {
 997         unlink(pszDestFileName);
 998         rename(pszTmpDestFile,pszDestFileName);
 999     }
1000
1001     if ( nRet > 0 )
1002     {
1003         return oslTranslateFileError(OSL_FET_ERROR, nRet);
1004     }
1005
1006     if ( DestFileExists == 1 )
1007     {
1008         unlink(pszTmpDestFile);
1009     }
1010
1011     return osl_File_E_None;
1012 }
1013
1014 /*****************************************
1015  * oslChangeFileModes
1016  ****************************************/
1017
1018 static oslFileError oslChangeFileModes( const sal_Char* pszFileName, mode_t nMode, time_t nAcTime, time_t nModTime, uid_t nUID, gid_t nGID)
1019 {
1020     int nRet=0;
1021     struct utimbuf aTimeBuffer;
1022
1023     nRet = chmod(pszFileName,nMode);
1024     if ( nRet < 0 )
1025     {
1026         nRet=errno;
1027         return oslTranslateFileError(OSL_FET_ERROR, nRet);
1028     }
1029
1030     aTimeBuffer.actime=nAcTime;
1031     aTimeBuffer.modtime=nModTime;
1032     nRet=utime(pszFileName,&aTimeBuffer);
1033     if ( nRet < 0 )
1034     {
1035         nRet=errno;
1036         return oslTranslateFileError(OSL_FET_ERROR, nRet);
1037     }
1038
1039     if ( nUID != getuid() )
1040     {
1041         nUID=getuid();
1042     }
1043
1044     nRet=chown(pszFileName,nUID,nGID);
1045     if ( nRet < 0 )
1046     {
1047         nRet=errno;
1048
1049         /* mfe: do not return an error here! */
1050         /* return oslTranslateFileError(nRet);*/
1051     }
1052
1053     return osl_File_E_None;
1054 }
1055
1056 /*****************************************
1057  * oslDoCopyLink
1058  ****************************************/
1059
1060 static int oslDoCopyLink(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName)
1061 {
1062     int nRet=0;
1063
1064     /* mfe: if dest file is symbolic link remove the link and place the file instead (hro says so) */
1065     /* mfe: if source is a link copy the link and not the file it points to (hro says so) */
1066     sal_Char pszLinkContent[PATH_MAX];
1067
1068     pszLinkContent[0] = '\0';
1069
1070     nRet = readlink(pszSourceFileName,pszLinkContent,PATH_MAX);
1071
1072     if ( nRet < 0 )
1073     {
1074         nRet=errno;
1075         return nRet;
1076     }
1077     else
1078         pszLinkContent[ nRet ] = 0;
1079
1080     nRet = symlink(pszLinkContent,pszDestFileName);
1081
1082     if ( nRet < 0 )
1083     {
1084         nRet=errno;
1085         return nRet;
1086     }
1087
1088     return 0;
1089 }
1090
1091 /*****************************************
1092  * oslDoCopyFile
1093  ****************************************/
1094
1095 static int oslDoCopyFile(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, size_t nSourceSize, mode_t mode)
1096 {
1097     int SourceFileFD=0;
1098     int DestFileFD=0;
1099     int nRet=0;
1100     void* pSourceFile=0;
1101     char        buffer[ 4096];
1102
1103     SourceFileFD=open(pszSourceFileName,O_RDONLY | O_BINARY);
1104     if ( SourceFileFD < 0 )
1105     {
1106         nRet=errno;
1107         return nRet;
1108     }
1109
1110     DestFileFD=open(pszDestFileName, O_WRONLY | O_CREAT | O_BINARY, mode);
1111     if ( DestFileFD < 0 )
1112     {
1113         nRet=errno;
1114         close(SourceFileFD);
1115         return nRet;
1116     }
1117
1118     /* HACK: because memory mapping fails on various
1119        platforms if the size of the source file is  0 byte */
1120     if (0 == nSourceSize)
1121     {
1122         close(SourceFileFD);
1123         close(DestFileFD);
1124         return 0;
1125     }
1126
1127     while( (nRet = read(SourceFileFD, buffer, sizeof(buffer))) !=0 )
1128     {
1129         nRet = write( DestFileFD, buffer, nRet);
1130     }
1131
1132     close(SourceFileFD);
1133     close(DestFileFD);
1134
1135     return nRet;
1136 }
1137
1138 static oslFileError osl_psz_copyFile( const sal_Char* pszPath, const sal_Char* pszDestPath )
1139 {
1140     time_t nAcTime=0;
1141     time_t nModTime=0;
1142     uid_t nUID=0;
1143     gid_t nGID=0;
1144     int nRet=0;
1145     mode_t nMode=0;
1146     struct stat aFileStat;
1147     oslFileError tErr=osl_File_E_invalidError;
1148     size_t nSourceSize=0;
1149     int DestFileExists=1;
1150
1151     /* mfe: does the source file really exists? */
1152     nRet = lstat(pszPath,&aFileStat);
1153
1154     if ( nRet < 0 )
1155     {
1156         nRet=errno;
1157         return oslTranslateFileError(OSL_FET_ERROR, nRet);
1158     }
1159
1160     /* mfe: we do only copy files here! */
1161     if ( S_ISDIR(aFileStat.st_mode) )
1162     {
1163         return osl_File_E_ISDIR;
1164     }
1165
1166     nSourceSize=(size_t)aFileStat.st_size;
1167     nMode=aFileStat.st_mode;
1168     nAcTime=aFileStat.st_atime;
1169     nModTime=aFileStat.st_mtime;
1170     nUID=aFileStat.st_uid;
1171     nGID=aFileStat.st_gid;
1172
1173     nRet = stat(pszDestPath,&aFileStat);
1174     if ( nRet < 0 )
1175     {
1176         nRet=errno;
1177
1178         if ( nRet == ENOENT )
1179         {
1180             DestFileExists=0;
1181         }
1182 /*        return oslTranslateFileError(nRet);*/
1183     }
1184
1185     /* mfe: the destination file must not be a directory! */
1186     if ( nRet == 0 && S_ISDIR(aFileStat.st_mode) )
1187     {
1188         return osl_File_E_ISDIR;
1189     }
1190     else
1191     {
1192         /* mfe: file does not exists or is no dir */
1193     }
1194
1195     tErr = oslDoCopy(pszPath,pszDestPath,nMode,nSourceSize,DestFileExists);
1196
1197     if ( tErr != osl_File_E_None )
1198     {
1199         return tErr;
1200     }
1201
1202     /*
1203      *   mfe: ignore return code
1204      *        since only  the success of the copy is
1205      *        important
1206      */
1207     oslChangeFileModes(pszDestPath,nMode,nAcTime,nModTime,nUID,nGID);
1208
1209     return tErr;
1210 }
1211
1212 oslFileError osl_copyFile( rtl_uString* ustrFileURL, rtl_uString* ustrDestURL )
1213 {
1214     char srcPath[PATH_MAX];
1215     char destPath[PATH_MAX];
1216     oslFileError eRet;
1217     APIRET rc;
1218
1219     OSL_ASSERT( ustrFileURL );
1220     OSL_ASSERT( ustrDestURL );
1221
1222     /* convert source url to system path */
1223     eRet = FileURLToPath( srcPath, PATH_MAX, ustrFileURL );
1224     if( eRet != osl_File_E_None )
1225         return eRet;
1226
1227     /* convert destination url to system path */
1228     eRet = FileURLToPath( destPath, PATH_MAX, ustrDestURL );
1229     if( eRet != osl_File_E_None )
1230         return eRet;
1231
1232     return osl_psz_copyFile( srcPath, destPath );
1233 }
1234
1235 /****************************************************************************/
1236 /*      osl_removeFile */
1237 /****************************************************************************/
1238
1239 oslFileError osl_removeFile( rtl_uString* ustrFileURL )
1240 {
1241     char path[PATH_MAX];
1242     oslFileError eRet;
1243     APIRET rc;
1244
1245     OSL_ASSERT( ustrFileURL );
1246
1247     /* convert file url to system path */
1248     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
1249     if( eRet != osl_File_E_None )
1250         return eRet;
1251
1252     rc = DosDelete( (PCSZ)path);
1253     if (!rc)
1254         eRet = osl_File_E_None;
1255     else
1256         eRet = MapError( rc);
1257
1258     return eRet;
1259 }
1260
1261 /****************************************************************************/
1262 /*      osl_getVolumeInformation */
1263 /****************************************************************************/
1264
1265 #define TXFSDC_BLOCKR         0x00              // block device removable
1266 #define TXFSDC_GETBPB         0x00              // get device bpb info
1267 #define TXFSBPB_REMOVABLE     0x08              // BPB attribute for removable
1268
1269 typedef struct drivecmd
1270 {
1271    BYTE                cmd;                     // 0=unlock 1=lock 2=eject
1272    BYTE                drv;                     // 0=A, 1=B 2=C ...
1273 } DRIVECMD;                                     // end of struct "drivecmd"
1274
1275 #pragma pack(push, 1)                           // byte packing
1276 typedef struct txfs_ebpb                        // ext. boot parameter block
1277 {                                               // at offset 0x0b in bootsector
1278    USHORT              SectSize;                // 0B bytes per sector
1279    BYTE                ClustSize;               // 0D sectors per cluster
1280    USHORT              FatOffset;               // 0E sectors to 1st FAT
1281    BYTE                NrOfFats;                // 10 nr of FATS     (FAT only)
1282    USHORT              RootEntries;             // 11 Max entries \ (FAT only)
1283    USHORT              Sectors;                 // 13 nr of sectors if <  64K
1284    BYTE                MediaType;               // 15 mediatype (F8 for HD)
1285    USHORT              FatSectors;              // 16 sectors/FAT (FAT only)
1286    USHORT              LogGeoSect;              // 18 sectors/Track
1287    USHORT              LogGeoHead;              // 1a nr of heads
1288    ULONG               HiddenSectors;           // 1c sector-offset from MBR/EBR
1289    ULONG               BigSectors;              // 20 nr of sectors if >= 64K
1290 } TXFS_EBPB;                                    // last byte is at offset 0x23
1291
1292 typedef struct drivebpb
1293 {
1294    TXFS_EBPB           ebpb;                    // extended BPB
1295    BYTE                reserved[6];
1296    USHORT              cyls;
1297    BYTE                type;
1298    USHORT              attributes;              // device attributes
1299    BYTE                fill[6];                 // documented for IOCtl
1300 } DRIVEBPB;                                     // end of struct "drivebpb"
1301
1302 struct CDInfo {
1303     USHORT usCount;
1304     USHORT usFirst;
1305 };
1306
1307 #pragma pack(pop)
1308
1309 /*****************************************************************************/
1310 // Get number of cdrom readers
1311 /*****************************************************************************/
1312 BOOL GetCDInfo( CDInfo * pCDInfo )
1313 {
1314     HFILE hFileCD;
1315     ULONG ulAction;
1316
1317     if( NO_ERROR == DosOpen( (PCSZ)"\\DEV\\CD-ROM2$",
1318                             &hFileCD, &ulAction, 0, FILE_NORMAL,
1319                             OPEN_ACTION_OPEN_IF_EXISTS,
1320                             OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, NULL )) {
1321         ULONG  ulDataSize = sizeof(CDInfo);
1322         APIRET rc = DosDevIOCtl( hFileCD, 0x82, 0x60, NULL, 0,
1323                                  NULL, (PVOID)pCDInfo, ulDataSize, &ulDataSize);
1324         DosClose( hFileCD);
1325         if(rc == NO_ERROR)
1326             return TRUE;
1327     }
1328     // failed
1329     pCDInfo->usFirst = 0;
1330     pCDInfo->usCount = 0;
1331     return FALSE;
1332 }
1333
1334 /*****************************************************************************/
1335 // Determine if unit is a cdrom or not
1336 /*****************************************************************************/
1337 BOOL DriveIsCDROM(UINT uiDrive, CDInfo *pCDInfo)
1338 {
1339     return (uiDrive >= pCDInfo->usFirst)
1340             && (uiDrive < (pCDInfo->usFirst + pCDInfo->usCount));
1341 }
1342
1343 /*****************************************************************************/
1344 // Determine attached fstype, e.g. HPFS for specified drive
1345 /*****************************************************************************/
1346 BOOL TxFsType                                   // RET   FS type resolved
1347 (
1348    char               *drive,                   // IN    Drive specification
1349    char               *fstype,                  // OUT   Attached FS type
1350    char               *details                  // OUT   details (UNC) or NULL
1351 )
1352 {
1353    BOOL                rc = FALSE;
1354    FSQBUFFER2         *fsinfo;                     // Attached FS info
1355    ULONG               fsdlen = 2048;              // Fs info data length
1356
1357    strcpy(fstype, "none");
1358    if (details)
1359    {
1360       strcpy(details, "");
1361    }
1362    if ((fsinfo = (FSQBUFFER2*)calloc(1, fsdlen)) != NULL)
1363    {
1364       if (DosQFSAttach((PCSZ)drive, 0, 1, fsinfo, &fsdlen) == NO_ERROR)
1365       {
1366          strcpy(fstype, (char*) fsinfo->szName + fsinfo->cbName +1);
1367          if (details && (fsinfo->cbFSAData != 0))
1368          {
1369             strcpy( details, (char*) fsinfo->szName + fsinfo->cbName +
1370                                               fsinfo->cbFSDName +2);
1371          }
1372          rc = TRUE;
1373       }
1374       free(fsinfo);
1375    }
1376    return (rc);
1377 }                                               // end 'TxFsType'
1378 /*---------------------------------------------------------------------------*/
1379
1380
1381 /*****************************************************************************/
1382 // Determine if a driveletter represents a removable medium/device
1383 /*****************************************************************************/
1384 BOOL TxFsIsRemovable                            // RET   drive is removable
1385 (
1386    char               *drive                    // IN    Driveletter to test
1387 )
1388 {
1389    BOOL                rc = FALSE;
1390    DRIVECMD            IOCtl;
1391    DRIVEBPB            RemAt;
1392    ULONG               DataLen;
1393    ULONG               ParmLen;
1394    BYTE                NoRem;
1395
1396    DosError( FERR_DISABLEHARDERR);              // avoid 'not ready' popups
1397
1398    ParmLen   = sizeof(IOCtl);
1399    IOCtl.cmd = TXFSDC_BLOCKR;
1400    IOCtl.drv = toupper(drive[0]) - 'A';
1401    DataLen   = sizeof(NoRem);
1402
1403    if (DosDevIOCtl((HFILE) -1, IOCTL_DISK,
1404                                DSK_BLOCKREMOVABLE,
1405                                &IOCtl, ParmLen, &ParmLen,
1406                                &NoRem, DataLen, &DataLen) == NO_ERROR)
1407    {
1408       if (NoRem)                                // non-removable sofar, check
1409       {                                         // BPB as well (USB devices)
1410          ParmLen   = sizeof(IOCtl);
1411          IOCtl.cmd = TXFSDC_GETBPB;
1412          IOCtl.drv = toupper(drive[0]) - 'A';
1413          DataLen   = sizeof(RemAt);
1414
1415          if (DosDevIOCtl((HFILE) -1, IOCTL_DISK,
1416                                      DSK_GETDEVICEPARAMS,
1417                                      &IOCtl, ParmLen, &ParmLen,
1418                                      &RemAt, DataLen, &DataLen) == NO_ERROR)
1419
1420          {
1421             if (RemAt.attributes & TXFSBPB_REMOVABLE)
1422             {
1423                rc = TRUE;                       // removable, probably USB
1424             }
1425          }
1426       }
1427       else
1428       {
1429          rc = TRUE;                             // removable block device
1430       }
1431    }
1432    DosError( FERR_ENABLEHARDERR);               // enable criterror handler
1433    return (rc);
1434 }                                               // end 'TxFsIsRemovable'
1435 /*---------------------------------------------------------------------------*/
1436
1437 static oslFileError get_drive_type(const char* path, oslVolumeInfo* pInfo)
1438 {
1439     char                Drive_Letter = toupper( *path);
1440     char                fstype[ 64];
1441
1442     pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
1443
1444     // check for floppy A/B
1445     BYTE        nFloppies;
1446     APIRET      rc;
1447     rc = DosDevConfig( (void*) &nFloppies, DEVINFO_FLOPPY );
1448     if ((Drive_Letter - 'A') < nFloppies) {
1449         pInfo->uAttributes |= osl_Volume_Attribute_Removeable;
1450         pInfo->uAttributes |= osl_Volume_Attribute_FloppyDisk;
1451         return osl_File_E_None;
1452     }
1453
1454     // query system for CD drives
1455     CDInfo cdInfo;
1456     GetCDInfo(&cdInfo);
1457
1458     // query if drive is a CDROM
1459     if (DriveIsCDROM( Drive_Letter - 'A', &cdInfo))
1460         pInfo->uAttributes |= osl_Volume_Attribute_CompactDisc | osl_Volume_Attribute_Removeable;
1461
1462     if (TxFsIsRemovable( (char*)path))
1463         pInfo->uAttributes |= osl_Volume_Attribute_Removeable;
1464
1465     if (TxFsType( (char*)path, fstype, NULL) == FALSE) {
1466         // query failed, assume fixed disk
1467         pInfo->uAttributes |= osl_Volume_Attribute_FixedDisk;
1468         return osl_File_E_None;
1469     }
1470
1471     //- Note, connected Win-NT drives use the REAL FS-name like NTFS!
1472     if ((strncasecmp( fstype, "LAN", 3) == 0)                   //- OS/2 LAN drives
1473         || (strncasecmp( fstype, "NDFS", 4) == 0)       //- NetDrive
1474         || (strncasecmp( fstype, "REMOTE", 5) == 0)  )  //- NT disconnected
1475         pInfo->uAttributes |= osl_Volume_Attribute_Remote;
1476     else if (strncasecmp( fstype, "RAMFS", 5) == 0)
1477         pInfo->uAttributes |= osl_Volume_Attribute_RAMDisk;
1478     else if ((strncasecmp( fstype, "CD",  2) == 0)              // OS2:CDFS, DOS/WIN:CDROM
1479         || (strncasecmp( fstype, "UDF", 3) == 0)   )    // OS2:UDF DVD's
1480         pInfo->uAttributes |= osl_Volume_Attribute_CompactDisc | osl_Volume_Attribute_Removeable;
1481     else
1482         pInfo->uAttributes |= osl_Volume_Attribute_FixedDisk;
1483
1484     return osl_File_E_None;
1485 }
1486
1487 //#############################################
1488 inline bool is_volume_space_info_request(sal_uInt32 field_mask)
1489 {
1490     return (field_mask &
1491             (osl_VolumeInfo_Mask_TotalSpace |
1492              osl_VolumeInfo_Mask_UsedSpace  |
1493              osl_VolumeInfo_Mask_FreeSpace));
1494 }
1495
1496 //#############################################
1497 static void get_volume_space_information(const char* path, oslVolumeInfo *pInfo)
1498 {
1499     FSALLOCATE aFSInfoBuf;
1500     ULONG nDriveNumber = toupper( *path) - 'A' + 1;
1501
1502     // disable error popups
1503     DosError(FERR_DISABLEHARDERR);
1504     APIRET rc = DosQueryFSInfo( nDriveNumber, FSIL_ALLOC,
1505                                 &aFSInfoBuf, sizeof(aFSInfoBuf) );
1506     // enable error popups
1507     DosError(FERR_ENABLEHARDERR);
1508     if (!rc)
1509     {
1510         uint64_t aBytesPerCluster( uint64_t(aFSInfoBuf.cbSector) *
1511                                  uint64_t(aFSInfoBuf.cSectorUnit) );
1512         pInfo->uFreeSpace = aBytesPerCluster * uint64_t(aFSInfoBuf.cUnitAvail);
1513         pInfo->uTotalSpace = aBytesPerCluster * uint64_t(aFSInfoBuf.cUnit);
1514         pInfo->uUsedSpace    = pInfo->uTotalSpace - pInfo->uFreeSpace;
1515         pInfo->uValidFields |= osl_VolumeInfo_Mask_TotalSpace |
1516                                osl_VolumeInfo_Mask_UsedSpace |
1517                                osl_VolumeInfo_Mask_FreeSpace;
1518     }
1519 }
1520
1521 //#############################################
1522 inline bool is_filesystem_attributes_request(sal_uInt32 field_mask)
1523 {
1524     return (field_mask &
1525             (osl_VolumeInfo_Mask_MaxNameLength |
1526              osl_VolumeInfo_Mask_MaxPathLength |
1527              osl_VolumeInfo_Mask_FileSystemName |
1528              osl_VolumeInfo_Mask_FileSystemCaseHandling));
1529 }
1530
1531 //#############################################
1532 inline bool is_drivetype_request(sal_uInt32 field_mask)
1533 {
1534     return (field_mask & osl_VolumeInfo_Mask_Attributes);
1535 }
1536
1537 typedef struct _FSQBUFFER_
1538 {
1539     FSQBUFFER2  aBuf;
1540     UCHAR       sBuf[64];
1541 } FSQBUFFER_;
1542
1543 //#############################################
1544 static oslFileError get_filesystem_attributes(const char* path, sal_uInt32 field_mask, oslVolumeInfo* pInfo)
1545 {
1546     pInfo->uAttributes = 0;
1547
1548     oslFileError osl_error = osl_File_E_None;
1549
1550     // osl_get_drive_type must be called first because
1551     // this function resets osl_VolumeInfo_Mask_Attributes
1552     // on failure
1553     if (is_drivetype_request(field_mask))
1554         osl_error = get_drive_type(path, pInfo);
1555
1556     if ((osl_File_E_None == osl_error) && is_filesystem_attributes_request(field_mask))
1557     {
1558         FSQBUFFER_      aBuf;
1559         ULONG       nBufLen;
1560         APIRET      nRet;
1561
1562         nBufLen = sizeof( aBuf );
1563         // disable error popups
1564         DosError(FERR_DISABLEHARDERR);
1565         nRet = DosQueryFSAttach( (PCSZ)path, 0, FSAIL_QUERYNAME, (_FSQBUFFER2*) &aBuf, &nBufLen );
1566         if ( !nRet )
1567         {
1568             char *pType = (char*)(aBuf.aBuf.szName + aBuf.aBuf.cbName + 1);
1569             pInfo->uValidFields   |= osl_VolumeInfo_Mask_MaxNameLength;
1570             pInfo->uMaxNameLength  = _MAX_FNAME;
1571
1572             pInfo->uValidFields   |= osl_VolumeInfo_Mask_MaxPathLength;
1573             pInfo->uMaxPathLength  = _MAX_PATH;
1574
1575             pInfo->uValidFields   |= osl_VolumeInfo_Mask_FileSystemName;
1576             rtl_uString_newFromAscii(&pInfo->ustrFileSystemName, pType);
1577
1578             // case is preserved always except for FAT
1579             if (strcmp( pType, "FAT" ))
1580                 pInfo->uAttributes |= osl_Volume_Attribute_Case_Is_Preserved;
1581
1582             pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
1583         }
1584         // enable error popups
1585         DosError(FERR_ENABLEHARDERR);
1586     }
1587     return osl_error;
1588 }
1589
1590 oslFileError SAL_CALL osl_getVolumeInformation( rtl_uString* ustrDirectoryURL, oslVolumeInfo* pInfo, sal_uInt32 uFieldMask )
1591 {
1592     char volume_root[PATH_MAX];
1593     oslFileError error;
1594
1595     OSL_ASSERT( ustrDirectoryURL );
1596     OSL_ASSERT( pInfo );
1597
1598     /* convert directory url to system path */
1599     error = FileURLToPath( volume_root, PATH_MAX, ustrDirectoryURL );
1600     if( error != osl_File_E_None )
1601         return error;
1602
1603     if (!pInfo)
1604         return osl_File_E_INVAL;
1605
1606     pInfo->uValidFields = 0;
1607
1608     if ((error = get_filesystem_attributes(volume_root, uFieldMask, pInfo)) != osl_File_E_None)
1609         return error;
1610
1611     if (is_volume_space_info_request(uFieldMask))
1612         get_volume_space_information(volume_root, pInfo);
1613
1614     if (uFieldMask & osl_VolumeInfo_Mask_DeviceHandle)
1615     {
1616         pInfo->uValidFields |= osl_VolumeInfo_Mask_DeviceHandle;
1617         rtl_uString* uVolumeRoot;
1618         rtl_uString_newFromAscii( &uVolumeRoot, volume_root);
1619         osl_getFileURLFromSystemPath( uVolumeRoot, (rtl_uString**)&pInfo->pDeviceHandle);
1620         rtl_uString_release( uVolumeRoot);
1621     }
1622
1623     return osl_File_E_None;
1624 }
1625
1626 /****************************************************************************/
1627 /*      osl_getFileStatus */
1628 /****************************************************************************/
1629 static oslFileError _osl_getDriveInfo(
1630     oslDirectoryItem Item, oslFileStatus *pStatus, sal_uInt32 uFieldMask)
1631 {
1632     DirectoryItem_Impl  *pItemImpl = (DirectoryItem_Impl *)Item;
1633     sal_Unicode                 cDrive[3];
1634     sal_Unicode                 cRoot[4];
1635
1636     if ( !pItemImpl )
1637         return osl_File_E_INVAL;
1638
1639     pStatus->uValidFields = 0;
1640
1641     cDrive[0] = pItemImpl->ustrDrive->buffer[0];
1642     cDrive[1] = (sal_Unicode)':';
1643     cDrive[2] = 0;
1644     cRoot[0] = pItemImpl->ustrDrive->buffer[0];
1645     cRoot[1] = (sal_Unicode)':';
1646     cRoot[2] = 0;
1647
1648     if ( uFieldMask & osl_FileStatus_Mask_FileName )
1649     {
1650         if ( pItemImpl->ustrDrive->buffer[0] == '\\' &&
1651             pItemImpl->ustrDrive->buffer[1] == '\\' )
1652         {
1653             LPCWSTR     lpFirstBkSlash = wcschr( (const wchar_t*)&pItemImpl->ustrDrive->buffer[2], '\\' );
1654
1655             if ( lpFirstBkSlash && lpFirstBkSlash[1] )
1656             {
1657                 LPCWSTR lpLastBkSlash = wcschr( (const wchar_t*)&lpFirstBkSlash[1], '\\' );
1658
1659                 if ( lpLastBkSlash )
1660                     rtl_uString_newFromStr_WithLength( &pStatus->ustrFileName, (sal_Unicode*)&lpFirstBkSlash[1], lpLastBkSlash - lpFirstBkSlash - 1 );
1661                 else
1662                     rtl_uString_newFromStr( &pStatus->ustrFileName, (sal_Unicode*)&lpFirstBkSlash[1] );
1663                 pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1664             }
1665         }
1666         else
1667         {
1668             FSINFO      aFSInfoBuf;
1669             ULONG   ulFSInfoLevel = FSIL_VOLSER;
1670             ULONG   nDriveNumber;
1671             char        szFileName[ _MAX_PATH];
1672
1673             nDriveNumber = toupper(*cDrive) - 'A' + 1;
1674             memset( &aFSInfoBuf, 0, sizeof(FSINFO) );
1675             // disable error popups
1676             DosError(FERR_DISABLEHARDERR);
1677             APIRET rc = DosQueryFSInfo( nDriveNumber, ulFSInfoLevel, &aFSInfoBuf, sizeof(FSINFO) );
1678             // enable error popups
1679             DosError(FERR_ENABLEHARDERR);
1680             memset( szFileName, 0, sizeof( szFileName));
1681             *szFileName = toupper(*cDrive);
1682             strcat( szFileName, ": [");
1683             if ( !rc || aFSInfoBuf.vol.cch)
1684                 strncat( szFileName, aFSInfoBuf.vol.szVolLabel, aFSInfoBuf.vol.cch);
1685             strcat( szFileName, "]");
1686             rtl_uString_newFromAscii( &pStatus->ustrFileName, szFileName );
1687
1688             pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1689         }
1690     }
1691
1692     pStatus->eType = osl_File_Type_Volume;
1693     pStatus->uValidFields |= osl_FileStatus_Mask_Type;
1694
1695     if ( uFieldMask & osl_FileStatus_Mask_FileURL )
1696     {
1697         rtl_uString     *ustrSystemPath = NULL;
1698
1699         rtl_uString_newFromStr( &ustrSystemPath, pItemImpl->ustrDrive->buffer );
1700         osl_getFileURLFromSystemPath( ustrSystemPath, &pStatus->ustrFileURL );
1701         rtl_uString_release( ustrSystemPath );
1702         pStatus->uValidFields |= osl_FileStatus_Mask_FileURL;
1703     }
1704
1705     return osl_File_E_None;
1706 }
1707
1708 oslFileError SAL_CALL osl_getFileStatus(
1709     oslDirectoryItem Item,
1710     oslFileStatus *pStatus,
1711     sal_uInt32 uFieldMask )
1712 {
1713     DirectoryItem_Impl  *pItemImpl = (DirectoryItem_Impl *)Item;
1714     struct stat file_stat;
1715
1716     if ( !pItemImpl )
1717         return osl_File_E_INVAL;
1718
1719     if ( pItemImpl->uType == DIRECTORYITEM_DRIVE)
1720         return _osl_getDriveInfo( Item, pStatus, uFieldMask );
1721
1722     osl::lstat(pItemImpl->ustrFilePath, file_stat);
1723     if ( uFieldMask & osl_FileStatus_Mask_Validate )
1724     {
1725         uFieldMask &= ~ osl_FileStatus_Mask_Validate;
1726     }
1727
1728     /* If no fields to retrieve left ignore pStatus */
1729     if ( !uFieldMask )
1730         return osl_File_E_None;
1731
1732     /* Otherwise, this must be a valid pointer */
1733     if ( !pStatus )
1734         return osl_File_E_INVAL;
1735
1736     if ( pStatus->uStructSize != sizeof(oslFileStatus) )
1737         return osl_File_E_INVAL;
1738
1739     pStatus->uValidFields = 0;
1740
1741     /* File time stamps */
1742
1743     if ( (uFieldMask & osl_FileStatus_Mask_ModifyTime))
1744     {
1745         pStatus->aModifyTime.Seconds  = file_stat.st_mtime;
1746         pStatus->aModifyTime.Nanosec  = 0;
1747         pStatus->uValidFields |= osl_FileStatus_Mask_ModifyTime;
1748     }
1749
1750     if ( (uFieldMask & osl_FileStatus_Mask_AccessTime))
1751     {
1752         pStatus->aAccessTime.Seconds  = file_stat.st_atime;
1753         pStatus->aAccessTime.Nanosec  = 0;
1754         pStatus->uValidFields |= osl_FileStatus_Mask_AccessTime;
1755     }
1756
1757     if ( (uFieldMask & osl_FileStatus_Mask_CreationTime))
1758     {
1759         pStatus->aAccessTime.Seconds  = file_stat.st_birthtime;
1760         pStatus->aAccessTime.Nanosec  = 0;
1761         pStatus->uValidFields |= osl_FileStatus_Mask_CreationTime;
1762     }
1763
1764     /* Most of the fields are already set, regardless of requiered fields */
1765
1766     osl_systemPathGetFileNameOrLastDirectoryPart(pItemImpl->ustrFilePath, &pStatus->ustrFileName);
1767     pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
1768
1769     if (S_ISLNK(file_stat.st_mode))
1770        pStatus->eType = osl_File_Type_Link;
1771     else if (S_ISDIR(file_stat.st_mode))
1772        pStatus->eType = osl_File_Type_Directory;
1773     else if (S_ISREG(file_stat.st_mode))
1774        pStatus->eType = osl_File_Type_Regular;
1775     else if (S_ISFIFO(file_stat.st_mode))
1776        pStatus->eType = osl_File_Type_Fifo;
1777     else if (S_ISSOCK(file_stat.st_mode))
1778        pStatus->eType = osl_File_Type_Socket;
1779     else if (S_ISCHR(file_stat.st_mode) || S_ISBLK(file_stat.st_mode))
1780        pStatus->eType = osl_File_Type_Special;
1781     else
1782        pStatus->eType = osl_File_Type_Unknown;
1783
1784     pStatus->uValidFields |= osl_FileStatus_Mask_Type;
1785
1786     pStatus->uAttributes = pItemImpl->d_attr;
1787     pStatus->uValidFields |= osl_FileStatus_Mask_Attributes;
1788
1789     pStatus->uFileSize = file_stat.st_size;
1790     pStatus->uValidFields |= osl_FileStatus_Mask_FileSize;
1791
1792     if ( uFieldMask & osl_FileStatus_Mask_LinkTargetURL )
1793     {
1794         rtl_uString     *ustrFullPath = NULL;
1795
1796         rtl_uString_newFromStr( &ustrFullPath, rtl_uString_getStr(pItemImpl->ustrFilePath) );
1797         osl_getFileURLFromSystemPath( ustrFullPath, &pStatus->ustrLinkTargetURL );
1798         rtl_uString_release( ustrFullPath );
1799
1800         pStatus->uValidFields |= osl_FileStatus_Mask_LinkTargetURL;
1801     }
1802
1803     if ( uFieldMask & osl_FileStatus_Mask_FileURL )
1804     {
1805         rtl_uString     *ustrFullPath = NULL;
1806
1807         rtl_uString_newFromStr( &ustrFullPath, rtl_uString_getStr(pItemImpl->ustrFilePath) );
1808         osl_getFileURLFromSystemPath( ustrFullPath, &pStatus->ustrFileURL );
1809         rtl_uString_release( ustrFullPath );
1810         pStatus->uValidFields |= osl_FileStatus_Mask_FileURL;
1811     }
1812
1813     return osl_File_E_None;
1814 }
1815
1816 /****************************************************************************/
1817 /*      osl_createDirectory */
1818 /****************************************************************************/
1819
1820 oslFileError osl_createDirectory( rtl_uString* ustrDirectoryURL )
1821 {
1822     char path[PATH_MAX];
1823     oslFileError eRet;
1824     APIRET rc;
1825
1826     OSL_ASSERT( ustrDirectoryURL );
1827
1828     /* convert directory url to system path */
1829     eRet = FileURLToPath( path, PATH_MAX, ustrDirectoryURL );
1830     if( eRet != osl_File_E_None )
1831         return eRet;
1832
1833     rc = DosCreateDir( (PCSZ)path, NULL);
1834     if (rc == ERROR_ACCESS_DENIED)
1835        rc=ERROR_FILE_EXISTS;
1836
1837     if (!rc)
1838         eRet = osl_File_E_None;
1839     else
1840         eRet = MapError( rc);
1841
1842     return eRet;
1843 }
1844
1845 /****************************************************************************/
1846 /*      osl_removeDirectory */
1847 /****************************************************************************/
1848
1849 oslFileError osl_removeDirectory( rtl_uString* ustrDirectoryURL )
1850 {
1851     char path[PATH_MAX];
1852     oslFileError eRet;
1853     APIRET rc;
1854
1855     OSL_ASSERT( ustrDirectoryURL );
1856
1857     /* convert directory url to system path */
1858     eRet = FileURLToPath( path, PATH_MAX, ustrDirectoryURL );
1859     if( eRet != osl_File_E_None )
1860         return eRet;
1861
1862     rc = DosDeleteDir( (PCSZ)path);
1863     if (!rc)
1864         eRet = osl_File_E_None;
1865     else
1866         eRet = MapError( rc);
1867
1868     return eRet;
1869 }
1870
1871 //#############################################
1872 int path_make_parent(sal_Unicode* path)
1873 {
1874     int i = rtl_ustr_lastIndexOfChar(path, '/');
1875
1876     if (i > 0)
1877     {
1878         *(path + i) = 0;
1879         return i;
1880     }
1881     else
1882         return 0;
1883 }
1884
1885 //#############################################
1886 int create_dir_with_callback(
1887     sal_Unicode* directory_path,
1888     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
1889     void* pData)
1890 {
1891     int mode = S_IRWXU | S_IRWXG | S_IRWXO;
1892
1893     if (osl::mkdir(directory_path, mode) == 0)
1894     {
1895         if (aDirectoryCreationCallbackFunc)
1896         {
1897             rtl::OUString url;
1898             osl::FileBase::getFileURLFromSystemPath(directory_path, url);
1899             aDirectoryCreationCallbackFunc(pData, url.pData);
1900         }
1901         return 0;
1902     }
1903     return errno;
1904 }
1905
1906 //#############################################
1907 oslFileError create_dir_recursively_(
1908     sal_Unicode* dir_path,
1909     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
1910     void* pData)
1911 {
1912     OSL_PRECOND((rtl_ustr_getLength(dir_path) > 0) && ((dir_path + (rtl_ustr_getLength(dir_path) - 1)) != (dir_path + rtl_ustr_lastIndexOfChar(dir_path, '/'))), \
1913     "Path must not end with a slash");
1914
1915     int native_err = create_dir_with_callback(
1916         dir_path, aDirectoryCreationCallbackFunc, pData);
1917
1918     if (native_err == 0)
1919         return osl_File_E_None;
1920
1921     if (native_err != ENOENT)
1922         return oslTranslateFileError(OSL_FET_ERROR, native_err);
1923
1924     // we step back until '/a_dir' at maximum because
1925     // we should get an error unequal ENOENT when
1926     // we try to create 'a_dir' at '/' and would so
1927     // return before
1928     int pos = path_make_parent(dir_path);
1929
1930     oslFileError osl_error = create_dir_recursively_(
1931         dir_path, aDirectoryCreationCallbackFunc, pData);
1932
1933     if (osl_File_E_None != osl_error)
1934         return osl_error;
1935
1936        dir_path[pos] = '/';
1937
1938     return create_dir_recursively_(dir_path, aDirectoryCreationCallbackFunc, pData);
1939 }
1940
1941 //#######################################
1942 oslFileError SAL_CALL osl_createDirectoryPath(
1943     rtl_uString* aDirectoryUrl,
1944     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
1945     void* pData)
1946 {
1947     if (aDirectoryUrl == NULL)
1948         return osl_File_E_INVAL;
1949
1950     rtl::OUString sys_path;
1951     oslFileError osl_error = osl_getSystemPathFromFileURL_Ex(
1952         aDirectoryUrl, &sys_path.pData, sal_False);
1953
1954     if (osl_error != osl_File_E_None)
1955         return osl_error;
1956
1957     osl::systemPathRemoveSeparator(sys_path);
1958
1959     // const_cast because sys_path is a local copy which we want to modify inplace instead of
1960     // coyp it into another buffer on the heap again
1961     return create_dir_recursively_(sys_path.pData->buffer, aDirectoryCreationCallbackFunc, pData);
1962 }
1963
1964 /****************************************************************************/
1965 /*      osl_getCanonicalName */
1966 /****************************************************************************/
1967
1968 oslFileError osl_getCanonicalName( rtl_uString* ustrFileURL, rtl_uString** pustrValidURL )
1969 {
1970     OSL_ENSURE(sal_False, "osl_getCanonicalName not implemented");
1971
1972     rtl_uString_newFromString(pustrValidURL, ustrFileURL);
1973     return osl_File_E_None;
1974 }
1975
1976
1977 /****************************************************************************/
1978 /*      osl_setFileAttributes */
1979 /****************************************************************************/
1980
1981 oslFileError osl_setFileAttributes( rtl_uString* ustrFileURL, sal_uInt64 uAttributes )
1982 {
1983     char         path[PATH_MAX];
1984     oslFileError eRet;
1985     FILESTATUS3  fsts3ConfigInfo;
1986     ULONG        ulBufSize     = sizeof(FILESTATUS3);
1987     APIRET       rc            = NO_ERROR;
1988
1989     OSL_ASSERT( ustrFileURL );
1990
1991     /* convert file url to system path */
1992     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
1993     if( eRet != osl_File_E_None )
1994         return eRet;
1995
1996     /* query current attributes */
1997     rc = DosQueryPathInfo( (PCSZ)path, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
1998     if (rc != NO_ERROR)
1999         return MapError( rc);
2000
2001     /* set/reset readonly/hidden (see w32\file.cxx) */
2002     fsts3ConfigInfo.attrFile &= ~(FILE_READONLY | FILE_HIDDEN);
2003     if ( uAttributes & osl_File_Attribute_ReadOnly )
2004         fsts3ConfigInfo.attrFile |= FILE_READONLY;
2005     if ( uAttributes & osl_File_Attribute_Hidden )
2006         fsts3ConfigInfo.attrFile |= FILE_HIDDEN;
2007
2008     /* write new attributes */
2009     rc = DosSetPathInfo( (PCSZ)path, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize, 0);
2010     if (rc != NO_ERROR)
2011         return MapError( rc);
2012
2013     /* everything ok */
2014     return osl_File_E_None;
2015 }
2016
2017 /****************************************************************************/
2018 /*      osl_setFileTime */
2019 /****************************************************************************/
2020
2021 oslFileError osl_setFileTime( rtl_uString* ustrFileURL, const TimeValue* pCreationTime,
2022                               const TimeValue* pLastAccessTime, const TimeValue* pLastWriteTime )
2023 {
2024     char path[PATH_MAX];
2025     oslFileError eRet;
2026
2027     OSL_ASSERT( ustrFileURL );
2028
2029     /* convert file url to system path */
2030     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
2031     if( eRet != osl_File_E_None )
2032         return eRet;
2033
2034     return osl_psz_setFileTime( path, pCreationTime, pLastAccessTime, pLastWriteTime );
2035 }
2036
2037 /******************************************************************************
2038  *
2039  *                  Exported Module Functions
2040  *             (independent of C or Unicode Strings)
2041  *
2042  *****************************************************************************/
2043
2044
2045 /*******************************************
2046     osl_readFile
2047 ********************************************/
2048
2049 oslFileError osl_readFile(oslFileHandle Handle, void* pBuffer, sal_uInt64 uBytesRequested, sal_uInt64* pBytesRead)
2050 {
2051     ssize_t            nBytes      = 0;
2052     oslFileHandleImpl* pHandleImpl = (oslFileHandleImpl*)Handle;
2053
2054     if ((0 == pHandleImpl) || (pHandleImpl->fd < 0) || (0 == pBuffer) || (0 == pBytesRead))
2055         return osl_File_E_INVAL;
2056
2057     nBytes = read(pHandleImpl->fd, pBuffer, uBytesRequested);
2058
2059     if (-1 == nBytes)
2060         return oslTranslateFileError(OSL_FET_ERROR, errno);
2061
2062     *pBytesRead = nBytes;
2063     return osl_File_E_None;
2064 }
2065
2066 /*******************************************
2067     osl_writeFile
2068 ********************************************/
2069
2070 oslFileError osl_writeFile(oslFileHandle Handle, const void* pBuffer, sal_uInt64 uBytesToWrite, sal_uInt64* pBytesWritten)
2071 {
2072     ssize_t            nBytes      = 0;
2073     oslFileHandleImpl* pHandleImpl = (oslFileHandleImpl*)Handle;
2074
2075     OSL_ASSERT(pHandleImpl);
2076     OSL_ASSERT(pBuffer);
2077     OSL_ASSERT(pBytesWritten);
2078
2079     if ((0 == pHandleImpl) || (0 == pBuffer) || (0 == pBytesWritten))
2080         return osl_File_E_INVAL;
2081
2082     OSL_ASSERT(pHandleImpl->fd >= 0);
2083
2084     if (pHandleImpl->fd < 0)
2085         return osl_File_E_INVAL;
2086
2087     nBytes = write(pHandleImpl->fd, pBuffer, uBytesToWrite);
2088
2089     if (-1 == nBytes)
2090         return oslTranslateFileError(OSL_FET_ERROR, errno);
2091
2092     *pBytesWritten = nBytes;
2093     return osl_File_E_None;
2094 }
2095
2096 /*******************************************
2097     osl_writeFile
2098 ********************************************/
2099
2100 oslFileError osl_setFilePos( oslFileHandle Handle, sal_uInt32 uHow, sal_Int64 uPos )
2101 {
2102     oslFileHandleImpl* pHandleImpl=0;
2103     int nRet=0;
2104     off_t nOffset=0;
2105
2106     pHandleImpl = (oslFileHandleImpl*) Handle;
2107     if ( pHandleImpl == 0 )
2108     {
2109         return osl_File_E_INVAL;
2110     }
2111
2112     if ( pHandleImpl->fd < 0 )
2113     {
2114         return osl_File_E_INVAL;
2115     }
2116
2117     /* FIXME mfe: setFilePos: Do we have any runtime function to determine LONG_MAX? */
2118     if ( uPos > LONG_MAX )
2119     {
2120         return osl_File_E_OVERFLOW;
2121     }
2122
2123     nOffset=(off_t)uPos;
2124
2125     switch(uHow)
2126     {
2127         case osl_Pos_Absolut:
2128             nOffset = lseek(pHandleImpl->fd,nOffset,SEEK_SET);
2129             break;
2130
2131         case osl_Pos_Current:
2132             nOffset = lseek(pHandleImpl->fd,nOffset,SEEK_CUR);
2133             break;
2134
2135         case osl_Pos_End:
2136             nOffset = lseek(pHandleImpl->fd,nOffset,SEEK_END);
2137             break;
2138
2139         default:
2140             return osl_File_E_INVAL;
2141     }
2142
2143     if ( nOffset < 0 )
2144     {
2145         nRet=errno;
2146         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2147     }
2148
2149     return osl_File_E_None;
2150 }
2151
2152 /************************************************
2153  * osl_getFilePos
2154  ***********************************************/
2155
2156 oslFileError osl_getFilePos( oslFileHandle Handle, sal_uInt64* pPos )
2157 {
2158     oslFileHandleImpl* pHandleImpl=0;
2159     off_t nOffset=0;
2160     int nRet=0;
2161
2162     pHandleImpl = (oslFileHandleImpl*) Handle;
2163     if ( pHandleImpl == 0 || pPos == 0)
2164     {
2165         return osl_File_E_INVAL;
2166     }
2167
2168     if ( pHandleImpl->fd < 0 )
2169     {
2170         return osl_File_E_INVAL;
2171     }
2172
2173     nOffset = lseek(pHandleImpl->fd,0,SEEK_CUR);
2174
2175     if (nOffset < 0)
2176     {
2177         nRet  =errno;
2178
2179         /* *pPos =0; */
2180
2181         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2182     }
2183
2184     *pPos=nOffset;
2185
2186     return osl_File_E_None;
2187 }
2188
2189 /****************************************************************************
2190  *      osl_getFileSize
2191  ****************************************************************************/
2192
2193 oslFileError osl_getFileSize( oslFileHandle Handle, sal_uInt64* pSize )
2194 {
2195     oslFileHandleImpl* pHandleImpl=(oslFileHandleImpl*) Handle;
2196     if (pHandleImpl == 0)
2197         return osl_File_E_INVAL;
2198
2199     struct stat file_stat;
2200     if (fstat(pHandleImpl->fd, &file_stat) == -1)
2201         return oslTranslateFileError(OSL_FET_ERROR, errno);
2202
2203     *pSize = file_stat.st_size;
2204     return osl_File_E_None;
2205 }
2206
2207 /************************************************
2208  * osl_setFileSize
2209  ***********************************************/
2210
2211 oslFileError osl_setFileSize( oslFileHandle Handle, sal_uInt64 uSize )
2212 {
2213     oslFileHandleImpl* pHandleImpl=0;
2214     off_t nOffset=0;
2215
2216     pHandleImpl = (oslFileHandleImpl*) Handle;
2217     if ( pHandleImpl == 0 )
2218     {
2219         return osl_File_E_INVAL;
2220     }
2221
2222     if ( pHandleImpl->fd < 0 )
2223     {
2224         return osl_File_E_INVAL;
2225     }
2226
2227     /* FIXME: mfe: setFileSize: Do we have any runtime function to determine LONG_MAX? */
2228     if ( uSize > LONG_MAX )
2229     {
2230         return osl_File_E_OVERFLOW;
2231     }
2232
2233     nOffset = (off_t)uSize;
2234     if (ftruncate (pHandleImpl->fd, nOffset) < 0)
2235     {
2236         /* Failure. Try fallback algorithm */
2237         oslFileError result;
2238         struct stat  aStat;
2239         off_t        nCurPos;
2240
2241         /* Save original result */
2242         result = oslTranslateFileError (OSL_FET_ERROR, errno);
2243         PERROR("ftruncate", "Try osl_setFileSize [fallback]\n");
2244
2245         /* Check against current size. Fail upon 'shrink' */
2246         if (fstat (pHandleImpl->fd, &aStat) < 0)
2247         {
2248             PERROR("ftruncate: fstat", "Out osl_setFileSize [error]\n");
2249             return (result);
2250         }
2251         if ((0 <= nOffset) && (nOffset <= aStat.st_size))
2252         {
2253             /* Failure upon 'shrink'. Return original result */
2254             return (result);
2255         }
2256
2257         /* Save current position */
2258         nCurPos = (off_t)lseek (pHandleImpl->fd, (off_t)0, SEEK_CUR);
2259         if (nCurPos == (off_t)(-1))
2260         {
2261             PERROR("ftruncate: lseek", "Out osl_setFileSize [error]\n");
2262             return (result);
2263         }
2264
2265         /* Try 'expand' via 'lseek()' and 'write()' */
2266         if (lseek (pHandleImpl->fd, (off_t)(nOffset - 1), SEEK_SET) < 0)
2267         {
2268             PERROR("ftruncate: lseek", "Out osl_setFileSize [error]\n");
2269             return (result);
2270         }
2271         if (write (pHandleImpl->fd, (char*)"", (size_t)1) < 0)
2272         {
2273             /* Failure. Restore saved position */
2274             PERROR("ftruncate: write", "Out osl_setFileSize [error]\n");
2275             if (lseek (pHandleImpl->fd, (off_t)nCurPos, SEEK_SET) < 0)
2276             {
2277 #ifdef DEBUG_OSL_FILE
2278                 perror("ftruncate: lseek");
2279 #endif /* DEBUG_OSL_FILE */
2280             }
2281             return (result);
2282         }
2283
2284         /* Success. Restore saved position */
2285         if (lseek (pHandleImpl->fd, (off_t)nCurPos, SEEK_SET) < 0)
2286         {
2287             PERROR("ftruncate: lseek", "Out osl_setFileSize [error]");
2288             return (result);
2289         }
2290     }
2291
2292     return (osl_File_E_None);
2293 }
2294
2295 /*###############################################*/
2296 oslFileError SAL_CALL osl_syncFile(oslFileHandle Handle)
2297 {
2298     oslFileHandleImpl* handle_impl = (oslFileHandleImpl*)Handle;
2299
2300     if (handle_impl == 0)
2301         return osl_File_E_INVAL;
2302
2303     if (fsync(handle_impl->fd) == -1)
2304         return oslTranslateFileError(OSL_FET_ERROR, errno);
2305
2306     return osl_File_E_None;
2307 }
2308
2309 /******************************************************************************
2310  *
2311  *                  C-String Versions of Exported Module Functions
2312  *
2313  *****************************************************************************/
2314
2315 #ifdef HAVE_STATFS_H
2316
2317 #if defined(FREEBSD) || defined(NETBSD) || defined(MACOSX)
2318 #   define __OSL_STATFS_STRUCT                          struct statfs
2319 #   define __OSL_STATFS(dir, sfs)                       statfs((dir), (sfs))
2320 #   define __OSL_STATFS_BLKSIZ(a)                       ((sal_uInt64)((a).f_bsize))
2321 #   define __OSL_STATFS_TYPENAME(a)                     ((a).f_fstypename)
2322 #   define __OSL_STATFS_ISREMOTE(a)                     (((a).f_type & MNT_LOCAL) == 0)
2323
2324 /* always return true if queried for the properties of
2325    the file system. If you think this is wrong under any
2326    of the target platforms fix it!!!! */
2327 #       define __OSL_STATFS_IS_CASE_SENSITIVE_FS(a)      (1)
2328 #       define __OSL_STATFS_IS_CASE_PRESERVING_FS(a) (1)
2329 #endif /* FREEBSD || NETBSD */
2330
2331 #if defined(LINUX)
2332 #       define __OSL_NFS_SUPER_MAGIC                             0x6969
2333 #       define __OSL_SMB_SUPER_MAGIC                             0x517B
2334 #       define __OSL_MSDOS_SUPER_MAGIC                           0x4d44
2335 #       define __OSL_NTFS_SUPER_MAGIC                            0x5346544e
2336 #   define __OSL_STATFS_STRUCT                       struct statfs
2337 #   define __OSL_STATFS(dir, sfs)                        statfs((dir), (sfs))
2338 #   define __OSL_STATFS_BLKSIZ(a)                        ((sal_uInt64)((a).f_bsize))
2339 #   define __OSL_STATFS_IS_NFS(a)                        (__OSL_NFS_SUPER_MAGIC == (a).f_type)
2340 #   define __OSL_STATFS_IS_SMB(a)                        (__OSL_SMB_SUPER_MAGIC == (a).f_type)
2341 #   define __OSL_STATFS_ISREMOTE(a)                      (__OSL_STATFS_IS_NFS((a)) || __OSL_STATFS_IS_SMB((a)))
2342 #       define __OSL_STATFS_IS_CASE_SENSITIVE_FS(a)  ((__OSL_MSDOS_SUPER_MAGIC != (a).f_type) && (__OSL_NTFS_SUPER_MAGIC != (a).f_type))
2343 #       define __OSL_STATFS_IS_CASE_PRESERVING_FS(a) ((__OSL_MSDOS_SUPER_MAGIC != (a).f_type))
2344 #endif /* LINUX */
2345
2346 #if defined(SOLARIS) || defined(IRIX)
2347 #   define __OSL_STATFS_STRUCT                           struct statvfs
2348 #   define __OSL_STATFS(dir, sfs)                        statvfs((dir), (sfs))
2349 #   define __OSL_STATFS_BLKSIZ(a)                        ((sal_uInt64)((a).f_frsize))
2350 #   define __OSL_STATFS_TYPENAME(a)                      ((a).f_basetype)
2351 #   define __OSL_STATFS_ISREMOTE(a)                      (rtl_str_compare((a).f_basetype, "nfs") == 0)
2352
2353 /* always return true if queried for the properties of
2354    the file system. If you think this is wrong under any
2355    of the target platforms fix it!!!! */
2356 #       define __OSL_STATFS_IS_CASE_SENSITIVE_FS(a)      (1)
2357 #       define __OSL_STATFS_IS_CASE_PRESERVING_FS(a) (1)
2358 #endif /* SOLARIS || IRIX*/
2359
2360 #   define __OSL_STATFS_INIT(a)             (memset(&(a), 0, sizeof(__OSL_STATFS_STRUCT)))
2361
2362 #else /* no statfs available */
2363
2364 #   define __OSL_STATFS_STRUCT                           struct dummy {int i;}
2365 #   define __OSL_STATFS_INIT(a)                          ((void)0)
2366 #   define __OSL_STATFS(dir, sfs)                    (1)
2367 #   define __OSL_STATFS_ISREMOTE(sfs)                    (0)
2368 #       define __OSL_STATFS_IS_CASE_SENSITIVE_FS(a)      (1)
2369 #       define __OSL_STATFS_IS_CASE_PRESERVING_FS(a) (1)
2370 #endif /* HAVE_STATFS_H */
2371
2372
2373 static oslFileError osl_psz_getVolumeInformation (
2374     const sal_Char* pszDirectory, oslVolumeInfo* pInfo, sal_uInt32 uFieldMask)
2375 {
2376     __OSL_STATFS_STRUCT sfs;
2377
2378     if (!pInfo)
2379         return osl_File_E_INVAL;
2380
2381     __OSL_STATFS_INIT(sfs);
2382
2383     pInfo->uValidFields = 0;
2384     pInfo->uAttributes  = 0;
2385
2386     if ((__OSL_STATFS(pszDirectory, &sfs)) < 0)
2387     {
2388         oslFileError result = oslTranslateFileError(OSL_FET_ERROR, errno);
2389         return (result);
2390     }
2391
2392     /* FIXME: how to detect the kind of storage (fixed, cdrom, ...) */
2393     if (uFieldMask & osl_VolumeInfo_Mask_Attributes)
2394     {
2395         if (__OSL_STATFS_ISREMOTE(sfs))
2396             pInfo->uAttributes  |= osl_Volume_Attribute_Remote;
2397
2398         pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
2399     }
2400
2401     if (uFieldMask & osl_VolumeInfo_Mask_FileSystemCaseHandling)
2402     {
2403         if (__OSL_STATFS_IS_CASE_SENSITIVE_FS(sfs))
2404             pInfo->uAttributes |= osl_Volume_Attribute_Case_Sensitive;
2405
2406         if (__OSL_STATFS_IS_CASE_PRESERVING_FS(sfs))
2407             pInfo->uAttributes |= osl_Volume_Attribute_Case_Is_Preserved;
2408
2409         pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
2410     }
2411
2412     pInfo->uTotalSpace = 0;
2413     pInfo->uFreeSpace  = 0;
2414     pInfo->uUsedSpace  = 0;
2415
2416 #if defined(__OSL_STATFS_BLKSIZ)
2417
2418     if ((uFieldMask & osl_VolumeInfo_Mask_TotalSpace) ||
2419         (uFieldMask & osl_VolumeInfo_Mask_UsedSpace))
2420     {
2421         pInfo->uTotalSpace   = __OSL_STATFS_BLKSIZ(sfs);
2422         pInfo->uTotalSpace  *= (sal_uInt64)(sfs.f_blocks);
2423         pInfo->uValidFields |= osl_VolumeInfo_Mask_TotalSpace;
2424     }
2425
2426     if ((uFieldMask & osl_VolumeInfo_Mask_FreeSpace) ||
2427         (uFieldMask & osl_VolumeInfo_Mask_UsedSpace))
2428     {
2429         pInfo->uFreeSpace = __OSL_STATFS_BLKSIZ(sfs);
2430
2431         if (getuid() == 0)
2432             pInfo->uFreeSpace *= (sal_uInt64)(sfs.f_bfree);
2433         else
2434             pInfo->uFreeSpace *= (sal_uInt64)(sfs.f_bavail);
2435
2436         pInfo->uValidFields |= osl_VolumeInfo_Mask_FreeSpace;
2437     }
2438
2439 #endif  /* __OSL_STATFS_BLKSIZ */
2440
2441     if ((pInfo->uValidFields & osl_VolumeInfo_Mask_TotalSpace) &&
2442         (pInfo->uValidFields & osl_VolumeInfo_Mask_FreeSpace ))
2443     {
2444         pInfo->uUsedSpace    = pInfo->uTotalSpace - pInfo->uFreeSpace;
2445         pInfo->uValidFields |= osl_VolumeInfo_Mask_UsedSpace;
2446     }
2447
2448     pInfo->uMaxNameLength = 0;
2449     if (uFieldMask & osl_VolumeInfo_Mask_MaxNameLength)
2450     {
2451         long nLen = pathconf(pszDirectory, _PC_NAME_MAX);
2452         if (nLen > 0)
2453         {
2454             pInfo->uMaxNameLength = (sal_uInt32)nLen;
2455             pInfo->uValidFields |= osl_VolumeInfo_Mask_MaxNameLength;
2456         }
2457     }
2458
2459     pInfo->uMaxPathLength = 0;
2460     if (uFieldMask & osl_VolumeInfo_Mask_MaxPathLength)
2461     {
2462         long nLen = pathconf (pszDirectory, _PC_PATH_MAX);
2463         if (nLen > 0)
2464         {
2465             pInfo->uMaxPathLength  = (sal_uInt32)nLen;
2466             pInfo->uValidFields   |= osl_VolumeInfo_Mask_MaxPathLength;
2467         }
2468     }
2469
2470 #if defined(__OSL_STATFS_TYPENAME)
2471
2472     if (uFieldMask & osl_VolumeInfo_Mask_FileSystemName)
2473     {
2474         rtl_string2UString(
2475             &(pInfo->ustrFileSystemName),
2476             __OSL_STATFS_TYPENAME(sfs),
2477             rtl_str_getLength(__OSL_STATFS_TYPENAME(sfs)),
2478             osl_getThreadTextEncoding(),
2479             OUSTRING_TO_OSTRING_CVTFLAGS);
2480         OSL_ASSERT(pInfo->ustrFileSystemName != 0);
2481
2482         pInfo->uValidFields |= osl_VolumeInfo_Mask_FileSystemName;
2483     }
2484
2485 #endif /* __OSL_STATFS_TYPENAME */
2486
2487     if (uFieldMask & osl_VolumeInfo_Mask_DeviceHandle)
2488     {
2489         /* FIXME: check also entries in mntent for the device
2490            and fill it with correct values */
2491
2492         *pInfo->pDeviceHandle = osl_isFloppyDrive(pszDirectory);
2493
2494         if (*pInfo->pDeviceHandle)
2495         {
2496             pInfo->uValidFields |= osl_VolumeInfo_Mask_DeviceHandle;
2497             pInfo->uAttributes  |= osl_Volume_Attribute_Removeable;
2498             pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
2499         }
2500     }
2501     return osl_File_E_None;
2502 }
2503
2504 /******************************************
2505  * osl_psz_setFileTime
2506  *****************************************/
2507
2508 static oslFileError osl_psz_setFileTime( const sal_Char* pszFilePath,
2509                                   const TimeValue* /*pCreationTime*/,
2510                                   const TimeValue* pLastAccessTime,
2511                                   const TimeValue* pLastWriteTime )
2512 {
2513     int nRet=0;
2514     struct utimbuf aTimeBuffer;
2515     struct stat aFileStat;
2516 #ifdef DEBUG_OSL_FILE
2517     struct tm* pTM=0;
2518 #endif
2519
2520     nRet = lstat(pszFilePath,&aFileStat);
2521
2522     if ( nRet < 0 )
2523     {
2524         nRet=errno;
2525         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2526     }
2527
2528 #ifdef DEBUG_OSL_FILE
2529     fprintf(stderr,"File Times are (in localtime):\n");
2530     pTM=localtime(&aFileStat.st_ctime);
2531     fprintf(stderr,"CreationTime is '%s'\n",asctime(pTM));
2532     pTM=localtime(&aFileStat.st_atime);
2533     fprintf(stderr,"AccessTime   is '%s'\n",asctime(pTM));
2534     pTM=localtime(&aFileStat.st_mtime);
2535     fprintf(stderr,"Modification is '%s'\n",asctime(pTM));
2536
2537     fprintf(stderr,"File Times are (in UTC):\n");
2538     fprintf(stderr,"CreationTime is '%s'\n",ctime(&aFileStat.st_ctime));
2539     fprintf(stderr,"AccessTime   is '%s'\n",ctime(&aTimeBuffer.actime));
2540     fprintf(stderr,"Modification is '%s'\n",ctime(&aTimeBuffer.modtime));
2541 #endif
2542
2543     if ( pLastAccessTime != 0 )
2544     {
2545         aTimeBuffer.actime=pLastAccessTime->Seconds;
2546     }
2547     else
2548     {
2549         aTimeBuffer.actime=aFileStat.st_atime;
2550     }
2551
2552     if ( pLastWriteTime != 0 )
2553     {
2554         aTimeBuffer.modtime=pLastWriteTime->Seconds;
2555     }
2556     else
2557     {
2558         aTimeBuffer.modtime=aFileStat.st_mtime;
2559     }
2560
2561     /* mfe: Creation time not used here! */
2562
2563 #ifdef DEBUG_OSL_FILE
2564     fprintf(stderr,"File Times are (in localtime):\n");
2565     pTM=localtime(&aFileStat.st_ctime);
2566     fprintf(stderr,"CreationTime now '%s'\n",asctime(pTM));
2567     pTM=localtime(&aTimeBuffer.actime);
2568     fprintf(stderr,"AccessTime   now '%s'\n",asctime(pTM));
2569     pTM=localtime(&aTimeBuffer.modtime);
2570     fprintf(stderr,"Modification now '%s'\n",asctime(pTM));
2571
2572     fprintf(stderr,"File Times are (in UTC):\n");
2573     fprintf(stderr,"CreationTime now '%s'\n",ctime(&aFileStat.st_ctime));
2574     fprintf(stderr,"AccessTime   now '%s'\n",ctime(&aTimeBuffer.actime));
2575     fprintf(stderr,"Modification now '%s'\n",ctime(&aTimeBuffer.modtime));
2576 #endif
2577
2578     nRet=utime(pszFilePath,&aTimeBuffer);
2579     if ( nRet < 0 )
2580     {
2581         nRet=errno;
2582         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2583     }
2584
2585     return osl_File_E_None;
2586 }
2587
2588
2589 /*****************************************
2590  * osl_psz_removeFile
2591  ****************************************/
2592 #if 0
2593 static oslFileError osl_psz_removeFile( const sal_Char* pszPath )
2594 {
2595     int nRet=0;
2596     struct stat aStat;
2597
2598     nRet = stat(pszPath,&aStat);
2599     if ( nRet < 0 )
2600     {
2601         nRet=errno;
2602         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2603     }
2604
2605     if ( S_ISDIR(aStat.st_mode) )
2606     {
2607         return osl_File_E_ISDIR;
2608     }
2609
2610     nRet = unlink(pszPath);
2611     if ( nRet < 0 )
2612     {
2613         nRet=errno;
2614         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2615     }
2616
2617     return osl_File_E_None;
2618 }
2619 #endif
2620
2621 /*****************************************
2622  * osl_psz_createDirectory
2623  ****************************************/
2624 #if 0
2625 static oslFileError osl_psz_createDirectory( const sal_Char* pszPath )
2626 {
2627     int nRet=0;
2628     int mode = S_IRWXU | S_IRWXG | S_IRWXO;
2629
2630     nRet = mkdir(pszPath,mode);
2631
2632     if ( nRet < 0 )
2633     {
2634         nRet=errno;
2635         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2636     }
2637
2638     return osl_File_E_None;
2639 }
2640 #endif
2641 /*****************************************
2642  * osl_psz_removeDirectory
2643  ****************************************/
2644 #if 0
2645 static oslFileError osl_psz_removeDirectory( const sal_Char* pszPath )
2646 {
2647     int nRet=0;
2648
2649     nRet = rmdir(pszPath);
2650
2651     if ( nRet < 0 )
2652     {
2653         nRet=errno;
2654         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2655     }
2656
2657     return osl_File_E_None;
2658 }
2659 #endif
2660 /*****************************************
2661  * oslDoMoveFile
2662  ****************************************/
2663 #if 0
2664 static oslFileError oslDoMoveFile( const sal_Char* pszPath, const sal_Char* pszDestPath)
2665 {
2666     oslFileError tErr=osl_File_E_invalidError;
2667
2668     tErr = osl_psz_moveFile(pszPath,pszDestPath);
2669     if ( tErr == osl_File_E_None )
2670     {
2671         return tErr;
2672     }
2673
2674     if ( tErr != osl_File_E_XDEV )
2675     {
2676         return tErr;
2677     }
2678
2679     tErr=osl_psz_copyFile(pszPath,pszDestPath);
2680
2681     if ( tErr != osl_File_E_None )
2682     {
2683         oslFileError tErrRemove;
2684         tErrRemove=osl_psz_removeFile(pszDestPath);
2685         return tErr;
2686     }
2687
2688     tErr=osl_psz_removeFile(pszPath);
2689
2690     return tErr;
2691 }
2692 #endif
2693 /*****************************************
2694  * osl_psz_moveFile
2695  ****************************************/
2696 #if 0
2697 static oslFileError osl_psz_moveFile(const sal_Char* pszPath, const sal_Char* pszDestPath)
2698 {
2699
2700     int nRet = 0;
2701
2702     nRet = rename(pszPath,pszDestPath);
2703
2704     if ( nRet < 0 )
2705     {
2706         nRet=errno;
2707         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2708     }
2709
2710     return osl_File_E_None;
2711 }
2712 #endif
2713 /*****************************************
2714  * osl_psz_copyFile
2715  ****************************************/
2716 #if 0
2717 static oslFileError osl_psz_copyFile( const sal_Char* pszPath, const sal_Char* pszDestPath )
2718 {
2719     time_t nAcTime=0;
2720     time_t nModTime=0;
2721     uid_t nUID=0;
2722     gid_t nGID=0;
2723     int nRet=0;
2724     mode_t nMode=0;
2725     struct stat aFileStat;
2726     oslFileError tErr=osl_File_E_invalidError;
2727     size_t nSourceSize=0;
2728     int DestFileExists=1;
2729
2730     /* mfe: does the source file really exists? */
2731     nRet = lstat(pszPath,&aFileStat);
2732
2733     if ( nRet < 0 )
2734     {
2735         nRet=errno;
2736         return oslTranslateFileError(OSL_FET_ERROR, nRet);
2737     }
2738
2739     /* mfe: we do only copy files here! */
2740     if ( S_ISDIR(aFileStat.st_mode) )
2741     {
2742         return osl_File_E_ISDIR;
2743     }
2744
2745     nSourceSize=(size_t)aFileStat.st_size;
2746     nMode=aFileStat.st_mode;
2747     nAcTime=aFileStat.st_atime;
2748     nModTime=aFileStat.st_mtime;
2749     nUID=aFileStat.st_uid;
2750     nGID=aFileStat.st_gid;
2751
2752     nRet = stat(pszDestPath,&aFileStat);
2753     if ( nRet < 0 )
2754     {
2755         nRet=errno;
2756
2757         if ( nRet == ENOENT )
2758         {
2759             DestFileExists=0;
2760         }
2761 /*        return oslTranslateFileError(nRet);*/
2762     }
2763
2764     /* mfe: the destination file must not be a directory! */
2765     if ( nRet == 0 && S_ISDIR(aFileStat.st_mode) )
2766     {
2767         return osl_File_E_ISDIR;
2768     }
2769     else
2770     {
2771         /* mfe: file does not exists or is no dir */
2772     }
2773
2774     tErr = oslDoCopy(pszPath,pszDestPath,nMode,nSourceSize,DestFileExists);
2775
2776     if ( tErr != osl_File_E_None )
2777     {
2778         return tErr;
2779     }
2780
2781     /*
2782      *   mfe: ignore return code
2783      *        since only  the success of the copy is
2784      *        important
2785      */
2786     oslChangeFileModes(pszDestPath,nMode,nAcTime,nModTime,nUID,nGID);
2787
2788     return tErr;
2789 }
2790 #endif
2791
2792 /******************************************************************************
2793  *
2794  *                  Utility Functions
2795  *
2796  *****************************************************************************/
2797
2798
2799 /*****************************************
2800  * oslMakeUStrFromPsz
2801  ****************************************/
2802
2803 rtl_uString* oslMakeUStrFromPsz(const sal_Char* pszStr, rtl_uString** ustrValid)
2804 {
2805     rtl_string2UString(
2806         ustrValid,
2807         pszStr,
2808         rtl_str_getLength( pszStr ),
2809         osl_getThreadTextEncoding(),
2810         OUSTRING_TO_OSTRING_CVTFLAGS );
2811     OSL_ASSERT(*ustrValid != 0);
2812
2813     return *ustrValid;
2814 }
2815
2816 /*****************************************************************************
2817  * UnicodeToText
2818  * converting unicode to text manually saves us the penalty of a temporary
2819  * rtl_String object.
2820  ****************************************************************************/
2821
2822 int UnicodeToText( char * buffer, size_t bufLen, const sal_Unicode * uniText, sal_Int32 uniTextLen )
2823 {
2824     rtl_UnicodeToTextConverter hConverter;
2825     sal_uInt32   nInfo;
2826     sal_Size   nSrcChars, nDestBytes;
2827
2828     /* stolen from rtl/string.c */
2829     hConverter = rtl_createUnicodeToTextConverter( osl_getThreadTextEncoding() );
2830
2831     nDestBytes = rtl_convertUnicodeToText( hConverter, 0, uniText, uniTextLen,
2832                                            buffer, bufLen,
2833                                            OUSTRING_TO_OSTRING_CVTFLAGS | RTL_UNICODETOTEXT_FLAGS_FLUSH,
2834                                            &nInfo, &nSrcChars );
2835
2836     rtl_destroyUnicodeToTextConverter( hConverter );
2837
2838     if( nInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL )
2839     {
2840         errno = EOVERFLOW;
2841         return 0;
2842     }
2843
2844     /* ensure trailing '\0' */
2845     buffer[nDestBytes] = '\0';
2846
2847     return nDestBytes;
2848 }
2849
2850 /*****************************************************************************
2851    TextToUnicode
2852
2853    @param text
2854           The text to convert.
2855
2856    @param text_buffer_size
2857           The number of characters.
2858
2859    @param unic_text
2860           The unicode buffer.
2861
2862    @param unic_text_buffer_size
2863              The size in characters of the unicode buffer.
2864
2865  ****************************************************************************/
2866
2867 int TextToUnicode(
2868     const char*  text,
2869     size_t       text_buffer_size,
2870     sal_Unicode* unic_text,
2871     sal_Int32    unic_text_buffer_size)
2872 {
2873     rtl_TextToUnicodeConverter hConverter;
2874     sal_uInt32 nInfo;
2875     sal_Size nSrcChars;
2876     sal_Size nDestBytes;
2877
2878     /* stolen from rtl/string.c */
2879     hConverter = rtl_createTextToUnicodeConverter(osl_getThreadTextEncoding());
2880
2881     nDestBytes = rtl_convertTextToUnicode(hConverter,
2882                                           0,
2883                                           text,  text_buffer_size,
2884                                           unic_text, unic_text_buffer_size,
2885                                           OSTRING_TO_OUSTRING_CVTFLAGS | RTL_TEXTTOUNICODE_FLAGS_FLUSH,
2886                                           &nInfo, &nSrcChars);
2887
2888     rtl_destroyTextToUnicodeConverter(hConverter);
2889
2890     if (nInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL)
2891     {
2892         errno = EOVERFLOW;
2893         return 0;
2894     }
2895
2896     /* ensure trailing '\0' */
2897     unic_text[nDestBytes] = '\0';
2898
2899     return nDestBytes;
2900 }
2901
2902 /******************************************************************************
2903  *
2904  *                  GENERIC FLOPPY FUNCTIONS
2905  *
2906  *****************************************************************************/
2907
2908
2909 /*****************************************
2910  * osl_unmountVolumeDevice
2911  ****************************************/
2912
2913 oslFileError osl_unmountVolumeDevice( oslVolumeDeviceHandle Handle )
2914 {
2915     oslFileError tErr = osl_File_E_NOSYS;
2916
2917     tErr = osl_unmountFloppy(Handle);
2918
2919      /* Perhaps current working directory is set to mount point */
2920
2921      if ( tErr )
2922     {
2923         sal_Char *pszHomeDir = getenv("HOME");
2924
2925         if ( pszHomeDir && strlen( pszHomeDir ) && 0 == chdir( pszHomeDir ) )
2926         {
2927             /* try again */
2928
2929             tErr = osl_unmountFloppy(Handle);
2930
2931             OSL_ENSURE( tErr, "osl_unmountvolumeDevice: CWD was set to volume mount point" );
2932         }
2933     }
2934
2935     return tErr;
2936 }
2937
2938 /*****************************************
2939  * osl_automountVolumeDevice
2940  ****************************************/
2941
2942 oslFileError osl_automountVolumeDevice( oslVolumeDeviceHandle Handle )
2943 {
2944     oslFileError tErr = osl_File_E_NOSYS;
2945
2946     tErr = osl_mountFloppy(Handle);
2947
2948     return tErr;
2949 }
2950
2951 /*****************************************
2952  * osl_getVolumeDeviceMountPath
2953  ****************************************/
2954
2955 oslFileError osl_getVolumeDeviceMountPath( oslVolumeDeviceHandle Handle, rtl_uString **pstrPath )
2956 {
2957     oslVolumeDeviceHandleImpl* pItem = (oslVolumeDeviceHandleImpl*) Handle;
2958     sal_Char Buffer[PATH_MAX];
2959
2960     Buffer[0] = '\0';
2961
2962     if ( pItem == 0 || pstrPath == 0 )
2963     {
2964         return osl_File_E_INVAL;
2965     }
2966
2967     if ( pItem->ident[0] != 'O' || pItem->ident[1] != 'V' || pItem->ident[2] != 'D' || pItem->ident[3] != 'H' )
2968     {
2969         return osl_File_E_INVAL;
2970     }
2971
2972 #ifdef DEBUG_OSL_FILE
2973     fprintf(stderr,"Handle is:\n");
2974     osl_printFloppyHandle(pItem);
2975 #endif
2976
2977     snprintf(Buffer, sizeof(Buffer), "file://%s", pItem->pszMountPoint);
2978
2979 #ifdef DEBUG_OSL_FILE
2980     fprintf(stderr,"Mount Point is: '%s'\n",Buffer);
2981 #endif
2982
2983     oslMakeUStrFromPsz(Buffer, pstrPath);
2984
2985     return osl_File_E_None;
2986 }
2987
2988 /*****************************************
2989  * osl_acquireVolumeDeviceHandle
2990  ****************************************/
2991
2992 oslFileError SAL_CALL osl_acquireVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
2993 {
2994     oslVolumeDeviceHandleImpl* pItem =(oslVolumeDeviceHandleImpl*) Handle;
2995
2996     if ( pItem == 0 )
2997     {
2998         return osl_File_E_INVAL;
2999     }
3000
3001     if ( pItem->ident[0] != 'O' || pItem->ident[1] != 'V' || pItem->ident[2] != 'D' || pItem->ident[3] != 'H' )
3002     {
3003         return osl_File_E_INVAL;
3004     }
3005
3006     ++pItem->RefCount;
3007
3008     return osl_File_E_None;
3009 }
3010
3011 /*****************************************
3012  * osl_releaseVolumeDeviceHandle
3013  ****************************************/
3014
3015 oslFileError osl_releaseVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
3016 {
3017     oslVolumeDeviceHandleImpl* pItem =(oslVolumeDeviceHandleImpl*) Handle;
3018
3019     if ( pItem == 0 )
3020     {
3021         return osl_File_E_INVAL;
3022     }
3023
3024     if ( pItem->ident[0] != 'O' || pItem->ident[1] != 'V' || pItem->ident[2] != 'D' || pItem->ident[3] != 'H' )
3025     {
3026         return osl_File_E_INVAL;
3027     }
3028
3029     --pItem->RefCount;
3030
3031     if ( pItem->RefCount == 0 )
3032     {
3033         rtl_freeMemory(pItem);
3034     }
3035
3036     return osl_File_E_None;
3037 }
3038
3039 /*****************************************
3040  * osl_newVolumeDeviceHandleImpl
3041  ****************************************/
3042
3043 static oslVolumeDeviceHandleImpl* osl_newVolumeDeviceHandleImpl()
3044 {
3045     oslVolumeDeviceHandleImpl* pHandle;
3046     const size_t               nSizeOfHandle = sizeof(oslVolumeDeviceHandleImpl);
3047
3048     pHandle = (oslVolumeDeviceHandleImpl*) rtl_allocateMemory (nSizeOfHandle);
3049     if (pHandle != NULL)
3050     {
3051         pHandle->ident[0]         = 'O';
3052         pHandle->ident[1]         = 'V';
3053         pHandle->ident[2]         = 'D';
3054         pHandle->ident[3]         = 'H';
3055         pHandle->pszMountPoint[0] = '\0';
3056         pHandle->pszFilePath[0]   = '\0';
3057         pHandle->pszDevice[0]     = '\0';
3058         pHandle->RefCount         = 1;
3059     }
3060     return pHandle;
3061 }
3062
3063 /*****************************************
3064  * osl_freeVolumeDeviceHandleImpl
3065  ****************************************/
3066
3067 static void osl_freeVolumeDeviceHandleImpl (oslVolumeDeviceHandleImpl* pHandle)
3068 {
3069     if (pHandle != NULL)
3070         rtl_freeMemory (pHandle);
3071 }
3072
3073
3074 /******************************************************************************
3075  *
3076  *                  OS/2 FLOPPY FUNCTIONS
3077  *
3078  *****************************************************************************/
3079
3080 #if defined(OS2)
3081 static oslVolumeDeviceHandle osl_isFloppyDrive(const sal_Char* pszPath)
3082 {
3083     return NULL;
3084 }
3085
3086 static oslFileError osl_mountFloppy(oslVolumeDeviceHandle hFloppy)
3087 {
3088     return osl_File_E_BUSY;
3089 }
3090
3091 static oslFileError osl_unmountFloppy(oslVolumeDeviceHandle hFloppy)
3092 {
3093     return osl_File_E_BUSY;
3094 }
3095
3096 static sal_Bool osl_getFloppyMountEntry(const sal_Char* pszPath, oslVolumeDeviceHandleImpl* pItem)
3097 {
3098     return sal_False;
3099 }
3100
3101 static sal_Bool osl_isFloppyMounted(oslVolumeDeviceHandleImpl* pDevice)
3102 {
3103     return sal_False;
3104 }
3105
3106
3107 #ifdef DEBUG_OSL_FILE
3108 static void osl_printFloppyHandle(oslVolumeDeviceHandleImpl* pItem)
3109 {
3110     if (pItem == 0 )
3111     {
3112         fprintf(stderr,"NULL Handle\n");
3113         return;
3114     }
3115     if ( pItem->ident[0] != 'O' || pItem->ident[1] != 'V' || pItem->ident[2] != 'D' || pItem->ident[3] != 'H' )
3116     {
3117 #ifdef TRACE_OSL_FILE
3118         fprintf(stderr,"Invalid Handle]\n");
3119 #endif
3120         return;
3121     }
3122
3123
3124     fprintf(stderr,"MountPoint : '%s'\n",pItem->pszMountPoint);
3125     fprintf(stderr,"FilePath   : '%s'\n",pItem->pszFilePath);
3126     fprintf(stderr,"Device     : '%s'\n",pItem->pszDevice);
3127
3128     return;
3129 }
3130 #endif
3131
3132 #endif /* OS2 */