tools/source/stream/strmunx.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <algorithm>
  21 #include <stdio.h>
  22 #include <fcntl.h>
  23 #include <errno.h>
  24
  25 #include <tools/stream.hxx>
  26 #include <vector>
  27
  28 #include <osl/mutex.hxx>
  29 #include <osl/thread.h>
  30 #include <sal/log.hxx>
  31
  32 // class FileBase
  33 #include <osl/file.hxx>
  34 #include <osl/detail/file.h>
  35 #include <rtl/instance.hxx>
  36
  37 using namespace osl;
  38
  39 // InternalLock ----------------------------------------------------------------
  40
  41 namespace {
  42
  43 struct LockMutex : public rtl::Static< osl::Mutex, LockMutex > {};
  44
  45 struct InternalStreamLock
  46 {
  47     sal_uInt64         m_nStartPos;
  48     sal_uInt64         m_nEndPos;
  49     SvFileStream*      m_pStream;
  50     osl::DirectoryItem m_aItem;
  51
  52     InternalStreamLock( sal_uInt64, sal_uInt64, SvFileStream* );
  53     ~InternalStreamLock();
  54 };
  55
  56 struct LockList : public rtl::Static< std::vector<InternalStreamLock>, LockList > {};
  57
  58 InternalStreamLock::InternalStreamLock(
  59     sal_uInt64 const nStart,
  60     sal_uInt64 const nEnd,
  61     SvFileStream* pStream ) :
  62         m_nStartPos( nStart ),
  63         m_nEndPos( nEnd ),
  64         m_pStream( pStream )
  65 {
  66     (void)osl::DirectoryItem::get( m_pStream->GetFileName(), m_aItem );
  67 #if OSL_DEBUG_LEVEL > 1
  68     OString aFileName(OUStringToOString(m_pStream->GetFileName(),
  69                                                   osl_getThreadTextEncoding()));
  70     fprintf( stderr, "locked %s", aFileName.getStr() );
  71     if( m_nStartPos || m_nEndPos )
  72         fprintf(stderr, " [ %ld ... %ld ]", m_nStartPos, m_nEndPos );
  73     fprintf( stderr, "\n" );
  74 #endif
  75 }
  76
  77 InternalStreamLock::~InternalStreamLock()
  78 {
  79 #if OSL_DEBUG_LEVEL > 1
  80     OString aFileName(OUStringToOString(m_pStream->GetFileName(),
  81                                                   osl_getThreadTextEncoding()));
  82     fprintf( stderr, "unlocked %s", aFileName.getStr() );
  83     if( m_nStartPos || m_nEndPos )
  84         fprintf(stderr, " [ %ld ... %ld ]", m_nStartPos, m_nEndPos );
  85     fprintf( stderr, "\n" );
  86 #endif
  87 }
  88
  89 bool lockFile( sal_uInt64 const nStart, sal_uInt64 const nEnd, SvFileStream* pStream )
  90 {
  91     osl::DirectoryItem aItem;
  92     if (osl::DirectoryItem::get( pStream->GetFileName(), aItem) != osl::FileBase::E_None )
  93     {
  94         SAL_INFO("tools.stream", "Failed to lookup stream for locking");
  95         return true;
  96     }
  97
  98     osl::FileStatus aStatus( osl_FileStatus_Mask_Type );
  99     if ( aItem.getFileStatus( aStatus ) != osl::FileBase::E_None )
 100     {
 101         SAL_INFO("tools.stream", "Failed to stat stream for locking");
 102         return true;
 103     }
 104     if( aStatus.getFileType() == osl::FileStatus::Directory )
 105         return true;
 106
 107     osl::MutexGuard aGuard( LockMutex::get() );
 108     std::vector<InternalStreamLock> &rLockList = LockList::get();
 109     for( const auto& rLock : rLockList )
 110     {
 111         if( aItem.isIdenticalTo( rLock.m_aItem ) )
 112         {
 113             StreamMode nLockMode = rLock.m_pStream->GetStreamMode();
 114             StreamMode nNewMode = pStream->GetStreamMode();
 115             bool bDenyByOptions = (nLockMode & StreamMode::SHARE_DENYALL) ||
 116                 ( (nLockMode & StreamMode::SHARE_DENYWRITE) && (nNewMode & StreamMode::WRITE) ) ||
 117                 ( (nLockMode & StreamMode::SHARE_DENYREAD) && (nNewMode & StreamMode::READ) );
 118
 119             if( bDenyByOptions )
 120             {
 121                 if( rLock.m_nStartPos == 0 && rLock.m_nEndPos == 0 ) // whole file is already locked
 122                     return false;
 123                 if( nStart == 0 && nEnd == 0) // cannot lock whole file
 124                     return false;
 125
 126                 if( ( nStart < rLock.m_nStartPos && nEnd > rLock.m_nStartPos ) ||
 127                     ( nStart < rLock.m_nEndPos && nEnd > rLock.m_nEndPos ) )
 128                     return false;
 129             }
 130         }
 131     }
 132     rLockList.push_back( InternalStreamLock( nStart, nEnd, pStream ) );
 133     return true;
 134 }
 135
 136 void unlockFile( sal_uInt64 const nStart, sal_uInt64 const nEnd, SvFileStream const * pStream )
 137 {
 138     osl::MutexGuard aGuard( LockMutex::get() );
 139     std::vector<InternalStreamLock> &rLockList = LockList::get();
 140     rLockList.erase(std::remove_if(rLockList.begin(), rLockList.end(),
 141         [&pStream, &nStart, &nEnd](const InternalStreamLock& rLock) {
 142             return rLock.m_pStream == pStream
 143                 && ((nStart == 0 && nEnd == 0)
 144                     || (rLock.m_nStartPos == nStart && rLock.m_nEndPos == nEnd));
 145         }), rLockList.end());
 146 }
 147
 148 }
 149
 150 // StreamData ------------------------------------------------------------------
 151
 152 class StreamData
 153 {
 154 public:
 155     oslFileHandle rHandle;
 156
 157     StreamData() : rHandle( nullptr ) { }
 158 };
 159
 160 static ErrCode GetSvError( int nErrno )
 161 {
 162     static struct { int nErr; ErrCode sv; } const errArr[] =
 163     {
 164         { 0,            ERRCODE_NONE },
 165         { EACCES,       SVSTREAM_ACCESS_DENIED },
 166         { EBADF,        SVSTREAM_INVALID_HANDLE },
 167 #if defined(NETBSD) || \
 168     defined(FREEBSD) || defined(MACOSX) || defined(OPENBSD) || \
 169     defined(__FreeBSD_kernel__) || defined (AIX) || defined(DRAGONFLY) || \
 170     defined(IOS) || defined(HAIKU)
 171         { EDEADLK,      SVSTREAM_LOCKING_VIOLATION },
 172 #else
 173         { EDEADLOCK,    SVSTREAM_LOCKING_VIOLATION },
 174 #endif
 175         { EINVAL,       SVSTREAM_INVALID_PARAMETER },
 176         { EMFILE,       SVSTREAM_TOO_MANY_OPEN_FILES },
 177         { ENFILE,       SVSTREAM_TOO_MANY_OPEN_FILES },
 178         { ENOENT,       SVSTREAM_FILE_NOT_FOUND },
 179         { EPERM,        SVSTREAM_ACCESS_DENIED },
 180         { EROFS,        SVSTREAM_ACCESS_DENIED },
 181         { EAGAIN,       SVSTREAM_LOCKING_VIOLATION },
 182         { EISDIR,       SVSTREAM_PATH_NOT_FOUND },
 183         { ELOOP,        SVSTREAM_PATH_NOT_FOUND },
 184 #if !defined(NETBSD) && !defined (FREEBSD) && \
 185     !defined(MACOSX) && !defined(OPENBSD) && !defined(__FreeBSD_kernel__) && \
 186     !defined(DRAGONFLY)
 187         { EMULTIHOP,    SVSTREAM_PATH_NOT_FOUND },
 188         { ENOLINK,      SVSTREAM_PATH_NOT_FOUND },
 189 #endif
 190         { ENOTDIR,      SVSTREAM_PATH_NOT_FOUND },
 191         { ETXTBSY,      SVSTREAM_ACCESS_DENIED  },
 192         { EEXIST,       SVSTREAM_CANNOT_MAKE    },
 193         { ENOSPC,       SVSTREAM_DISK_FULL      },
 194         { int(0xFFFF),  SVSTREAM_GENERALERROR }
 195     };
 196
 197     ErrCode nRetVal = SVSTREAM_GENERALERROR; // default error
 198     int i=0;
 199     do
 200     {
 201         if ( errArr[i].nErr == nErrno )
 202         {
 203             nRetVal = errArr[i].sv;
 204             break;
 205         }
 206         ++i;
 207     }
 208     while( errArr[i].nErr != 0xFFFF );
 209     return nRetVal;
 210 }
 211
 212 static ErrCode GetSvError( oslFileError nErrno )
 213 {
 214     static struct { oslFileError nErr; ErrCode sv; } const errArr[] =
 215     {
 216         { osl_File_E_None,        ERRCODE_NONE },
 217         { osl_File_E_ACCES,       SVSTREAM_ACCESS_DENIED },
 218         { osl_File_E_BADF,        SVSTREAM_INVALID_HANDLE },
 219         { osl_File_E_DEADLK,      SVSTREAM_LOCKING_VIOLATION },
 220         { osl_File_E_INVAL,       SVSTREAM_INVALID_PARAMETER },
 221         { osl_File_E_MFILE,       SVSTREAM_TOO_MANY_OPEN_FILES },
 222         { osl_File_E_NFILE,       SVSTREAM_TOO_MANY_OPEN_FILES },
 223         { osl_File_E_NOENT,       SVSTREAM_FILE_NOT_FOUND },
 224         { osl_File_E_PERM,        SVSTREAM_ACCESS_DENIED },
 225         { osl_File_E_ROFS,        SVSTREAM_ACCESS_DENIED },
 226         { osl_File_E_AGAIN,       SVSTREAM_LOCKING_VIOLATION },
 227         { osl_File_E_ISDIR,       SVSTREAM_PATH_NOT_FOUND },
 228         { osl_File_E_LOOP,        SVSTREAM_PATH_NOT_FOUND },
 229         { osl_File_E_MULTIHOP,    SVSTREAM_PATH_NOT_FOUND },
 230         { osl_File_E_NOLINK,      SVSTREAM_PATH_NOT_FOUND },
 231         { osl_File_E_NOTDIR,      SVSTREAM_PATH_NOT_FOUND },
 232         { osl_File_E_EXIST,       SVSTREAM_CANNOT_MAKE    },
 233         { osl_File_E_NOSPC,       SVSTREAM_DISK_FULL      },
 234         { oslFileError(0xFFFF),   SVSTREAM_GENERALERROR }
 235     };
 236
 237     ErrCode nRetVal = SVSTREAM_GENERALERROR; // default error
 238     int i=0;
 239     do
 240     {
 241         if ( errArr[i].nErr == nErrno )
 242         {
 243             nRetVal = errArr[i].sv;
 244             break;
 245         }
 246         ++i;
 247     }
 248     while( errArr[i].nErr != oslFileError(0xFFFF) );
 249     return nRetVal;
 250 }
 251
 252 SvFileStream::SvFileStream( const OUString& rFileName, StreamMode nOpenMode )
 253 {
 254     bIsOpen             = false;
 255     m_isWritable        = false;
 256     pInstanceData.reset(new StreamData);
 257
 258     SetBufferSize( 1024 );
 259     // convert URL to SystemPath, if necessary
 260     OUString aSystemFileName;
 261     if( FileBase::getSystemPathFromFileURL( rFileName , aSystemFileName )
 262         != FileBase::E_None )
 263     {
 264         aSystemFileName = rFileName;
 265     }
 266     Open( aSystemFileName, nOpenMode );
 267 }
 268
 269 SvFileStream::SvFileStream()
 270 {
 271     bIsOpen             = false;
 272     m_isWritable        = false;
 273     pInstanceData.reset(new StreamData);
 274     SetBufferSize( 1024 );
 275 }
 276
 277 SvFileStream::~SvFileStream()
 278 {
 279     Close();
 280 }
 281
 282 std::size_t SvFileStream::GetData( void* pData, std::size_t nSize )
 283 {
 284     SAL_INFO("tools", OString::number(static_cast<sal_Int64>(nSize)) << " Bytes from " << aFilename);
 285
 286     sal_uInt64 nRead = 0;
 287     if ( IsOpen() )
 288     {
 289         oslFileError rc = osl_readFile(pInstanceData->rHandle,pData,static_cast<sal_uInt64>(nSize),&nRead);
 290         if ( rc != osl_File_E_None )
 291         {
 292             SetError( ::GetSvError( rc ));
 293             return -1;
 294         }
 295     }
 296     return static_cast<std::size_t>(nRead);
 297 }
 298
 299 std::size_t SvFileStream::PutData( const void* pData, std::size_t nSize )
 300 {
 301     SAL_INFO("tools", OString::number(static_cast<sal_Int64>(nSize)) << " Bytes to " << aFilename);
 302
 303     sal_uInt64 nWrite = 0;
 304     if ( IsOpen() )
 305     {
 306         oslFileError rc = osl_writeFile(pInstanceData->rHandle,pData,static_cast<sal_uInt64>(nSize),&nWrite);
 307         if ( rc != osl_File_E_None )
 308         {
 309             SetError( ::GetSvError( rc ) );
 310             return -1;
 311         }
 312         else if( !nWrite )
 313             SetError( SVSTREAM_DISK_FULL );
 314     }
 315     return static_cast<std::size_t>(nWrite);
 316 }
 317
 318 sal_uInt64 SvFileStream::SeekPos(sal_uInt64 const nPos)
 319 {
 320     // check if a truncated STREAM_SEEK_TO_END was passed
 321     assert(nPos != sal_uInt64(sal_uInt32(STREAM_SEEK_TO_END)));
 322     if ( IsOpen() )
 323     {
 324         oslFileError rc;
 325         sal_uInt64 nNewPos;
 326         if ( nPos != STREAM_SEEK_TO_END )
 327             rc = osl_setFilePos( pInstanceData->rHandle, osl_Pos_Absolut, nPos );
 328         else
 329             rc = osl_setFilePos( pInstanceData->rHandle, osl_Pos_End, 0 );
 330
 331         if ( rc != osl_File_E_None )
 332         {
 333             SetError( SVSTREAM_SEEK_ERROR );
 334             return 0L;
 335         }
 336         if ( nPos != STREAM_SEEK_TO_END )
 337             return nPos;
 338         rc = osl_getFilePos( pInstanceData->rHandle, &nNewPos );
 339         return nNewPos;
 340     }
 341     SetError( SVSTREAM_GENERALERROR );
 342     return 0L;
 343 }
 344
 345 void SvFileStream::FlushData()
 346 {
 347     // does not exist locally
 348 }
 349
 350 bool SvFileStream::LockRange(sal_uInt64 const nByteOffset, std::size_t nBytes)
 351 {
 352     int nLockMode = 0;
 353
 354     if ( ! IsOpen() )
 355         return false;
 356
 357     if (m_eStreamMode & StreamMode::SHARE_DENYALL)
 358     {
 359         if (m_isWritable)
 360             nLockMode = F_WRLCK;
 361         else
 362             nLockMode = F_RDLCK;
 363     }
 364
 365     if (m_eStreamMode & StreamMode::SHARE_DENYREAD)
 366     {
 367         if (m_isWritable)
 368             nLockMode = F_WRLCK;
 369         else
 370         {
 371             SetError(SVSTREAM_LOCKING_VIOLATION);
 372             return false;
 373         }
 374     }
 375
 376     if (m_eStreamMode & StreamMode::SHARE_DENYWRITE)
 377     {
 378         if (m_isWritable)
 379             nLockMode = F_WRLCK;
 380         else
 381             nLockMode = F_RDLCK;
 382     }
 383
 384     if (!nLockMode)
 385         return true;
 386
 387     if( !lockFile( nByteOffset, nByteOffset+nBytes, this ) )
 388     {
 389 #if OSL_DEBUG_LEVEL > 1
 390         fprintf( stderr, "InternalLock on %s [ %ld ... %ld ] failed\n",
 391                  OUStringToOString(aFilename, osl_getThreadTextEncoding()).getStr(), nByteOffset, nByteOffset+nBytes );
 392 #endif
 393         return false;
 394     }
 395
 396     return true;
 397 }
 398
 399 bool SvFileStream::UnlockRange(sal_uInt64 const nByteOffset, std::size_t nBytes)
 400 {
 401     if ( ! IsOpen() )
 402         return false;
 403
 404     unlockFile( nByteOffset, nByteOffset+nBytes, this );
 405
 406     return true;
 407 }
 408
 409 bool SvFileStream::LockFile()
 410 {
 411   return LockRange( 0UL, 0UL );
 412 }
 413
 414 void SvFileStream::UnlockFile()
 415 {
 416     UnlockRange( 0UL, 0UL );
 417 }
 418
 419 void SvFileStream::Open( const OUString& rFilename, StreamMode nOpenMode )
 420 {
 421     sal_uInt32 uFlags;
 422     oslFileHandle nHandleTmp;
 423
 424     Close();
 425     errno = 0;
 426     m_eStreamMode = nOpenMode;
 427     m_eStreamMode &= ~StreamMode::TRUNC; // don't truncate on reopen
 428
 429     aFilename = rFilename;
 430
 431     SAL_INFO("tools", aFilename);
 432
 433     OUString aFileURL;
 434     osl::DirectoryItem aItem;
 435     osl::FileStatus aStatus( osl_FileStatus_Mask_Type | osl_FileStatus_Mask_LinkTargetURL );
 436
 437     // FIXME: we really need to switch to a pure URL model ...
 438     if ( osl::File::getFileURLFromSystemPath( aFilename, aFileURL ) != osl::FileBase::E_None )
 439         aFileURL = aFilename;
 440     bool bStatValid = ( osl::DirectoryItem::get( aFileURL, aItem) == osl::FileBase::E_None &&
 441                         aItem.getFileStatus( aStatus ) == osl::FileBase::E_None );
 442
 443     // SvFileStream can't open a directory
 444     if( bStatValid && aStatus.getFileType() == osl::FileStatus::Directory )
 445     {
 446         SetError( ::GetSvError( EISDIR ) );
 447         return;
 448     }
 449
 450     if ( !( nOpenMode & StreamMode::WRITE ) )
 451         uFlags = osl_File_OpenFlag_Read;
 452     else if ( !( nOpenMode & StreamMode::READ ) )
 453         uFlags = osl_File_OpenFlag_Write;
 454     else
 455         uFlags = osl_File_OpenFlag_Read | osl_File_OpenFlag_Write;
 456
 457     // Fix (MDA, 18.01.95): Don't open with O_CREAT upon RD_ONLY
 458     // Important for Read-Only-Filesystems (e.g,  CDROM)
 459     if ( (!( nOpenMode & StreamMode::NOCREATE )) && ( uFlags != osl_File_OpenFlag_Read ) )
 460         uFlags |= osl_File_OpenFlag_Create;
 461     if ( nOpenMode & StreamMode::TRUNC )
 462         uFlags |= osl_File_OpenFlag_Trunc;
 463
 464     uFlags |= osl_File_OpenFlag_NoExcl | osl_File_OpenFlag_NoLock;
 465
 466     if ( nOpenMode & StreamMode::WRITE)
 467     {
 468         if ( nOpenMode & StreamMode::COPY_ON_SYMLINK )
 469         {
 470             if ( bStatValid && aStatus.getFileType() == osl::FileStatus::Link &&
 471                  aStatus.getLinkTargetURL().getLength() > 0 )
 472             {
 473                 // delete the symbolic link, and replace it with the contents of the link
 474                 if (osl::File::remove( aFileURL ) == osl::FileBase::E_None )
 475                 {
 476                     File::copy( aStatus.getLinkTargetURL(), aFileURL );
 477 #if OSL_DEBUG_LEVEL > 0
 478                     fprintf( stderr,
 479                              "Removing link and replacing with file contents (%s) -> (%s).\n",
 480                              OUStringToOString( aStatus.getLinkTargetURL(),
 481                                                      RTL_TEXTENCODING_UTF8).getStr(),
 482                              OUStringToOString( aFileURL,
 483                                                      RTL_TEXTENCODING_UTF8).getStr() );
 484 #endif
 485                 }
 486             }
 487         }
 488     }
 489
 490     oslFileError rc = osl_openFile( aFileURL.pData, &nHandleTmp, uFlags );
 491     if ( rc != osl_File_E_None )
 492     {
 493         if ( uFlags & osl_File_OpenFlag_Write )
 494         {
 495             // Change to read-only
 496             uFlags &= ~osl_File_OpenFlag_Write;
 497             rc = osl_openFile( aFileURL.pData, &nHandleTmp, uFlags );
 498         }
 499     }
 500     if ( rc == osl_File_E_None )
 501     {
 502         pInstanceData->rHandle = nHandleTmp;
 503         bIsOpen = true;
 504         if ( uFlags & osl_File_OpenFlag_Write )
 505             m_isWritable = true;
 506
 507         if ( !LockFile() ) // whole file
 508         {
 509             rc = osl_closeFile( nHandleTmp );
 510             bIsOpen = false;
 511             m_isWritable = false;
 512             pInstanceData->rHandle = nullptr;
 513         }
 514     }
 515     else
 516         SetError( ::GetSvError( rc ) );
 517 }
 518
 519 void SvFileStream::Close()
 520 {
 521     UnlockFile();
 522
 523     if ( IsOpen() )
 524     {
 525         SAL_INFO("tools", "Closing " << aFilename);
 526         Flush();
 527         osl_closeFile( pInstanceData->rHandle );
 528         pInstanceData->rHandle = nullptr;
 529     }
 530
 531     bIsOpen     = false;
 532     m_isWritable = false;
 533     SvStream::ClearBuffer();
 534     SvStream::ClearError();
 535 }
 536
 537 /// set filepointer to beginning of file
 538 void SvFileStream::ResetError()
 539 {
 540     SvStream::ClearError();
 541 }
 542
 543 void SvFileStream::SetSize (sal_uInt64 const nSize)
 544 {
 545     if (IsOpen())
 546     {
 547         oslFileError rc = osl_setFileSize( pInstanceData->rHandle, nSize );
 548         if (rc != osl_File_E_None )
 549         {
 550             SetError ( ::GetSvError( rc ));
 551         }
 552     }
 553 }
 554
 555 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */