Introduce new lockfile handler for MSO like lockfiles

* Implement writing of MSO lockfiles
* Grab the already implemented parsing code (tryMSOwnerFile method)
and put it together into one class
* Add tests about the generated URL for lockfiles and the lockfile content
* MSO lockfiles are not written yet by LO, next step is to integrate
this code into the locking mechanism.

Change-Id: I3b0ed1975cd57dfd006d4e1890b23c307890de5c
Reviewed-on: https://gerrit.libreoffice.org/69582
Tested-by: Jenkins
Reviewed-by: Tamás Zolnai <tamas.zolnai@collabora.com>

include/svl/documentlockfile.hxx

@@ -29,23 +29,41 @@ namespace com { namespace sun { namespace star { namespace io { class XOutputStr
 
 namespace svt {
 
-class SVL_DLLPUBLIC DocumentLockFile : public LockFileCommon
+/// Generalized class for LO and MSO lockfile handling.
+class SVL_DLLPUBLIC GenDocumentLockFile : public LockFileCommon
 {
-    css::uno::Reference< css::io::XInputStream > OpenStream();
-
-    void WriteEntryToStream( const LockFileEntry& aEntry, const css::uno::Reference< css::io::XOutputStream >& xStream );
-
 public:
-    DocumentLockFile( const OUString& aOrigURL );
-    ~DocumentLockFile();
+    /// Specify the lockfile URL directly
+    GenDocumentLockFile( const OUString& aURL );
+    /// Let the object generate and own URL based on the original file's URL and a prefix
+    GenDocumentLockFile( const OUString& aOrigURL, const OUString& aPrefix );
+    virtual ~GenDocumentLockFile() override;
 
     bool CreateOwnLockFile();
-    LockFileEntry GetLockData();
     bool OverwriteOwnLockFile();
     /// Delete the Lockfile, if current user is the owner
-    void RemoveFile();
+    virtual void RemoveFile();
     /// Only delete lockfile, disregarding ownership
     void RemoveFileDirectly();
+
+    virtual LockFileEntry GetLockData() = 0;
+
+protected:
+    virtual void WriteEntryToStream( const LockFileEntry& aEntry, const css::uno::Reference< css::io::XOutputStream >& xStream ) = 0;
+    css::uno::Reference< css::io::XInputStream > OpenStream();
+};
+
+/// Class implementing reading and writing LO lockfiles.
+class SVL_DLLPUBLIC DocumentLockFile : public GenDocumentLockFile
+{
+protected:
+    virtual void WriteEntryToStream( const LockFileEntry& aEntry, const css::uno::Reference< css::io::XOutputStream >& xStream ) override;
+
+public:
+    DocumentLockFile( const OUString& aOrigURL );
+    virtual ~DocumentLockFile() override;
+
+    virtual LockFileEntry GetLockData() override;
 };
 
 }

include/svl/lockfilecommon.hxx

@@ -38,18 +38,27 @@ typedef o3tl::enumarray<LockFileComponent,OUString> LockFileEntry;
 
 namespace svt {
 
-// This is a general implementation that is used in document lock file implementation and in sharing control file implementation
+/// This is a general implementation that is used in document lock file implementation and in sharing control file implementation
 class SVL_DLLPUBLIC LockFileCommon
 {
-protected:
-    ::osl::Mutex m_aMutex;
+private:
     OUString m_aURL;
 
-    INetURLObject ResolveLinks( const INetURLObject& aDocURL ) const;
+protected:
+    ::osl::Mutex m_aMutex;
 
 public:
+    /// Specify the lockfile URL directly
+    LockFileCommon( const OUString& aURL );
+    /// Let the object generate and own URL based on the original file's URL and a prefix
     LockFileCommon( const OUString& aOrigURL, const OUString& aPrefix );
-    ~LockFileCommon();
+    virtual ~LockFileCommon();
+
+    const OUString& GetURL() const;
+    void SetURL(const OUString& aURL);
+
+    /// This method generates the URL of the lock file based on the document URL and the specified prefix.
+    virtual OUString GenerateURL( const OUString& aOrigURL, const OUString& aPrefix );
 
     static void ParseList( const css::uno::Sequence< sal_Int8 >& aBuffer, std::vector< LockFileEntry > &rOutput );
     static LockFileEntry ParseEntry( const css::uno::Sequence< sal_Int8 >& aBuffer, sal_Int32& o_nCurPos );
@@ -58,6 +67,8 @@ public:
     static OUString GetOOOUserName();
     static OUString GetCurrentLocalTime();
     static LockFileEntry GenerateOwnEntry();
+
+    INetURLObject ResolveLinks( const INetURLObject& aDocURL ) const;
 };
 
 }

include/svl/msodocumentlockfile.hxx

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDED_SVL_MSODOCUMENTLOCKFILE_HXX
+#define INCLUDED_SVL_MSODOCUMENTLOCKFILE_HXX
+
+#include <svl/svldllapi.h>
+#include <svl/lockfilecommon.hxx>
+#include <svl/documentlockfile.hxx>
+
+#include <com/sun/star/lang/XComponent.hpp>
+
+namespace com
+{
+namespace sun
+{
+namespace star
+{
+namespace io
+{
+class XInputStream;
+}
+}
+}
+}
+namespace com
+{
+namespace sun
+{
+namespace star
+{
+namespace io
+{
+class XOutputStream;
+}
+}
+}
+}
+
+#define MSO_WORD_LOCKFILE_SIZE 162
+#define MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE 165
+#define MSO_USERNAME_MAX_LENGTH 52
+
+namespace svt
+{
+/// Class implementing reading and writing MSO lockfiles.
+class SVL_DLLPUBLIC MSODocumentLockFile : public GenDocumentLockFile
+{
+private:
+    OUString m_sOrigURL;
+
+    bool isWordFormat(const OUString& aOrigURL) const;
+    bool isExcelFormat(const OUString& aOrigURL) const;
+    bool isPowerPointFormat(const OUString& aOrigURL) const;
+
+protected:
+    virtual void
+    WriteEntryToStream(const LockFileEntry& aEntry,
+                       const css::uno::Reference<css::io::XOutputStream>& xStream) override;
+
+public:
+    MSODocumentLockFile(const OUString& aOrigURL);
+    virtual ~MSODocumentLockFile() override;
+
+    /// Need to generate different lock file name for MSO.
+    virtual OUString GenerateURL(const OUString& aOrigURL, const OUString& aPrefix) override;
+
+    virtual LockFileEntry GetLockData() override;
+
+    virtual void RemoveFile() override;
+};
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */

include/svl/sharecontrolfile.hxx

@@ -53,7 +53,7 @@ public:
 
     // The constructor will throw exception in case the stream can not be opened
     ShareControlFile( const OUString& aOrigURL );
-    ~ShareControlFile();
+    virtual ~ShareControlFile() override;
 
     std::vector< LockFileEntry > GetUsersData();
     void SetUsersDataAndStore( const std::vector< LockFileEntry >& aUserNames );

svl/CppunitTest_svl_lockfiles.mk

+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t; fill-column: 100 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_CppunitTest_CppunitTest,svl_lockfiles))
+
+$(eval $(call gb_CppunitTest_use_sdk_api,svl_lockfiles))
+
+$(eval $(call gb_CppunitTest_use_api,svl_lockfiles,\
+    udkapi \
+    offapi \
+    oovbaapi \
+))
+
+$(eval $(call gb_CppunitTest_use_ure,svl_lockfiles))
+
+$(eval $(call gb_CppunitTest_use_vcl,svl_lockfiles))
+
+
+$(eval $(call gb_CppunitTest_add_exception_objects,svl_lockfiles, \
+        svl/qa/unit/lockfiles/test_lockfiles \
+))
+
+$(eval $(call gb_CppunitTest_use_libraries,svl_lockfiles, \
+    comphelper \
+    cppu \
+    cppuhelper \
+    tl \
+    sal \
+    svl \
+    svt \
+    sw \
+    test \
+    unotest \
+    utl \
+    vcl \
+))
+
+$(eval $(call gb_CppunitTest_use_rdb,svl_lockfiles,services))
+
+$(eval $(call gb_CppunitTest_use_custom_headers,svl_lockfiles,\
+        officecfg/registry \
+))
+
+$(eval $(call gb_CppunitTest_use_configuration,svl_lockfiles))
+
+# vim: set noet sw=4 ts=4:

svl/Library_svl.mk

@@ -158,7 +158,8 @@ $(eval $(call gb_Library_add_exception_objects,svl,\
     svl/source/misc/PasswordHelper \
     svl/source/misc/adrparse \
     $(if $(filter DESKTOP,$(BUILD_TYPE)),\
-        svl/source/misc/documentlockfile) \
+        svl/source/misc/documentlockfile \
+        svl/source/misc/msodocumentlockfile) \
     svl/source/misc/filenotation \
     svl/source/misc/fstathelper \
     svl/source/misc/getstringresource \

svl/Module_svl.mk

@@ -34,6 +34,7 @@ $(eval $(call gb_Module_add_check_targets,svl,\
 	CppunitTest_svl_itempool \
 	CppunitTest_svl_items \
 	CppunitTest_svl_lngmisc \
+	CppunitTest_svl_lockfiles \
 	CppunitTest_svl_notify \
 	CppunitTest_svl_qa_cppunit \
 	CppunitTest_svl_urihelper \

svl/source/misc/documentlockfile.cxx

@@ -54,39 +54,34 @@ using namespace ::com::sun::star;
 
 namespace svt {
 
-DocumentLockFile::DocumentLockFile( const OUString& aOrigURL )
-: LockFileCommon( aOrigURL, ".~lock." )
+GenDocumentLockFile::GenDocumentLockFile( const OUString& aURL )
+: LockFileCommon( aURL )
 {
 }
 
 
-DocumentLockFile::~DocumentLockFile()
+GenDocumentLockFile::GenDocumentLockFile( const OUString& aOrigURL, const OUString& aPrefix )
+: LockFileCommon( aOrigURL, aPrefix )
 {
 }
 
 
-void DocumentLockFile::WriteEntryToStream( const LockFileEntry& aEntry, const uno::Reference< io::XOutputStream >& xOutput )
+GenDocumentLockFile::~GenDocumentLockFile()
 {
-    ::osl::MutexGuard aGuard( m_aMutex );
+}
 
-    OUStringBuffer aBuffer;
+uno::Reference< io::XInputStream > GenDocumentLockFile::OpenStream()
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
 
-    for ( LockFileComponent lft : o3tl::enumrange<LockFileComponent>() )
-    {
-        aBuffer.append( EscapeCharacters( aEntry[lft] ) );
-        if ( lft < LockFileComponent::LAST )
-            aBuffer.append( ',' );
-        else
-            aBuffer.append( ';' );
-    }
+    uno::Reference < css::ucb::XCommandEnvironment > xEnv;
+    ::ucbhelper::Content aSourceContent( GetURL(), xEnv, comphelper::getProcessComponentContext() );
 
-    OString aStringData( OUStringToOString( aBuffer.makeStringAndClear(), RTL_TEXTENCODING_UTF8 ) );
-    uno::Sequence< sal_Int8 > aData( reinterpret_cast<sal_Int8 const *>(aStringData.getStr()), aStringData.getLength() );
-    xOutput->writeBytes( aData );
+    // the file can be opened readonly, no locking will be done
+    return aSourceContent.openStream();
 }
 
-
-bool DocumentLockFile::CreateOwnLockFile()
+bool GenDocumentLockFile::CreateOwnLockFile()
 {
     ::osl::MutexGuard aGuard( m_aMutex );
 
@@ -110,7 +105,7 @@ bool DocumentLockFile::CreateOwnLockFile()
         xSeekable->seek( 0 );
 
         uno::Reference < css::ucb::XCommandEnvironment > xEnv;
-        ::ucbhelper::Content aTargetContent( m_aURL, xEnv, comphelper::getProcessComponentContext() );
+        ::ucbhelper::Content aTargetContent( GetURL(), xEnv, comphelper::getProcessComponentContext() );
 
         ucb::InsertCommandArgument aInsertArg;
         aInsertArg.Data = xInput;
@@ -132,50 +127,13 @@ bool DocumentLockFile::CreateOwnLockFile()
     return true;
 }
 
-
-LockFileEntry DocumentLockFile::GetLockData()
-{
-    ::osl::MutexGuard aGuard( m_aMutex );
-
-    uno::Reference< io::XInputStream > xInput = OpenStream();
-    if ( !xInput.is() )
-        throw uno::RuntimeException();
-
-    const sal_Int32 nBufLen = 32000;
-    uno::Sequence< sal_Int8 > aBuffer( nBufLen );
-
-    sal_Int32 nRead = 0;
-
-    nRead = xInput->readBytes( aBuffer, nBufLen );
-    xInput->closeInput();
-
-    if ( nRead == nBufLen )
-        throw io::WrongFormatException();
-
-    sal_Int32 nCurPos = 0;
-    return ParseEntry( aBuffer, nCurPos );
-}
-
-
-uno::Reference< io::XInputStream > DocumentLockFile::OpenStream()
-{
-    ::osl::MutexGuard aGuard( m_aMutex );
-
-    uno::Reference < css::ucb::XCommandEnvironment > xEnv;
-    ::ucbhelper::Content aSourceContent( m_aURL, xEnv, comphelper::getProcessComponentContext() );
-
-    // the file can be opened readonly, no locking will be done
-    return aSourceContent.openStream();
-}
-
-
-bool DocumentLockFile::OverwriteOwnLockFile()
+bool GenDocumentLockFile::OverwriteOwnLockFile()
 {
     // allows to overwrite the lock file with the current data
     try
     {
         uno::Reference < css::ucb::XCommandEnvironment > xEnv;
-        ::ucbhelper::Content aTargetContent( m_aURL, xEnv, comphelper::getProcessComponentContext() );
+        ::ucbhelper::Content aTargetContent( GetURL(), xEnv, comphelper::getProcessComponentContext() );
 
         LockFileEntry aNewEntry = GenerateOwnEntry();
 
@@ -195,8 +153,7 @@ bool DocumentLockFile::OverwriteOwnLockFile()
     return true;
 }
 
-
-void DocumentLockFile::RemoveFile()
+void GenDocumentLockFile::RemoveFile()
 {
     ::osl::MutexGuard aGuard( m_aMutex );
 
@@ -212,15 +169,71 @@ void DocumentLockFile::RemoveFile()
     RemoveFileDirectly();
 }
 
-void DocumentLockFile::RemoveFileDirectly()
+void GenDocumentLockFile::RemoveFileDirectly()
 {
     uno::Reference < css::ucb::XCommandEnvironment > xEnv;
-    ::ucbhelper::Content aCnt(m_aURL, xEnv, comphelper::getProcessComponentContext());
+    ::ucbhelper::Content aCnt(GetURL(), xEnv, comphelper::getProcessComponentContext());
     aCnt.executeCommand("delete",
         uno::makeAny(true));
 }
 
 
+DocumentLockFile::DocumentLockFile( const OUString& aOrigURL )
+: GenDocumentLockFile( aOrigURL, ".~lock." )
+{
+}
+
+
+DocumentLockFile::~DocumentLockFile()
+{
+}
+
+
+void DocumentLockFile::WriteEntryToStream( const LockFileEntry& aEntry, const uno::Reference< io::XOutputStream >& xOutput )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    OUStringBuffer aBuffer;
+
+    for ( LockFileComponent lft : o3tl::enumrange<LockFileComponent>() )
+    {
+        aBuffer.append( EscapeCharacters( aEntry[lft] ) );
+        if ( lft < LockFileComponent::LAST )
+            aBuffer.append( ',' );
+        else
+            aBuffer.append( ';' );
+    }
+
+    OString aStringData( OUStringToOString( aBuffer.makeStringAndClear(), RTL_TEXTENCODING_UTF8 ) );
+    uno::Sequence< sal_Int8 > aData( reinterpret_cast<sal_Int8 const *>(aStringData.getStr()), aStringData.getLength() );
+    xOutput->writeBytes( aData );
+}
+
+LockFileEntry DocumentLockFile::GetLockData()
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    uno::Reference< io::XInputStream > xInput = OpenStream();
+    if ( !xInput.is() )
+        throw uno::RuntimeException();
+
+    const sal_Int32 nBufLen = 32000;
+    uno::Sequence< sal_Int8 > aBuffer( nBufLen );
+
+    sal_Int32 nRead = 0;
+
+    nRead = xInput->readBytes( aBuffer, nBufLen );
+    xInput->closeInput();
+
+    if ( nRead == nBufLen )
+        throw io::WrongFormatException();
+
+    sal_Int32 nCurPos = 0;
+    return ParseEntry( aBuffer, nCurPos );
+}
+
+
+
 
 } // namespace svt
 

svl/source/misc/lockfilecommon.cxx

@@ -54,7 +54,35 @@ using namespace ::com::sun::star;
 namespace svt {
 
 
+LockFileCommon::LockFileCommon( const OUString& aURL )
+{
+    m_aURL = aURL;
+}
+
 LockFileCommon::LockFileCommon( const OUString& aOrigURL, const OUString& aPrefix )
+{
+    m_aURL = GenerateURL(aOrigURL, aPrefix);
+}
+
+
+LockFileCommon::~LockFileCommon()
+{
+}
+
+
+const OUString& LockFileCommon::GetURL() const
+{
+    return m_aURL;
+}
+
+
+void LockFileCommon::SetURL(const OUString& aURL)
+{
+    m_aURL = aURL;
+}
+
+
+OUString LockFileCommon::GenerateURL( const OUString& aOrigURL, const OUString& aPrefix )
 {
     INetURLObject aDocURL = ResolveLinks( INetURLObject( aOrigURL ) );
 
@@ -62,12 +90,7 @@ LockFileCommon::LockFileCommon( const OUString& aOrigURL, const OUString& aPrefi
     aShareURLString += aPrefix;
     aShareURLString += aDocURL.GetName();
     aShareURLString += "%23"; // '#'
-    m_aURL = INetURLObject( aShareURLString ).GetMainURL( INetURLObject::DecodeMechanism::NONE );
-}
-
-
-LockFileCommon::~LockFileCommon()
-{
+    return INetURLObject( aShareURLString ).GetMainURL( INetURLObject::DecodeMechanism::NONE );
 }
 
 

svl/source/misc/msodocumentlockfile.cxx

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <svl/msodocumentlockfile.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <algorithm>
+
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+
+namespace svt
+{
+bool MSODocumentLockFile::isWordFormat(const OUString& aOrigURL) const
+{
+    INetURLObject aDocURL = ResolveLinks(INetURLObject(aOrigURL));
+
+    return aDocURL.GetFileExtension().compareToIgnoreAsciiCase("DOC") == 0
+           || aDocURL.GetFileExtension().compareToIgnoreAsciiCase("DOCX") == 0
+           || aDocURL.GetFileExtension().compareToIgnoreAsciiCase("RTF") == 0
+           || aDocURL.GetFileExtension().compareToIgnoreAsciiCase("ODT") == 0;
+}
+
+bool MSODocumentLockFile::isExcelFormat(const OUString& aOrigURL) const
+{
+    INetURLObject aDocURL = ResolveLinks(INetURLObject(aOrigURL));
+
+    return //aDocURL.GetFileExtension().compareToIgnoreAsciiCase("XLS") || // MSO does not create lockfile for XLS
+        aDocURL.GetFileExtension().compareToIgnoreAsciiCase("XLSX") == 0
+        || aDocURL.GetFileExtension().compareToIgnoreAsciiCase("ODS") == 0;
+}
+
+bool MSODocumentLockFile::isPowerPointFormat(const OUString& aOrigURL) const
+{
+    INetURLObject aDocURL = ResolveLinks(INetURLObject(aOrigURL));
+
+    return aDocURL.GetFileExtension().compareToIgnoreAsciiCase("PPTX") == 0
+           || aDocURL.GetFileExtension().compareToIgnoreAsciiCase("PPT") == 0
+           || aDocURL.GetFileExtension().compareToIgnoreAsciiCase("ODP") == 0;
+}
+
+MSODocumentLockFile::MSODocumentLockFile(const OUString& aOrigURL)
+    : GenDocumentLockFile(GenerateURL(aOrigURL, "~$"))
+    , m_sOrigURL(aOrigURL)
+{
+}
+
+MSODocumentLockFile::~MSODocumentLockFile() {}
+
+OUString MSODocumentLockFile::GenerateURL(const OUString& aOrigURL, const OUString& aPrefix)
+{
+    INetURLObject aDocURL = ResolveLinks(INetURLObject(aOrigURL));
+    OUString aURL = aDocURL.GetPartBeforeLastName();
+    aURL += aPrefix;
+
+    // For text documents MSO Word cuts some of the first characters of the file name
+    OUString sFileName = aDocURL.GetName();
+    if (isWordFormat(aOrigURL))
+    {
+        sal_Int32 nFileNameLength
+            = aDocURL.GetName().getLength() - aDocURL.GetFileExtension().getLength() - 1;
+        if (nFileNameLength >= 8)
+            aURL += sFileName.copy(2);
+        else if (nFileNameLength == 7)
+            aURL += sFileName.copy(1);
+        else
+            aURL += sFileName;
+    }
+    else
+    {
+        aURL += sFileName;
+    }
+    return INetURLObject(aURL).GetMainURL(INetURLObject::DecodeMechanism::NONE);
+}
+
+void MSODocumentLockFile::WriteEntryToStream(
+    const LockFileEntry& aEntry, const css::uno::Reference<css::io::XOutputStream>& xOutput)
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    // Reallocate the date with the right size, different lock file size for different components
+    int nLockFileSize = isWordFormat(m_sOrigURL) ? MSO_WORD_LOCKFILE_SIZE
+                                                 : MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE;
+    css::uno::Sequence<sal_Int8> aData(nLockFileSize);
+
+    // Write out the user name's length as a single byte integer
+    // The maximum length is 52 in MSO, so we'll need to truncate the user name if it's longer
+    OUString aUserName = aEntry[LockFileComponent::OOOUSERNAME];
+    int nIndex = 0;
+    aData[nIndex] = static_cast<sal_Int8>(
+        std::min(aUserName.getLength(), sal_Int32(MSO_USERNAME_MAX_LENGTH)));
+
+    if (aUserName.getLength() > MSO_USERNAME_MAX_LENGTH)
+        aUserName = aUserName.copy(0, MSO_USERNAME_MAX_LENGTH);
+
+    // From the second position write out the user name using one byte characters.
+    nIndex = 1;
+    for (int nChar = 0; nChar < aUserName.getLength(); ++nChar)
+    {
+        aData[nIndex] = static_cast<sal_Int8>(aUserName[nChar]);
+        ++nIndex;
+    }
+
+    // Fill up the remaining bytes with dummy data
+    if (isWordFormat(m_sOrigURL))
+    {
+        while (nIndex < MSO_USERNAME_MAX_LENGTH + 2)
+        {
+            aData[nIndex] = static_cast<sal_Int8>(0);
+            ++nIndex;
+        }
+    }
+    else if (isExcelFormat(m_sOrigURL))
+    {
+        while (nIndex < MSO_USERNAME_MAX_LENGTH + 3)
+        {
+            aData[nIndex] = static_cast<sal_Int8>(0x20);
+            ++nIndex;
+        }
+    }
+    else
+    {
+        aData[nIndex] = static_cast<sal_Int8>(0);
+        ++nIndex;
+
+        while (nIndex < MSO_USERNAME_MAX_LENGTH + 3)
+        {
+            aData[nIndex] = static_cast<sal_Int8>(0x20);
+            ++nIndex;
+        }
+    }
+
+    // At the next position we have the user name's length again, but now as a 2 byte integer
+    aData[nIndex] = static_cast<sal_Int8>(
+        std::min(aUserName.getLength(), sal_Int32(MSO_USERNAME_MAX_LENGTH)));
+    ++nIndex;
+    aData[nIndex] = 0;
+    ++nIndex;
+
+    // And the user name again with unicode characters
+    for (int nChar = 0; nChar < aUserName.getLength(); ++nChar)
+    {
+        aData[nIndex] = static_cast<sal_Int8>(aUserName[nChar] & 0xff);
+        ++nIndex;
+        aData[nIndex] = static_cast<sal_Int8>(aUserName[nChar] >> 8);
+        ++nIndex;
+    }
+
+    // Fill the remaining part with dummy bits
+    if (isWordFormat(m_sOrigURL))
+    {
+        while (nIndex < nLockFileSize)
+        {
+            aData[nIndex] = static_cast<sal_Int8>(0);
+            ++nIndex;
+        }
+    }
+    else
+    {
+        while (nIndex < nLockFileSize)
+        {
+            aData[nIndex] = static_cast<sal_Int8>(0x20);
+            ++nIndex;
+            if (nIndex < nLockFileSize)
+            {
+                aData[nIndex] = static_cast<sal_Int8>(0);
+                ++nIndex;
+            }
+        }
+    }
+
+    xOutput->writeBytes(aData);
+}
+
+LockFileEntry MSODocumentLockFile::GetLockData()
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    LockFileEntry aResult;
+    css::uno::Reference<css::io::XInputStream> xInput = OpenStream();
+    if (!xInput.is())
+        throw css::uno::RuntimeException();
+
+    const sal_Int32 nBufLen = 256;
+    css::uno::Sequence<sal_Int8> aBuf(nBufLen);
+    const sal_Int32 nRead = xInput->readBytes(aBuf, nBufLen);
+    xInput->closeInput();
+    if (nRead >= 162)
+    {
+        // Reverse engineering of MS Office Owner Files format (MS Office 2016 tested).
+        // It starts with a single byte with name length, after which characters of username go
+        // in current Windows 8-bit codepage.
+        // For Word lockfiles, the name is followed by zero bytes up to position 54.
+        // For PowerPoint lockfiles, the name is followed by a single zero byte, and then 0x20
+        // bytes up to position 55.
+        // For Excel lockfiles, the name is followed by 0x20 bytes up to position 55.
+        // At those positions in each type of lockfile, a name length 2-byte word goes, followed
+        // by UTF-16-LE-encoded copy of username. Spaces or some garbage follow up to the end of
+        // the lockfile (total 162 bytes for Word, 165 bytes for Excel/PowerPoint).
+        // Apparently MS Office does not allow username to be longer than 52 characters (trying
+        // to enter more in its options dialog results in error messages stating this limit).
+        const int nACPLen = aBuf[0];
+        if (nACPLen > 0 && nACPLen <= 52) // skip wrong format
+        {
+            const sal_Int8* pBuf = aBuf.getConstArray() + 54;
+            int nUTF16Len = *pBuf; // try Word position
+            // If UTF-16 length is 0x20, then ACP length is also less than maximal, which means
+            // that in Word lockfile case, at least two preceeding bytes would be zero. Both
+            // Excel and PowerPoint lockfiles would have at least one of those bytes non-zero.
+            if (nUTF16Len == 0x20 && (*(pBuf - 1) != 0 || *(pBuf - 2) != 0))
+                nUTF16Len = *++pBuf; // use Excel/PowerPoint position
+
+            if (nUTF16Len > 0 && nUTF16Len <= 52) // skip wrong format
+                aResult[LockFileComponent::OOOUSERNAME]
+                    = OUString(reinterpret_cast<const sal_Unicode*>(pBuf + 2), nUTF16Len);
+        }
+    }
+    return aResult;
+}
+
+void MSODocumentLockFile::RemoveFile()
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    // TODO/LATER: the removing is not atomic, is it possible in general to make it atomic?
+    LockFileEntry aNewEntry = GenerateOwnEntry();
+    LockFileEntry aFileData = GetLockData();
+
+    if (aFileData[LockFileComponent::OOOUSERNAME] != aNewEntry[LockFileComponent::OOOUSERNAME])
+        throw css::io::IOException(); // not the owner, access denied
+
+    RemoveFileDirectly();
+}
+
+} // namespace svt
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */

svl/source/misc/sharecontrolfile.cxx

@@ -55,10 +55,10 @@ namespace svt {
 ShareControlFile::ShareControlFile( const OUString& aOrigURL )
 : LockFileCommon( aOrigURL, ".~sharing." )
 {
-    if ( !m_xStream.is() && !m_aURL.isEmpty() )
+    if ( !m_xStream.is() && !GetURL().isEmpty() )
     {
         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
-        ::ucbhelper::Content aContent = ::ucbhelper::Content( m_aURL, xDummyEnv, comphelper::getProcessComponentContext() );
+        ::ucbhelper::Content aContent = ::ucbhelper::Content( GetURL(), xDummyEnv, comphelper::getProcessComponentContext() );
 
         uno::Reference< ucb::XContentIdentifier > xContId( aContent.get().is() ? aContent.get()->getIdentifier() : nullptr );
         if ( !xContId.is() || xContId->getContentProviderScheme() != "file" )
@@ -329,7 +329,7 @@ void ShareControlFile::RemoveFile()
     Close();
 
     uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(ucb::SimpleFileAccess::create(comphelper::getProcessComponentContext()));
-    xSimpleFileAccess->kill( m_aURL );
+    xSimpleFileAccess->kill( GetURL() );
 }
 
 } // namespace svt