svtools/source/misc/lockfilecommon.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ,v $
  10  *
  11  * $Revision: $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_svtools.hxx"
  34
  35 #include <stdio.h>
  36
  37 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
  38 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  39 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
  40 #include <com/sun/star/ucb/NameClashException.hpp>
  41 #include <com/sun/star/io/WrongFormatException.hpp>
  42
  43 #include <osl/time.h>
  44 #include <osl/security.hxx>
  45 #include <osl/socket.hxx>
  46 #include <osl/file.hxx>
  47
  48 #include <rtl/string.hxx>
  49 #include <rtl/ustring.hxx>
  50 #include <rtl/strbuf.hxx>
  51 #include <rtl/ustrbuf.hxx>
  52
  53 #include <comphelper/processfactory.hxx>
  54
  55 #include <tools/urlobj.hxx>
  56 #include <unotools/bootstrap.hxx>
  57
  58 #include <ucbhelper/content.hxx>
  59
  60 #include <svtools/useroptions.hxx>
  61
  62 #include <svtools/lockfilecommon.hxx>
  63
  64 using namespace ::com::sun::star;
  65
  66 namespace svt {
  67
  68 // ----------------------------------------------------------------------
  69 LockFileCommon::LockFileCommon( const ::rtl::OUString& aOrigURL, const uno::Reference< lang::XMultiServiceFactory >& xFactory, const ::rtl::OUString& aPrefix )
  70 : m_xFactory( xFactory )
  71 {
  72     if ( !m_xFactory.is() )
  73         m_xFactory = ::comphelper::getProcessServiceFactory();
  74
  75     INetURLObject aDocURL = ResolveLinks( INetURLObject( aOrigURL ) );
  76
  77     ::rtl::OUString aShareURLString = aDocURL.GetPartBeforeLastName();
  78     aShareURLString += aPrefix;
  79     aShareURLString += aDocURL.GetName();
  80     aShareURLString += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "#" ) );
  81     m_aURL = INetURLObject( aShareURLString ).GetMainURL( INetURLObject::NO_DECODE );
  82 }
  83
  84 // ----------------------------------------------------------------------
  85 LockFileCommon::~LockFileCommon()
  86 {
  87 }
  88
  89 // ----------------------------------------------------------------------
  90 INetURLObject LockFileCommon::ResolveLinks( const INetURLObject& aDocURL )
  91 {
  92     if ( aDocURL.HasError() )
  93         throw lang::IllegalArgumentException();
  94
  95     ::rtl::OUString aURLToCheck = aDocURL.GetMainURL( INetURLObject::NO_DECODE );
  96
  97     sal_Bool bNeedsChecking = sal_True;
  98     sal_Int32 nMaxLinkCount = 128;
  99     sal_Int32 nCount = 0;
 100
 101     while( bNeedsChecking )
 102     {
 103         bNeedsChecking = sal_False;
 104
 105         // do not allow too deep links
 106         if ( nCount++ >= nMaxLinkCount )
 107             throw io::IOException();
 108
 109         // there is currently no UCB functionality to resolve the symbolic links;
 110         // since the lock files are used only for local file systems the osl functionality is used directly
 111
 112         ::osl::FileStatus aStatus( FileStatusMask_Type | FileStatusMask_LinkTargetURL );
 113         ::osl::DirectoryItem aItem;
 114         if ( ::osl::FileBase::E_None == ::osl::DirectoryItem::get( aURLToCheck, aItem )
 115           && aItem.is() && ::osl::FileBase::E_None == aItem.getFileStatus( aStatus ) )
 116         {
 117             if ( aStatus.isValid( FileStatusMask_Type )
 118               && aStatus.isValid( FileStatusMask_LinkTargetURL )
 119               && aStatus.getFileType() == ::osl::FileStatus::Link )
 120             {
 121                 aURLToCheck = aStatus.getLinkTargetURL();
 122                 bNeedsChecking = sal_True;
 123             }
 124         }
 125     }
 126
 127     return INetURLObject( aURLToCheck );
 128 }
 129
 130 // ----------------------------------------------------------------------
 131 uno::Sequence< uno::Sequence< ::rtl::OUString > > LockFileCommon::ParseList( const uno::Sequence< sal_Int8 >& aBuffer )
 132 {
 133     sal_Int32 nCurPos = 0;
 134     sal_Int32 nCurEntry = 0;
 135     uno::Sequence< uno::Sequence< ::rtl::OUString > > aResult( 10 );
 136
 137     while ( nCurPos < aBuffer.getLength() )
 138     {
 139         if ( nCurEntry >= aResult.getLength() )
 140             aResult.realloc( nCurEntry + 10 );
 141         aResult[nCurEntry] = ParseEntry( aBuffer, nCurPos );
 142         nCurEntry++;
 143     }
 144
 145     aResult.realloc( nCurEntry );
 146     return aResult;
 147 }
 148
 149 // ----------------------------------------------------------------------
 150 uno::Sequence< ::rtl::OUString > LockFileCommon::ParseEntry( const uno::Sequence< sal_Int8 >& aBuffer, sal_Int32& io_nCurPos )
 151 {
 152     uno::Sequence< ::rtl::OUString > aResult( LOCKFILE_ENTRYSIZE );
 153
 154     for ( int nInd = 0; nInd < LOCKFILE_ENTRYSIZE; nInd++ )
 155     {
 156         aResult[nInd] = ParseName( aBuffer, io_nCurPos );
 157         if ( io_nCurPos >= aBuffer.getLength()
 158           || ( nInd < LOCKFILE_ENTRYSIZE - 1 && aBuffer[io_nCurPos++] != ',' )
 159           || ( nInd == LOCKFILE_ENTRYSIZE - 1 && aBuffer[io_nCurPos++] != ';' ) )
 160             throw io::WrongFormatException();
 161     }
 162
 163     return aResult;
 164 }
 165
 166 // ----------------------------------------------------------------------
 167 ::rtl::OUString LockFileCommon::ParseName( const uno::Sequence< sal_Int8 >& aBuffer, sal_Int32& io_nCurPos )
 168 {
 169     ::rtl::OStringBuffer aResult;
 170     sal_Bool bHaveName = sal_False;
 171     sal_Bool bEscape = sal_False;
 172
 173     while( !bHaveName )
 174     {
 175         if ( io_nCurPos >= aBuffer.getLength() )
 176             throw io::WrongFormatException();
 177
 178         if ( bEscape )
 179         {
 180             if ( aBuffer[io_nCurPos] == ',' || aBuffer[io_nCurPos] == ';' || aBuffer[io_nCurPos] == '\\' )
 181                 aResult.append( (sal_Char)aBuffer[io_nCurPos] );
 182             else
 183                 throw io::WrongFormatException();
 184
 185             bEscape = sal_False;
 186             io_nCurPos++;
 187         }
 188         else if ( aBuffer[io_nCurPos] == ',' || aBuffer[io_nCurPos] == ';' )
 189             bHaveName = sal_True;
 190         else
 191         {
 192             if ( aBuffer[io_nCurPos] == '\\' )
 193                 bEscape = sal_True;
 194             else
 195                 aResult.append( (sal_Char)aBuffer[io_nCurPos] );
 196
 197             io_nCurPos++;
 198         }
 199     }
 200
 201     return ::rtl::OStringToOUString( aResult.makeStringAndClear(), RTL_TEXTENCODING_UTF8 );
 202 }
 203
 204 // ----------------------------------------------------------------------
 205 ::rtl::OUString LockFileCommon::EscapeCharacters( const ::rtl::OUString& aSource )
 206 {
 207     ::rtl::OUStringBuffer aBuffer;
 208     const sal_Unicode* pStr = aSource.getStr();
 209     for ( sal_Int32 nInd = 0; nInd < aSource.getLength() && pStr[nInd] != 0; nInd++ )
 210     {
 211         if ( pStr[nInd] == '\\' || pStr[nInd] == ';' || pStr[nInd] == ',' )
 212             aBuffer.append( (sal_Unicode)'\\' );
 213         aBuffer.append( pStr[nInd] );
 214     }
 215
 216     return aBuffer.makeStringAndClear();
 217 }
 218
 219 // ----------------------------------------------------------------------
 220 ::rtl::OUString LockFileCommon::GetOOOUserName()
 221 {
 222     SvtUserOptions aUserOpt;
 223     ::rtl::OUString aName = aUserOpt.GetFirstName();
 224     if ( aName.getLength() )
 225         aName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " ) );
 226     aName += aUserOpt.GetLastName();
 227
 228     return aName;
 229 }
 230
 231 // ----------------------------------------------------------------------
 232 ::rtl::OUString LockFileCommon::GetCurrentLocalTime()
 233 {
 234     ::rtl::OUString aTime;
 235
 236     TimeValue aSysTime;
 237     if ( osl_getSystemTime( &aSysTime ) )
 238     {
 239         TimeValue aLocTime;
 240         if ( osl_getLocalTimeFromSystemTime( &aSysTime, &aLocTime ) )
 241         {
 242             oslDateTime aDateTime;
 243             if ( osl_getDateTimeFromTimeValue( &aLocTime, &aDateTime ) )
 244             {
 245                 char pDateTime[20];
 246                 sprintf( pDateTime, "%02d.%02d.%4d %02d:%02d", aDateTime.Day, aDateTime.Month, aDateTime.Year, aDateTime.Hours, aDateTime.Minutes );
 247                 aTime = ::rtl::OUString::createFromAscii( pDateTime );
 248             }
 249         }
 250     }
 251
 252     return aTime;
 253 }
 254
 255 // ----------------------------------------------------------------------
 256 uno::Sequence< ::rtl::OUString > LockFileCommon::GenerateOwnEntry()
 257 {
 258     uno::Sequence< ::rtl::OUString > aResult( LOCKFILE_ENTRYSIZE );
 259
 260     aResult[LOCKFILE_OOOUSERNAME_ID] = GetOOOUserName();
 261
 262     ::osl::Security aSecurity;
 263     aSecurity.getUserName( aResult[LOCKFILE_SYSUSERNAME_ID] );
 264
 265     aResult[LOCKFILE_LOCALHOST_ID] = ::osl::SocketAddr::getLocalHostname();
 266
 267     aResult[LOCKFILE_EDITTIME_ID] = GetCurrentLocalTime();
 268
 269     ::utl::Bootstrap::locateUserInstallation( aResult[LOCKFILE_USERURL_ID] );
 270
 271
 272     return aResult;
 273 }
 274
 275 } // namespace svt
 276