svl/source/misc/sharecontrolfile.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
  21 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  22 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  23 #include <com/sun/star/ucb/XContent.hpp>
  24 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
  25 #include <com/sun/star/ucb/InteractiveIOException.hpp>
  26 #include <com/sun/star/io/NotConnectedException.hpp>
  27
  28 #include <o3tl/enumrange.hxx>
  29
  30 #include <rtl/string.hxx>
  31 #include <rtl/ustring.hxx>
  32 #include <rtl/ustrbuf.hxx>
  33
  34 #include <comphelper/processfactory.hxx>
  35 #include <ucbhelper/content.hxx>
  36
  37 #include <tools/stream.hxx>
  38 #include <unotools/streamwrap.hxx>
  39
  40 #include <svl/sharecontrolfile.hxx>
  41
  42 using namespace ::com::sun::star;
  43
  44 namespace svt {
  45
  46
  47 ShareControlFile::ShareControlFile( std::u16string_view aOrigURL )
  48     : LockFileCommon(GenerateOwnLockFileURL(aOrigURL, u".~sharing."))
  49 {
  50     if ( !m_xStream.is() && !GetURL().isEmpty() )
  51     {
  52         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
  53         ::ucbhelper::Content aContent( GetURL(), xDummyEnv, comphelper::getProcessComponentContext() );
  54
  55         uno::Reference< ucb::XContentIdentifier > xContId( aContent.get().is() ? aContent.get()->getIdentifier() : nullptr );
  56         if ( !xContId.is() || xContId->getContentProviderScheme() != "file" )
  57             throw io::IOException(); // the implementation supports only local files for now
  58
  59         uno::Reference< io::XStream > xStream;
  60
  61         // Currently the locking of the original document is intended to be used.
  62         // That means that the shared file should be accessed only when the original document is locked and only by user who has locked the document.
  63         // TODO/LATER: should the own file locking be used?
  64
  65         try
  66         {
  67             xStream = aContent.openWriteableStreamNoLock();
  68         }
  69         catch ( ucb::InteractiveIOException const & e )
  70         {
  71             if ( e.Code == ucb::IOErrorCode_NOT_EXISTING )
  72             {
  73                 // Create file...
  74                 ucb::InsertCommandArgument aInsertArg;
  75                 SvMemoryStream aStream(0,0);
  76                 aInsertArg.Data.set(new ::utl::OInputStreamWrapper(aStream));
  77                 aInsertArg.ReplaceExisting = false;
  78                 aContent.executeCommand( u"insert"_ustr, uno::Any( aInsertArg ) );
  79
  80                 // try to let the file be hidden if possible
  81                 try {
  82                     aContent.setPropertyValue(u"IsHidden"_ustr, uno::Any( true ) );
  83                 } catch( uno::Exception& ) {}
  84
  85                 // Try to open one more time
  86                 xStream = aContent.openWriteableStreamNoLock();
  87             }
  88             else
  89                 throw;
  90         }
  91
  92         m_xSeekable.set( xStream, uno::UNO_QUERY_THROW );
  93         m_xInputStream.set( xStream->getInputStream(), uno::UNO_SET_THROW );
  94         m_xOutputStream.set( xStream->getOutputStream(), uno::UNO_SET_THROW );
  95         m_xTruncate.set( m_xOutputStream, uno::UNO_QUERY_THROW );
  96         m_xStream = std::move(xStream);
  97     }
  98
  99     if ( !IsValid() )
 100         throw io::NotConnectedException();
 101 }
 102
 103 ShareControlFile::~ShareControlFile()
 104 {
 105     try
 106     {
 107         Close();
 108     }
 109     catch( uno::Exception& )
 110     {}
 111 }
 112
 113 void ShareControlFile::Close()
 114 {
 115     // if it is called outside of destructor the mutex must be locked
 116
 117     if ( !m_xStream.is() )
 118         return;
 119
 120     try
 121     {
 122         if ( m_xInputStream.is() )
 123             m_xInputStream->closeInput();
 124         if ( m_xOutputStream.is() )
 125             m_xOutputStream->closeOutput();
 126     }
 127     catch( uno::Exception& )
 128     {}
 129
 130     m_xStream.clear();
 131     m_xInputStream.clear();
 132     m_xOutputStream.clear();
 133     m_xSeekable.clear();
 134     m_xTruncate.clear();
 135     m_aUsersData.clear();
 136 }
 137
 138
 139 std::vector< o3tl::enumarray< LockFileComponent, OUString > > ShareControlFile::GetUsersData()
 140 {
 141     std::unique_lock aGuard(m_aMutex);
 142     return GetUsersDataImpl(aGuard);
 143 }
 144
 145 const std::vector< o3tl::enumarray< LockFileComponent, OUString > > & ShareControlFile::GetUsersDataImpl(std::unique_lock<std::mutex>& /*rGuard*/)
 146 {
 147     if ( !IsValid() )
 148         throw io::NotConnectedException();
 149
 150     if ( m_aUsersData.empty() )
 151     {
 152         sal_Int64 nLength = m_xSeekable->getLength();
 153         if (nLength > SAL_MAX_INT32 || nLength < 0)
 154             throw uno::RuntimeException();
 155
 156         uno::Sequence< sal_Int8 > aBuffer( static_cast<sal_Int32>(nLength) );
 157         m_xSeekable->seek( 0 );
 158
 159         sal_Int32 nRead = m_xInputStream->readBytes( aBuffer, static_cast<sal_Int32>(nLength) );
 160         auto aBufferRange = asNonConstRange(aBuffer);
 161         nLength -= nRead;
 162         while ( nLength > 0 )
 163         {
 164             uno::Sequence< sal_Int8 > aTmpBuf( static_cast<sal_Int32>(nLength) );
 165             nRead = m_xInputStream->readBytes( aTmpBuf, static_cast<sal_Int32>(nLength) );
 166             if ( nRead > nLength )
 167                 throw uno::RuntimeException();
 168
 169             for ( sal_Int32 nInd = 0; nInd < nRead; nInd++ )
 170                 aBufferRange[aBuffer.getLength() - static_cast<sal_Int32>(nLength) + nInd] = aTmpBuf[nInd];
 171             nLength -= nRead;
 172         }
 173
 174         ParseList( aBuffer, m_aUsersData );
 175     }
 176
 177     return m_aUsersData;
 178 }
 179
 180 void ShareControlFile::SetUsersDataAndStore( std::unique_lock<std::mutex>& /*rGuard*/, std::vector< LockFileEntry >&& aUsersData )
 181 {
 182     if ( !IsValid() )
 183         throw io::NotConnectedException();
 184
 185     if ( !m_xTruncate.is() || !m_xOutputStream.is() || !m_xSeekable.is() )
 186         throw uno::RuntimeException();
 187
 188     m_xTruncate->truncate();
 189     m_xSeekable->seek( 0 );
 190
 191     OUStringBuffer aBuffer;
 192     for (const auto & rData : aUsersData)
 193     {
 194         for ( LockFileComponent nEntryInd : o3tl::enumrange<LockFileComponent>() )
 195         {
 196             aBuffer.append( EscapeCharacters( rData[nEntryInd] ) );
 197             if ( nEntryInd < LockFileComponent::LAST )
 198                 aBuffer.append( ',' );
 199             else
 200                 aBuffer.append( ';' );
 201         }
 202     }
 203
 204     OString aStringData( OUStringToOString( aBuffer, RTL_TEXTENCODING_UTF8 ) );
 205     uno::Sequence< sal_Int8 > aData( reinterpret_cast<sal_Int8 const *>(aStringData.getStr()), aStringData.getLength() );
 206     m_xOutputStream->writeBytes( aData );
 207     m_aUsersData = std::move(aUsersData);
 208 }
 209
 210 LockFileEntry ShareControlFile::InsertOwnEntry()
 211 {
 212     std::unique_lock aGuard( m_aMutex );
 213
 214     if ( !IsValid() )
 215         throw io::NotConnectedException();
 216
 217     GetUsersDataImpl(aGuard);
 218     std::vector< LockFileEntry > aNewData( m_aUsersData );
 219     LockFileEntry aNewEntry = GenerateOwnEntry();
 220
 221     bool bExists = false;
 222     sal_Int32 nNewInd = 0;
 223     for (LockFileEntry & rEntry : m_aUsersData)
 224     {
 225         if ( rEntry[LockFileComponent::LOCALHOST] == aNewEntry[LockFileComponent::LOCALHOST]
 226              && rEntry[LockFileComponent::SYSUSERNAME] == aNewEntry[LockFileComponent::SYSUSERNAME]
 227              && rEntry[LockFileComponent::USERURL] == aNewEntry[LockFileComponent::USERURL] )
 228         {
 229             if ( !bExists )
 230             {
 231                 aNewData[nNewInd] = aNewEntry;
 232                 bExists = true;
 233             }
 234         }
 235         else
 236         {
 237             aNewData[nNewInd] = rEntry;
 238         }
 239
 240         nNewInd++;
 241     }
 242
 243     if ( !bExists )
 244         aNewData.push_back( aNewEntry );
 245
 246     SetUsersDataAndStore( aGuard, std::move(aNewData) );
 247
 248     return aNewEntry;
 249 }
 250
 251
 252 bool ShareControlFile::HasOwnEntry()
 253 {
 254     std::unique_lock aGuard( m_aMutex );
 255
 256     if ( !IsValid() )
 257     {
 258         throw io::NotConnectedException();
 259     }
 260
 261     GetUsersDataImpl(aGuard);
 262     LockFileEntry aEntry = GenerateOwnEntry();
 263
 264     for (LockFileEntry & rEntry : m_aUsersData)
 265     {
 266         if ( rEntry[LockFileComponent::LOCALHOST] == aEntry[LockFileComponent::LOCALHOST] &&
 267              rEntry[LockFileComponent::SYSUSERNAME] == aEntry[LockFileComponent::SYSUSERNAME] &&
 268              rEntry[LockFileComponent::USERURL] == aEntry[LockFileComponent::USERURL] )
 269         {
 270             return true;
 271         }
 272     }
 273
 274     return false;
 275 }
 276
 277
 278 void ShareControlFile::RemoveEntry()
 279 {
 280     RemoveEntry(GenerateOwnEntry());
 281 }
 282
 283 void ShareControlFile::RemoveEntry( const LockFileEntry& aEntry )
 284 {
 285     std::unique_lock aGuard( m_aMutex );
 286
 287     if ( !IsValid() )
 288         throw io::NotConnectedException();
 289
 290     GetUsersDataImpl(aGuard);
 291
 292     std::vector< LockFileEntry > aNewData;
 293
 294     for (LockFileEntry & rEntry : m_aUsersData)
 295     {
 296         if ( rEntry[LockFileComponent::LOCALHOST] != aEntry[LockFileComponent::LOCALHOST]
 297              || rEntry[LockFileComponent::SYSUSERNAME] != aEntry[LockFileComponent::SYSUSERNAME]
 298              || rEntry[LockFileComponent::USERURL] != aEntry[LockFileComponent::USERURL] )
 299         {
 300             aNewData.push_back( rEntry );
 301         }
 302     }
 303
 304     const bool bNewDataEmpty = aNewData.empty();
 305     SetUsersDataAndStore( aGuard, std::move(aNewData) );
 306
 307     if ( bNewDataEmpty )
 308     {
 309         // try to remove the file if it is empty
 310         RemoveFileImpl(aGuard);
 311     }
 312 }
 313
 314
 315 void ShareControlFile::RemoveFile()
 316 {
 317     std::unique_lock aGuard(m_aMutex);
 318     return RemoveFileImpl(aGuard);
 319 }
 320
 321 void ShareControlFile::RemoveFileImpl(std::unique_lock<std::mutex>& /*rGuard*/)
 322 {
 323     if ( !IsValid() )
 324         throw io::NotConnectedException();
 325
 326     Close();
 327
 328     uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(ucb::SimpleFileAccess::create(comphelper::getProcessComponentContext()));
 329     xSimpleFileAccess->kill( GetURL() );
 330 }
 331
 332 } // namespace svt
 333
 334 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */