sal/osl/unx/file_misc.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  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 #include "osl/file.hxx"
  29
  30 #include "osl/diagnose.h"
  31 #include "osl/thread.h"
  32 #include "rtl/alloc.h"
  33
  34 #include "system.h"
  35 #include "file_impl.hxx"
  36 #include "file_error_transl.h"
  37 #include "file_path_helper.hxx"
  38 #include "file_url.h"
  39 #include "uunxapi.hxx"
  40
  41 #include <sys/types.h>
  42 #include <errno.h>
  43 #include <dirent.h>
  44 #include <limits.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <sys/stat.h>
  49 #include <sys/mman.h>
  50
  51 /************************************************************************
  52  *   ToDo
  53  *
  54  *   - Fix: check for corresponding struct sizes in exported functions
  55  *   - check size/use of oslDirectory
  56  *   - check size/use of oslDirectoryItem
  57  ***********************************************************************/
  58 /******************************************************************************
  59  *
  60  *                  Data Type Definition
  61  *
  62  ******************************************************************************/
  63
  64 typedef struct
  65 {
  66     rtl_uString* ustrPath;           /* holds native directory path */
  67     DIR*         pDirStruct;
  68 } oslDirectoryImpl;
  69
  70 #if 0
  71 /* FIXME: reintroducing this may save some extra bytes per Item */
  72 typedef struct
  73 {
  74     rtl_uString* ustrFileName;       /* holds native file name */
  75     rtl_uString* ustrDirPath;        /* holds native dir path */
  76     sal_uInt32   RefCount;
  77 } oslDirectoryItemImpl;
  78 #endif
  79
  80 DirectoryItem_Impl::DirectoryItem_Impl(
  81     rtl_uString * ustrFilePath, unsigned char DType)
  82     : m_RefCount     (1),
  83       m_ustrFilePath (ustrFilePath),
  84       m_DType        (DType)
  85 {
  86     if (m_ustrFilePath != 0)
  87         rtl_uString_acquire(m_ustrFilePath);
  88 }
  89 DirectoryItem_Impl::~DirectoryItem_Impl()
  90 {
  91     if (m_ustrFilePath != 0)
  92         rtl_uString_release(m_ustrFilePath);
  93 }
  94
  95 void * DirectoryItem_Impl::operator new(size_t n)
  96 {
  97     return rtl_allocateMemory(n);
  98 }
  99 void DirectoryItem_Impl::operator delete(void * p, size_t)
 100 {
 101     rtl_freeMemory(p);
 102 }
 103
 104 void DirectoryItem_Impl::acquire()
 105 {
 106     ++m_RefCount;
 107 }
 108 void DirectoryItem_Impl::release()
 109 {
 110     if (0 == --m_RefCount)
 111         delete this;
 112 }
 113
 114 oslFileType DirectoryItem_Impl::getFileType() const
 115 {
 116     switch (m_DType)
 117     {
 118 #ifdef _DIRENT_HAVE_D_TYPE
 119         case DT_LNK:
 120             return osl_File_Type_Link;
 121         case DT_DIR:
 122             return osl_File_Type_Directory;
 123         case DT_REG:
 124             return osl_File_Type_Regular;
 125         case DT_FIFO:
 126             return osl_File_Type_Fifo;
 127         case DT_SOCK:
 128             return osl_File_Type_Socket;
 129         case DT_CHR:
 130         case DT_BLK:
 131             return osl_File_Type_Special;
 132 #endif /* _DIRENT_HAVE_D_TYPE */
 133         default:
 134             break;
 135     }
 136     return osl_File_Type_Unknown;
 137 }
 138
 139 /******************************************************************************
 140  *
 141  *                  C-String Function Declarations
 142  *
 143  *****************************************************************************/
 144
 145 static oslFileError osl_psz_createDirectory(const sal_Char* pszPath);
 146 static oslFileError osl_psz_removeDirectory(const sal_Char* pszPath);
 147
 148 /*******************************************************************
 149  *      osl_openDirectory
 150  ******************************************************************/
 151
 152 oslFileError SAL_CALL osl_openDirectory(rtl_uString* ustrDirectoryURL, oslDirectory* pDirectory)
 153 {
 154     rtl_uString* ustrSystemPath = NULL;
 155     oslFileError eRet;
 156
 157     char path[PATH_MAX];
 158
 159     if ((0 == ustrDirectoryURL) || (0 == ustrDirectoryURL->length) || (0 == pDirectory))
 160         return osl_File_E_INVAL;
 161
 162     /* convert file URL to system path */
 163     eRet = osl_getSystemPathFromFileURL_Ex(ustrDirectoryURL, &ustrSystemPath, sal_False);
 164
 165     if( osl_File_E_None != eRet )
 166         return eRet;
 167
 168     osl_systemPathRemoveSeparator(ustrSystemPath);
 169
 170     /* convert unicode path to text */
 171     if ( UnicodeToText( path, PATH_MAX, ustrSystemPath->buffer, ustrSystemPath->length )
 172 #ifdef MACOSX
 173      && macxp_resolveAlias( path, PATH_MAX ) == 0
 174 #endif /* MACOSX */
 175      )
 176     {
 177         /* open directory */
 178         DIR *pdir = opendir( path );
 179
 180         if( pdir )
 181         {
 182             /* create and initialize impl structure */
 183             oslDirectoryImpl* pDirImpl = (oslDirectoryImpl*) rtl_allocateMemory( sizeof(oslDirectoryImpl) );
 184
 185             if( pDirImpl )
 186             {
 187                 pDirImpl->pDirStruct = pdir;
 188                 pDirImpl->ustrPath = ustrSystemPath;
 189
 190                 *pDirectory = (oslDirectory) pDirImpl;
 191                 return osl_File_E_None;
 192             }
 193             else
 194             {
 195                 errno = ENOMEM;
 196                 closedir( pdir );
 197             }
 198         }
 199         else
 200         {
 201 #ifdef DEBUG_OSL_FILE
 202             perror ("osl_openDirectory"); fprintf (stderr, path);
 203 #endif
 204         }
 205     }
 206
 207     rtl_uString_release( ustrSystemPath );
 208
 209     return oslTranslateFileError(OSL_FET_ERROR, errno);
 210 }
 211
 212 /****************************************************************************/
 213 /*      osl_closeDirectory */
 214 /****************************************************************************/
 215
 216 oslFileError SAL_CALL osl_closeDirectory( oslDirectory Directory )
 217 {
 218     oslDirectoryImpl* pDirImpl = (oslDirectoryImpl*) Directory;
 219     oslFileError err = osl_File_E_None;
 220
 221     OSL_ASSERT( Directory );
 222
 223     if( NULL == pDirImpl )
 224         return osl_File_E_INVAL;
 225
 226     /* close directory */
 227     if( closedir( pDirImpl->pDirStruct ) )
 228     {
 229         err = oslTranslateFileError(OSL_FET_ERROR, errno);
 230     }
 231
 232     /* cleanup members */
 233     rtl_uString_release( pDirImpl->ustrPath );
 234
 235     rtl_freeMemory( pDirImpl );
 236
 237     return err;
 238 }
 239
 240 /**********************************************
 241  * osl_readdir_impl_
 242  *
 243  * readdir wrapper, filters out "." and ".."
 244  * on request
 245  *********************************************/
 246
 247 static struct dirent* osl_readdir_impl_(DIR* pdir, sal_Bool bFilterLocalAndParentDir)
 248 {
 249     struct dirent* pdirent;
 250
 251     while ((pdirent = readdir(pdir)) != NULL)
 252     {
 253         if (bFilterLocalAndParentDir &&
 254             ((0 == strcmp(pdirent->d_name, ".")) || (0 == strcmp(pdirent->d_name, ".."))))
 255             continue;
 256         else
 257             break;
 258     }
 259
 260     return pdirent;
 261 }
 262
 263 /****************************************************************************
 264  *      osl_getNextDirectoryItem
 265  ***************************************************************************/
 266
 267 oslFileError SAL_CALL osl_getNextDirectoryItem(oslDirectory Directory, oslDirectoryItem* pItem, sal_uInt32 /*uHint*/)
 268 {
 269     oslDirectoryImpl* pDirImpl     = (oslDirectoryImpl*)Directory;
 270     rtl_uString*      ustrFileName = NULL;
 271     rtl_uString*      ustrFilePath = NULL;
 272     struct dirent*    pEntry;
 273
 274     OSL_ASSERT(Directory);
 275     OSL_ASSERT(pItem);
 276
 277     if ((NULL == Directory) || (NULL == pItem))
 278         return osl_File_E_INVAL;
 279
 280     pEntry = osl_readdir_impl_(pDirImpl->pDirStruct, sal_True);
 281
 282     if (NULL == pEntry)
 283         return osl_File_E_NOENT;
 284
 285
 286 #if defined(MACOSX)
 287
 288     // convert decomposed filename to precomposed unicode
 289     char composed_name[BUFSIZ];
 290     CFMutableStringRef strRef = CFStringCreateMutable (NULL, 0 );
 291     CFStringAppendCString( strRef, pEntry->d_name, kCFStringEncodingUTF8 );  //UTF8 is default on Mac OSX
 292     CFStringNormalize( strRef, kCFStringNormalizationFormC );
 293     CFStringGetCString( strRef, composed_name, BUFSIZ, kCFStringEncodingUTF8 );
 294     CFRelease( strRef );
 295     rtl_string2UString( &ustrFileName, composed_name, strlen( composed_name),
 296     osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
 297
 298 #else  // not MACOSX
 299     /* convert file name to unicode */
 300     rtl_string2UString( &ustrFileName, pEntry->d_name, strlen( pEntry->d_name ),
 301         osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
 302     OSL_ASSERT(ustrFileName != 0);
 303
 304 #endif
 305
 306     osl_systemPathMakeAbsolutePath(pDirImpl->ustrPath, ustrFileName, &ustrFilePath);
 307     rtl_uString_release( ustrFileName );
 308
 309     DirectoryItem_Impl * pImpl = static_cast< DirectoryItem_Impl* >(*pItem);
 310     if (0 != pImpl)
 311     {
 312         pImpl->release(), pImpl = 0;
 313     }
 314 #ifdef _DIRENT_HAVE_D_TYPE
 315     pImpl = new DirectoryItem_Impl(ustrFilePath, pEntry->d_type);
 316 #else
 317     pImpl = new DirectoryItem_Impl(ustrFilePath);
 318 #endif /* _DIRENT_HAVE_D_TYPE */
 319     *pItem = pImpl;
 320     rtl_uString_release( ustrFilePath );
 321
 322     return osl_File_E_None;
 323 }
 324
 325 /****************************************************************************/
 326 /*      osl_getDirectoryItem */
 327 /****************************************************************************/
 328
 329 oslFileError SAL_CALL osl_getDirectoryItem( rtl_uString* ustrFileURL, oslDirectoryItem* pItem )
 330 {
 331     rtl_uString* ustrSystemPath = NULL;
 332     oslFileError osl_error      = osl_File_E_INVAL;
 333
 334     OSL_ASSERT(ustrFileURL);
 335     OSL_ASSERT(pItem);
 336
 337     if (0 == ustrFileURL->length || NULL == pItem)
 338         return osl_File_E_INVAL;
 339
 340     osl_error = osl_getSystemPathFromFileURL_Ex(ustrFileURL, &ustrSystemPath, sal_False);
 341     if (osl_File_E_None != osl_error)
 342         return osl_error;
 343
 344     osl_systemPathRemoveSeparator(ustrSystemPath);
 345
 346     if (-1 == access_u(ustrSystemPath, F_OK))
 347     {
 348         osl_error = oslTranslateFileError(OSL_FET_ERROR, errno);
 349     }
 350     else
 351     {
 352         *pItem = new DirectoryItem_Impl(ustrSystemPath);
 353     }
 354     rtl_uString_release(ustrSystemPath);
 355
 356     return osl_error;
 357 }
 358
 359
 360 /****************************************************************************/
 361 /*      osl_acquireDirectoryItem */
 362 /****************************************************************************/
 363
 364 oslFileError SAL_CALL osl_acquireDirectoryItem( oslDirectoryItem Item )
 365 {
 366     DirectoryItem_Impl * pImpl = static_cast< DirectoryItem_Impl* >(Item);
 367     if (0 == pImpl)
 368         return osl_File_E_INVAL;
 369
 370     pImpl->acquire();
 371     return osl_File_E_None;
 372 }
 373
 374 /****************************************************************************/
 375 /*      osl_releaseDirectoryItem */
 376 /****************************************************************************/
 377
 378 oslFileError SAL_CALL osl_releaseDirectoryItem( oslDirectoryItem Item )
 379 {
 380     DirectoryItem_Impl * pImpl = static_cast< DirectoryItem_Impl* >(Item);
 381     if (0 == pImpl)
 382         return osl_File_E_INVAL;
 383
 384     pImpl->release();
 385     return osl_File_E_None;
 386 }
 387
 388 /****************************************************************************/
 389 /*      osl_createDirectory */
 390 /****************************************************************************/
 391
 392 oslFileError SAL_CALL osl_createDirectory( rtl_uString* ustrDirectoryURL )
 393 {
 394     char path[PATH_MAX];
 395     oslFileError eRet;
 396
 397     OSL_ASSERT( ustrDirectoryURL );
 398
 399     /* convert directory url to system path */
 400     eRet = FileURLToPath( path, PATH_MAX, ustrDirectoryURL );
 401     if( eRet != osl_File_E_None )
 402         return eRet;
 403
 404 #ifdef MACOSX
 405     if ( macxp_resolveAlias( path, PATH_MAX ) != 0 )
 406       return oslTranslateFileError( OSL_FET_ERROR, errno );
 407 #endif/* MACOSX */
 408
 409     return osl_psz_createDirectory( path );
 410 }
 411
 412 /****************************************************************************/
 413 /*      osl_removeDirectory */
 414 /****************************************************************************/
 415
 416 oslFileError SAL_CALL osl_removeDirectory( rtl_uString* ustrDirectoryURL )
 417 {
 418     char path[PATH_MAX];
 419     oslFileError eRet;
 420
 421     OSL_ASSERT( ustrDirectoryURL );
 422
 423     /* convert directory url to system path */
 424     eRet = FileURLToPath( path, PATH_MAX, ustrDirectoryURL );
 425     if( eRet != osl_File_E_None )
 426         return eRet;
 427
 428 #ifdef MACOSX
 429     if ( macxp_resolveAlias( path, PATH_MAX ) != 0 )
 430       return oslTranslateFileError( OSL_FET_ERROR, errno );
 431 #endif/* MACOSX */
 432
 433     return osl_psz_removeDirectory( path );
 434 }
 435
 436 /*****************************************
 437  * osl_psz_createDirectory
 438  ****************************************/
 439
 440 static oslFileError osl_psz_createDirectory( const sal_Char* pszPath )
 441 {
 442     int nRet=0;
 443     int mode = S_IRWXU | S_IRWXG | S_IRWXO;
 444
 445     nRet = mkdir(pszPath,mode);
 446
 447     if ( nRet < 0 )
 448     {
 449         nRet=errno;
 450         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 451     }
 452
 453     return osl_File_E_None;
 454 }
 455
 456 /*****************************************
 457  * osl_psz_removeDirectory
 458  ****************************************/
 459
 460 static oslFileError osl_psz_removeDirectory( const sal_Char* pszPath )
 461 {
 462     int nRet=0;
 463
 464     nRet = rmdir(pszPath);
 465
 466     if ( nRet < 0 )
 467     {
 468         nRet=errno;
 469         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 470     }
 471
 472     return osl_File_E_None;
 473 }
 474
 475 /****************************************************************************/
 476 /*      osl_createDirectoryPath */
 477 /****************************************************************************/
 478
 479 static int path_make_parent(sal_Unicode* path)
 480 {
 481     int i = rtl_ustr_lastIndexOfChar(path, '/');
 482
 483     if (i > 0)
 484     {
 485         *(path + i) = 0;
 486         return i;
 487     }
 488     else
 489         return 0;
 490 }
 491
 492 static int create_dir_with_callback(
 493     sal_Unicode* directory_path,
 494     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
 495     void* pData)
 496 {
 497     int mode = S_IRWXU | S_IRWXG | S_IRWXO;
 498
 499     if (osl::mkdir(directory_path, mode) == 0)
 500     {
 501         if (aDirectoryCreationCallbackFunc)
 502         {
 503             rtl::OUString url;
 504             osl::FileBase::getFileURLFromSystemPath(directory_path, url);
 505             aDirectoryCreationCallbackFunc(pData, url.pData);
 506         }
 507         return 0;
 508     }
 509     return errno;
 510 }
 511
 512 static oslFileError create_dir_recursively_(
 513     sal_Unicode* dir_path,
 514     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
 515     void* pData)
 516 {
 517     OSL_PRECOND((rtl_ustr_getLength(dir_path) > 0) && ((dir_path + (rtl_ustr_getLength(dir_path) - 1)) != (dir_path + rtl_ustr_lastIndexOfChar(dir_path, '/'))), \
 518     "Path must not end with a slash");
 519
 520     int native_err = create_dir_with_callback(
 521         dir_path, aDirectoryCreationCallbackFunc, pData);
 522
 523     if (native_err == 0)
 524         return osl_File_E_None;
 525
 526     if (native_err != ENOENT)
 527         return oslTranslateFileError(OSL_FET_ERROR, native_err);
 528
 529     // we step back until '/a_dir' at maximum because
 530     // we should get an error unequal ENOENT when
 531     // we try to create 'a_dir' at '/' and would so
 532     // return before
 533     int pos = path_make_parent(dir_path);
 534
 535     oslFileError osl_error = create_dir_recursively_(
 536         dir_path, aDirectoryCreationCallbackFunc, pData);
 537
 538     if (osl_File_E_None != osl_error)
 539         return osl_error;
 540
 541        dir_path[pos] = '/';
 542
 543     return create_dir_recursively_(dir_path, aDirectoryCreationCallbackFunc, pData);
 544 }
 545
 546 oslFileError SAL_CALL osl_createDirectoryPath(
 547     rtl_uString* aDirectoryUrl,
 548     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
 549     void* pData)
 550 {
 551     if (aDirectoryUrl == NULL)
 552         return osl_File_E_INVAL;
 553
 554     rtl::OUString sys_path;
 555     oslFileError osl_error = osl_getSystemPathFromFileURL_Ex(
 556         aDirectoryUrl, &sys_path.pData, sal_False);
 557
 558     if (osl_error != osl_File_E_None)
 559         return osl_error;
 560
 561     osl::systemPathRemoveSeparator(sys_path);
 562
 563     // const_cast because sys_path is a local copy which we want to modify inplace instead of
 564     // coyp it into another buffer on the heap again
 565     return create_dir_recursively_(sys_path.pData->buffer, aDirectoryCreationCallbackFunc, pData);
 566 }
 567
 568 /******************************************************************************
 569  *
 570  *                  C-String Function Declarations
 571  *
 572  *****************************************************************************/
 573
 574 static oslFileError osl_psz_removeFile(const sal_Char* pszPath);
 575 static oslFileError osl_psz_copyFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
 576 static oslFileError osl_psz_moveFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
 577
 578
 579 /******************************************************************************
 580  *
 581  *                  Static Module Utility Function Declarations
 582  *
 583  *****************************************************************************/
 584
 585 static oslFileError  oslDoCopy(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, mode_t nMode, size_t nSourceSize, int DestFileExists);
 586 static oslFileError  oslChangeFileModes(const sal_Char* pszFileName, mode_t nMode, time_t nAcTime, time_t nModTime, uid_t nUID, gid_t nGID);
 587 static int           oslDoCopyLink(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName);
 588 static int           oslDoCopyFile(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, size_t nSourceSize, mode_t mode);
 589 static oslFileError  oslDoMoveFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
 590
 591 /****************************************************************************/
 592 /*      osl_moveFile */
 593 /****************************************************************************/
 594
 595 oslFileError SAL_CALL osl_moveFile( rtl_uString* ustrFileURL, rtl_uString* ustrDestURL )
 596 {
 597     char srcPath[PATH_MAX];
 598     char destPath[PATH_MAX];
 599     oslFileError eRet;
 600
 601     OSL_ASSERT( ustrFileURL );
 602     OSL_ASSERT( ustrDestURL );
 603
 604     /* convert source url to system path */
 605     eRet = FileURLToPath( srcPath, PATH_MAX, ustrFileURL );
 606     if( eRet != osl_File_E_None )
 607         return eRet;
 608
 609     /* convert destination url to system path */
 610     eRet = FileURLToPath( destPath, PATH_MAX, ustrDestURL );
 611     if( eRet != osl_File_E_None )
 612         return eRet;
 613
 614 #ifdef MACOSX
 615     if ( macxp_resolveAlias( srcPath, PATH_MAX ) != 0 || macxp_resolveAlias( destPath, PATH_MAX ) != 0 )
 616       return oslTranslateFileError( OSL_FET_ERROR, errno );
 617 #endif/* MACOSX */
 618
 619     return oslDoMoveFile( srcPath, destPath );
 620 }
 621
 622 /****************************************************************************/
 623 /*      osl_copyFile */
 624 /****************************************************************************/
 625
 626 oslFileError SAL_CALL osl_copyFile( rtl_uString* ustrFileURL, rtl_uString* ustrDestURL )
 627 {
 628     char srcPath[PATH_MAX];
 629     char destPath[PATH_MAX];
 630     oslFileError eRet;
 631
 632     OSL_ASSERT( ustrFileURL );
 633     OSL_ASSERT( ustrDestURL );
 634
 635     /* convert source url to system path */
 636     eRet = FileURLToPath( srcPath, PATH_MAX, ustrFileURL );
 637     if( eRet != osl_File_E_None )
 638         return eRet;
 639
 640     /* convert destination url to system path */
 641     eRet = FileURLToPath( destPath, PATH_MAX, ustrDestURL );
 642     if( eRet != osl_File_E_None )
 643         return eRet;
 644
 645 #ifdef MACOSX
 646     if ( macxp_resolveAlias( srcPath, PATH_MAX ) != 0 || macxp_resolveAlias( destPath, PATH_MAX ) != 0 )
 647       return oslTranslateFileError( OSL_FET_ERROR, errno );
 648 #endif/* MACOSX */
 649
 650     return osl_psz_copyFile( srcPath, destPath );
 651 }
 652
 653 /****************************************************************************/
 654 /*      osl_removeFile */
 655 /****************************************************************************/
 656
 657 oslFileError SAL_CALL osl_removeFile( rtl_uString* ustrFileURL )
 658 {
 659     char path[PATH_MAX];
 660     oslFileError eRet;
 661
 662     OSL_ASSERT( ustrFileURL );
 663
 664     /* convert file url to system path */
 665     eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
 666     if( eRet != osl_File_E_None )
 667         return eRet;
 668
 669 #ifdef MACOSX
 670     if ( macxp_resolveAlias( path, PATH_MAX ) != 0 )
 671       return oslTranslateFileError( OSL_FET_ERROR, errno );
 672 #endif/* MACOSX */
 673
 674     return osl_psz_removeFile( path );
 675 }
 676
 677 /******************************************************************************
 678  *
 679  *                  Utility Functions
 680  *
 681  *****************************************************************************/
 682
 683 /*****************************************
 684  * oslDoMoveFile
 685  ****************************************/
 686
 687 static oslFileError oslDoMoveFile( const sal_Char* pszPath, const sal_Char* pszDestPath)
 688 {
 689     oslFileError tErr=osl_File_E_invalidError;
 690
 691     tErr = osl_psz_moveFile(pszPath,pszDestPath);
 692     if ( tErr == osl_File_E_None )
 693     {
 694         return tErr;
 695     }
 696
 697     if ( tErr != osl_File_E_XDEV )
 698     {
 699         return tErr;
 700     }
 701
 702     tErr=osl_psz_copyFile(pszPath,pszDestPath);
 703
 704     if ( tErr != osl_File_E_None )
 705     {
 706         oslFileError tErrRemove;
 707         tErrRemove=osl_psz_removeFile(pszDestPath);
 708         return tErr;
 709     }
 710
 711     tErr=osl_psz_removeFile(pszPath);
 712
 713     return tErr;
 714 }
 715
 716 /*****************************************
 717  * osl_psz_removeFile
 718  ****************************************/
 719 static oslFileError osl_psz_removeFile( const sal_Char* pszPath )
 720 {
 721     int nRet=0;
 722     struct stat aStat;
 723
 724     nRet = lstat(pszPath,&aStat);
 725     if ( nRet < 0 )
 726     {
 727         nRet=errno;
 728         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 729     }
 730
 731     if ( S_ISDIR(aStat.st_mode) )
 732     {
 733         return osl_File_E_ISDIR;
 734     }
 735
 736     nRet = unlink(pszPath);
 737     if ( nRet < 0 )
 738     {
 739         nRet=errno;
 740         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 741     }
 742
 743     return osl_File_E_None;
 744 }
 745
 746 /*****************************************
 747  * osl_psz_moveFile
 748  ****************************************/
 749
 750 static oslFileError osl_psz_moveFile(const sal_Char* pszPath, const sal_Char* pszDestPath)
 751 {
 752
 753     int nRet = 0;
 754
 755     nRet = rename(pszPath,pszDestPath);
 756
 757     if ( nRet < 0 )
 758     {
 759         nRet=errno;
 760         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 761     }
 762
 763     return osl_File_E_None;
 764 }
 765
 766 /*****************************************
 767  * osl_psz_copyFile
 768  ****************************************/
 769
 770 static oslFileError osl_psz_copyFile( const sal_Char* pszPath, const sal_Char* pszDestPath )
 771 {
 772     time_t nAcTime=0;
 773     time_t nModTime=0;
 774     uid_t nUID=0;
 775     gid_t nGID=0;
 776     int nRet=0;
 777     mode_t nMode=0;
 778     struct stat aFileStat;
 779     oslFileError tErr=osl_File_E_invalidError;
 780     size_t nSourceSize=0;
 781     int DestFileExists=1;
 782
 783     /* mfe: does the source file really exists? */
 784     nRet = lstat(pszPath,&aFileStat);
 785
 786     if ( nRet < 0 )
 787     {
 788         nRet=errno;
 789         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 790     }
 791
 792     /* mfe: we do only copy files here! */
 793     if ( S_ISDIR(aFileStat.st_mode) )
 794     {
 795         return osl_File_E_ISDIR;
 796     }
 797
 798     nSourceSize=(size_t)aFileStat.st_size;
 799     nMode=aFileStat.st_mode;
 800     nAcTime=aFileStat.st_atime;
 801     nModTime=aFileStat.st_mtime;
 802     nUID=aFileStat.st_uid;
 803     nGID=aFileStat.st_gid;
 804
 805     nRet = stat(pszDestPath,&aFileStat);
 806     if ( nRet < 0 )
 807     {
 808         nRet=errno;
 809
 810         if ( nRet == ENOENT )
 811         {
 812             DestFileExists=0;
 813         }
 814 /*        return oslTranslateFileError(nRet);*/
 815     }
 816
 817     /* mfe: the destination file must not be a directory! */
 818     if ( nRet == 0 && S_ISDIR(aFileStat.st_mode) )
 819     {
 820         return osl_File_E_ISDIR;
 821     }
 822     else
 823     {
 824         /* mfe: file does not exists or is no dir */
 825     }
 826
 827     tErr = oslDoCopy(pszPath,pszDestPath,nMode,nSourceSize,DestFileExists);
 828
 829     if ( tErr != osl_File_E_None )
 830     {
 831         return tErr;
 832     }
 833
 834     /*
 835      *   mfe: ignore return code
 836      *        since only  the success of the copy is
 837      *        important
 838      */
 839     oslChangeFileModes(pszDestPath,nMode,nAcTime,nModTime,nUID,nGID);
 840
 841     return tErr;
 842 }
 843
 844
 845 /******************************************************************************
 846  *
 847  *                  Utility Functions
 848  *
 849  *****************************************************************************/
 850
 851 /*****************************************
 852  * oslDoCopy
 853  ****************************************/
 854
 855 #define TMP_DEST_FILE_EXTENSION ".osl-tmp"
 856
 857 static oslFileError oslDoCopy(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, mode_t nMode, size_t nSourceSize, int DestFileExists)
 858 {
 859     int      nRet=0;
 860     sal_Char pszTmpDestFile[PATH_MAX];
 861     size_t   size_tmp_dest_buff = sizeof(pszTmpDestFile);
 862
 863     /* Quick fix for #106048, the whole copy file function seems
 864        to be erroneous anyway and needs to be rewritten.
 865        Besides osl_copyFile     is currently not used from OO/SO code.
 866     */
 867     memset(pszTmpDestFile, 0, size_tmp_dest_buff);
 868
 869     if ( DestFileExists )
 870     {
 871         strncpy(pszTmpDestFile, pszDestFileName, size_tmp_dest_buff - 1);
 872
 873         if ((strlen(pszTmpDestFile) + strlen(TMP_DEST_FILE_EXTENSION)) >= size_tmp_dest_buff)
 874             return osl_File_E_NAMETOOLONG;
 875
 876         strncat(pszTmpDestFile, TMP_DEST_FILE_EXTENSION, strlen(TMP_DEST_FILE_EXTENSION));
 877
 878         /* FIXME: what if pszTmpDestFile already exists? */
 879         /*        with getcanonical??? */
 880         nRet=rename(pszDestFileName,pszTmpDestFile);
 881     }
 882
 883     /* mfe: should be S_ISREG */
 884     if ( !S_ISLNK(nMode) )
 885     {
 886         /* copy SourceFile to DestFile */
 887         nRet = oslDoCopyFile(pszSourceFileName,pszDestFileName,nSourceSize, nMode);
 888     }
 889     /* mfe: OK redundant at the moment */
 890     else if ( S_ISLNK(nMode) )
 891     {
 892         nRet = oslDoCopyLink(pszSourceFileName,pszDestFileName);
 893     }
 894     else
 895     {
 896         /* mfe: what to do here? */
 897         nRet=ENOSYS;
 898     }
 899
 900     if ( nRet > 0 && DestFileExists == 1 )
 901     {
 902         unlink(pszDestFileName);
 903         rename(pszTmpDestFile,pszDestFileName);
 904     }
 905
 906     if ( nRet > 0 )
 907     {
 908         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 909     }
 910
 911     if ( DestFileExists == 1 )
 912     {
 913         unlink(pszTmpDestFile);
 914     }
 915
 916     return osl_File_E_None;
 917 }
 918
 919 /*****************************************
 920  * oslChangeFileModes
 921  ****************************************/
 922
 923 static oslFileError oslChangeFileModes( const sal_Char* pszFileName, mode_t nMode, time_t nAcTime, time_t nModTime, uid_t nUID, gid_t nGID)
 924 {
 925     int nRet=0;
 926     struct utimbuf aTimeBuffer;
 927
 928     nRet = chmod(pszFileName,nMode);
 929     if ( nRet < 0 )
 930     {
 931         nRet=errno;
 932         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 933     }
 934
 935     aTimeBuffer.actime=nAcTime;
 936     aTimeBuffer.modtime=nModTime;
 937     nRet=utime(pszFileName,&aTimeBuffer);
 938     if ( nRet < 0 )
 939     {
 940         nRet=errno;
 941         return oslTranslateFileError(OSL_FET_ERROR, nRet);
 942     }
 943
 944     if ( nUID != getuid() )
 945     {
 946         nUID=getuid();
 947     }
 948
 949     nRet=chown(pszFileName,nUID,nGID);
 950     if ( nRet < 0 )
 951     {
 952         nRet=errno;
 953
 954         /* mfe: do not return an error here! */
 955         /* return oslTranslateFileError(nRet);*/
 956     }
 957
 958     return osl_File_E_None;
 959 }
 960
 961 /*****************************************
 962  * oslDoCopyLink
 963  ****************************************/
 964
 965 static int oslDoCopyLink(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName)
 966 {
 967     int nRet=0;
 968
 969     /* mfe: if dest file is symbolic link remove the link and place the file instead (hro says so) */
 970     /* mfe: if source is a link copy the link and not the file it points to (hro says so) */
 971     sal_Char pszLinkContent[PATH_MAX];
 972
 973     pszLinkContent[0] = '\0';
 974
 975     nRet = readlink(pszSourceFileName,pszLinkContent,PATH_MAX);
 976
 977     if ( nRet < 0 )
 978     {
 979         nRet=errno;
 980         return nRet;
 981     }
 982     else
 983         pszLinkContent[ nRet ] = 0;
 984
 985     nRet = symlink(pszLinkContent,pszDestFileName);
 986
 987     if ( nRet < 0 )
 988     {
 989         nRet=errno;
 990         return nRet;
 991     }
 992
 993     return 0;
 994 }
 995
 996 /*****************************************
 997  * oslDoCopyFile
 998  ****************************************/
 999
1000 static int oslDoCopyFile(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, size_t nSourceSize, mode_t mode)
1001 {
1002     int SourceFileFD=0;
1003     int DestFileFD=0;
1004     int nRet=0;
1005     void* pSourceFile=0;
1006
1007     SourceFileFD=open(pszSourceFileName,O_RDONLY);
1008     if ( SourceFileFD < 0 )
1009     {
1010         nRet=errno;
1011         return nRet;
1012     }
1013
1014     DestFileFD=open(pszDestFileName, O_WRONLY | O_CREAT, mode);
1015
1016     if ( DestFileFD < 0 )
1017     {
1018         nRet=errno;
1019         close(SourceFileFD);
1020         return nRet;
1021     }
1022
1023     /* HACK: because memory mapping fails on various
1024        platforms if the size of the source file is  0 byte */
1025     if (0 == nSourceSize)
1026     {
1027         close(SourceFileFD);
1028         close(DestFileFD);
1029         return 0;
1030     }
1031
1032     /* FIXME doCopy: fall back code for systems not having mmap */
1033     /* mmap file -- open dest file -- write once -- fsync it */
1034     pSourceFile=mmap(0,nSourceSize,PROT_READ,MAP_PRIVATE,SourceFileFD,0);
1035
1036     if ( pSourceFile == MAP_FAILED )
1037     {
1038         /* it's important to set nRet before the hack
1039            otherwise errno may be changed by lstat */
1040         nRet = errno;
1041         close(SourceFileFD);
1042         close(DestFileFD);
1043
1044         return nRet;
1045     }
1046
1047     nRet = write(DestFileFD,pSourceFile,nSourceSize);
1048
1049     /* #112584# if 'write' could not write the requested number of bytes
1050              we have to fail of course; because it's not exactly specified if 'write'
1051             sets errno if less than requested byte could be written we set nRet
1052            explicitly to ENOSPC */
1053     if ((nRet < 0) || (nRet != sal::static_int_cast< int >(nSourceSize)))
1054     {
1055         if (nRet < 0)
1056             nRet = errno;
1057         else
1058             nRet = ENOSPC;
1059
1060         close(SourceFileFD);
1061         close(DestFileFD);
1062         munmap((char*)pSourceFile,nSourceSize);
1063         return nRet;
1064     }
1065
1066     nRet = munmap((char*)pSourceFile,nSourceSize);
1067     if ( nRet < 0 )
1068     {
1069         nRet=errno;
1070         close(SourceFileFD);
1071         close(DestFileFD);
1072         return nRet;
1073     }
1074
1075     close(SourceFileFD);
1076
1077     // Removed call to 'fsync' again (#112584#) and instead
1078     // evaluate the return value of 'close' in order to detect
1079     // and report ENOSPC and other erronous conditions on close
1080     if (close(DestFileFD) == -1)
1081         return errno;
1082     else
1083         return 0;
1084 }