/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_comphelper.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace ::com::sun::star; namespace comphelper { // ---------------------------------------------------------------------- uno::Reference< lang::XSingleServiceFactory > OStorageHelper::GetStorageFactory( const uno::Reference< lang::XMultiServiceFactory >& xSF ) throw ( uno::Exception ) { uno::Reference< lang::XMultiServiceFactory > xFactory = xSF.is() ? xSF : ::comphelper::getProcessServiceFactory(); if ( !xFactory.is() ) throw uno::RuntimeException(); uno::Reference < lang::XSingleServiceFactory > xStorageFactory( xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.embed.StorageFactory" ) ), uno::UNO_QUERY ); if ( !xStorageFactory.is() ) throw uno::RuntimeException(); return xStorageFactory; } // ---------------------------------------------------------------------- uno::Reference< lang::XSingleServiceFactory > OStorageHelper::GetFileSystemStorageFactory( const uno::Reference< lang::XMultiServiceFactory >& xSF ) throw ( uno::Exception ) { uno::Reference< lang::XMultiServiceFactory > xFactory = xSF.is() ? xSF : ::comphelper::getProcessServiceFactory(); if ( !xFactory.is() ) throw uno::RuntimeException(); uno::Reference < lang::XSingleServiceFactory > xStorageFactory( xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.embed.FileSystemStorageFactory" ) ), uno::UNO_QUERY ); if ( !xStorageFactory.is() ) throw uno::RuntimeException(); return xStorageFactory; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetTemporaryStorage( const uno::Reference< lang::XMultiServiceFactory >& xFactory ) throw ( uno::Exception ) { uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( xFactory )->createInstance(), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromURL( const ::rtl::OUString& aURL, sal_Int32 nStorageMode, const uno::Reference< lang::XMultiServiceFactory >& xFactory ) throw ( uno::Exception ) { uno::Sequence< uno::Any > aArgs( 2 ); aArgs[0] <<= aURL; aArgs[1] <<= nStorageMode; uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( xFactory )->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromURL2( const ::rtl::OUString& aURL, sal_Int32 nStorageMode, const uno::Reference< lang::XMultiServiceFactory >& xFactory ) throw ( uno::Exception ) { uno::Sequence< uno::Any > aArgs( 2 ); aArgs[0] <<= aURL; aArgs[1] <<= nStorageMode; uno::Reference< lang::XSingleServiceFactory > xFact; try { ::ucbhelper::Content aCntnt( aURL, uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); if (aCntnt.isDocument()) { xFact = GetStorageFactory( xFactory ); } else { xFact = GetFileSystemStorageFactory( xFactory ); } } catch (uno::Exception &) { } if (!xFact.is()) throw uno::RuntimeException(); uno::Reference< embed::XStorage > xTempStorage( xFact->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromInputStream( const uno::Reference < io::XInputStream >& xStream, const uno::Reference< lang::XMultiServiceFactory >& xFactory ) throw ( uno::Exception ) { uno::Sequence< uno::Any > aArgs( 2 ); aArgs[0] <<= xStream; aArgs[1] <<= embed::ElementModes::READ; uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( xFactory )->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromStream( const uno::Reference < io::XStream >& xStream, sal_Int32 nStorageMode, const uno::Reference< lang::XMultiServiceFactory >& xFactory ) throw ( uno::Exception ) { uno::Sequence< uno::Any > aArgs( 2 ); aArgs[0] <<= xStream; aArgs[1] <<= nStorageMode; uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( xFactory )->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- void OStorageHelper::CopyInputToOutput( const uno::Reference< io::XInputStream >& xInput, const uno::Reference< io::XOutputStream >& xOutput ) throw ( uno::Exception ) { static const sal_Int32 nConstBufferSize = 32000; sal_Int32 nRead; uno::Sequence < sal_Int8 > aSequence ( nConstBufferSize ); do { nRead = xInput->readBytes ( aSequence, nConstBufferSize ); if ( nRead < nConstBufferSize ) { uno::Sequence < sal_Int8 > aTempBuf ( aSequence.getConstArray(), nRead ); xOutput->writeBytes ( aTempBuf ); } else xOutput->writeBytes ( aSequence ); } while ( nRead == nConstBufferSize ); } // ---------------------------------------------------------------------- uno::Reference< io::XInputStream > OStorageHelper::GetInputStreamFromURL( const ::rtl::OUString& aURL, const uno::Reference< lang::XMultiServiceFactory >& xSF ) throw ( uno::Exception ) { uno::Reference< lang::XMultiServiceFactory > xFactory = xSF.is() ? xSF : ::comphelper::getProcessServiceFactory(); if ( !xFactory.is() ) throw uno::RuntimeException(); uno::Reference < ::com::sun::star::ucb::XSimpleFileAccess > xTempAccess( xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ), uno::UNO_QUERY ); if ( !xTempAccess.is() ) throw uno::RuntimeException(); uno::Reference< io::XInputStream > xInputStream = xTempAccess->openFileRead( aURL ); if ( !xInputStream.is() ) throw uno::RuntimeException(); return xInputStream; } // ---------------------------------------------------------------------- void OStorageHelper::SetCommonStorageEncryptionData( const uno::Reference< embed::XStorage >& xStorage, const uno::Sequence< beans::NamedValue >& aEncryptionData ) throw ( uno::Exception ) { uno::Reference< embed::XEncryptionProtectedSource2 > xEncrSet( xStorage, uno::UNO_QUERY ); if ( !xEncrSet.is() ) throw io::IOException(); // TODO xEncrSet->setEncryptionData( aEncryptionData ); } // ---------------------------------------------------------------------- sal_Int32 OStorageHelper::GetXStorageFormat( const uno::Reference< embed::XStorage >& xStorage ) throw ( uno::Exception ) { uno::Reference< beans::XPropertySet > xStorProps( xStorage, uno::UNO_QUERY_THROW ); ::rtl::OUString aMediaType; xStorProps->getPropertyValue( ::rtl::OUString::createFromAscii( "MediaType" ) ) >>= aMediaType; sal_Int32 nResult = 0; // TODO/LATER: the filter configuration could be used to detect it later, or batter a special service if ( aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_WRITER_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_WRITER_WEB_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_WRITER_GLOBAL_ASCII) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_DRAW_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_IMPRESS_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_CALC_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_CHART_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_VND_SUN_XML_MATH_ASCII ) ) { nResult = SOFFICE_FILEFORMAT_60; } else if ( aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_WEB_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_GLOBAL_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_ASCII) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_CHART_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_DATABASE_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_REPORT_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_REPORT_CHART_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_TEMPLATE_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_TEMPLATE_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_TEMPLATE_ASCII) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_TEMPLATE_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_CHART_TEMPLATE_ASCII ) || aMediaType.equalsIgnoreAsciiCaseAscii(MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_TEMPLATE_ASCII ) ) { nResult = SOFFICE_FILEFORMAT_8; } else { // the mediatype is not known throw beans::IllegalTypeException(); } return nResult; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetTemporaryStorageOfFormat( const ::rtl::OUString& aFormat, const uno::Reference< lang::XMultiServiceFactory >& xFactory ) throw ( uno::Exception ) { uno::Reference< lang::XMultiServiceFactory > xFactoryToUse = xFactory.is() ? xFactory : ::comphelper::getProcessServiceFactory(); if ( !xFactoryToUse.is() ) throw uno::RuntimeException(); uno::Reference< io::XStream > xTmpStream( xFactoryToUse->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ), uno::UNO_QUERY_THROW ); return GetStorageOfFormatFromStream( aFormat, xTmpStream, embed::ElementModes::READWRITE, xFactoryToUse ); } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetStorageOfFormatFromURL( const ::rtl::OUString& aFormat, const ::rtl::OUString& aURL, sal_Int32 nStorageMode, const uno::Reference< lang::XMultiServiceFactory >& xFactory, sal_Bool bRepairStorage ) throw ( uno::Exception ) { uno::Sequence< beans::PropertyValue > aProps( 1 ); aProps[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StorageFormat" ) ); aProps[0].Value <<= aFormat; if ( bRepairStorage ) { aProps.realloc( 2 ); aProps[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RepairPackage" ) ); aProps[1].Value <<= bRepairStorage; } uno::Sequence< uno::Any > aArgs( 3 ); aArgs[0] <<= aURL; aArgs[1] <<= nStorageMode; aArgs[2] <<= aProps; uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( xFactory )->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetStorageOfFormatFromInputStream( const ::rtl::OUString& aFormat, const uno::Reference < io::XInputStream >& xStream, const uno::Reference< lang::XMultiServiceFactory >& xFactory, sal_Bool bRepairStorage ) throw ( uno::Exception ) { uno::Sequence< beans::PropertyValue > aProps( 1 ); aProps[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StorageFormat" ) ); aProps[0].Value <<= aFormat; if ( bRepairStorage ) { aProps.realloc( 2 ); aProps[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RepairPackage" ) ); aProps[1].Value <<= bRepairStorage; } uno::Sequence< uno::Any > aArgs( 3 ); aArgs[0] <<= xStream; aArgs[1] <<= embed::ElementModes::READ; aArgs[2] <<= aProps; uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( xFactory )->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- uno::Reference< embed::XStorage > OStorageHelper::GetStorageOfFormatFromStream( const ::rtl::OUString& aFormat, const uno::Reference < io::XStream >& xStream, sal_Int32 nStorageMode, const uno::Reference< lang::XMultiServiceFactory >& xFactory, sal_Bool bRepairStorage ) throw ( uno::Exception ) { uno::Sequence< beans::PropertyValue > aProps( 1 ); aProps[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StorageFormat" ) ); aProps[0].Value <<= aFormat; if ( bRepairStorage ) { aProps.realloc( 2 ); aProps[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RepairPackage" ) ); aProps[1].Value <<= bRepairStorage; } uno::Sequence< uno::Any > aArgs( 3 ); aArgs[0] <<= xStream; aArgs[1] <<= nStorageMode; aArgs[2] <<= aProps; uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( xFactory )->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); if ( !xTempStorage.is() ) throw uno::RuntimeException(); return xTempStorage; } // ---------------------------------------------------------------------- uno::Sequence< beans::NamedValue > OStorageHelper::CreatePackageEncryptionData( const ::rtl::OUString& aPassword, const uno::Reference< lang::XMultiServiceFactory >& xSF ) { // TODO/LATER: Should not the method be part of DocPasswordHelper? uno::Sequence< beans::NamedValue > aEncryptionData; sal_Int32 nSha1Ind = 0; if ( !aPassword.isEmpty() ) { // generate SHA256 start key try { uno::Reference< lang::XMultiServiceFactory > xFactory = xSF.is() ? xSF : ::comphelper::getProcessServiceFactory(); if ( !xFactory.is() ) throw uno::RuntimeException(); uno::Reference< xml::crypto::XDigestContextSupplier > xDigestContextSupplier( xFactory->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.crypto.NSSInitializer" ) ) ), uno::UNO_QUERY_THROW ); uno::Reference< xml::crypto::XDigestContext > xDigestContext( xDigestContextSupplier->getDigestContext( xml::crypto::DigestID::SHA256, uno::Sequence< beans::NamedValue >() ), uno::UNO_SET_THROW ); ::rtl::OString aUTF8Password( ::rtl::OUStringToOString( aPassword, RTL_TEXTENCODING_UTF8 ) ); xDigestContext->updateDigest( uno::Sequence< sal_Int8 >( reinterpret_cast< const sal_Int8* >( aUTF8Password.getStr() ), aUTF8Password.getLength() ) ); uno::Sequence< sal_Int8 > aDigest = xDigestContext->finalizeDigestAndDispose(); aEncryptionData.realloc( ++nSha1Ind ); aEncryptionData[0].Name = PACKAGE_ENCRYPTIONDATA_SHA256UTF8; aEncryptionData[0].Value <<= aDigest; } catch ( uno::Exception& ) { OSL_ENSURE( false, "Can not create SHA256 digest!" ); } // MS_1252 encoding was used for SO60 document format password encoding, // this encoding supports only a minor subset of nonascii characters, // but for compatibility reasons it has to be used for old document formats aEncryptionData.realloc( nSha1Ind + 2 ); aEncryptionData[nSha1Ind].Name = PACKAGE_ENCRYPTIONDATA_SHA1UTF8; aEncryptionData[nSha1Ind + 1].Name = PACKAGE_ENCRYPTIONDATA_SHA1MS1252; rtl_TextEncoding pEncoding[2] = { RTL_TEXTENCODING_UTF8, RTL_TEXTENCODING_MS_1252 }; for ( sal_Int32 nInd = 0; nInd < 2; nInd++ ) { ::rtl::OString aByteStrPass = ::rtl::OUStringToOString( aPassword, pEncoding[nInd] ); sal_uInt8 pBuffer[RTL_DIGEST_LENGTH_SHA1]; rtlDigestError nError = rtl_digest_SHA1( aByteStrPass.getStr(), aByteStrPass.getLength(), pBuffer, RTL_DIGEST_LENGTH_SHA1 ); if ( nError != rtl_Digest_E_None ) { aEncryptionData.realloc( nSha1Ind ); break; } aEncryptionData[nSha1Ind+nInd].Value <<= uno::Sequence< sal_Int8 >( (sal_Int8*)pBuffer, RTL_DIGEST_LENGTH_SHA1 ); } } return aEncryptionData; } // ---------------------------------------------------------------------- sal_Bool OStorageHelper::IsValidZipEntryFileName( const ::rtl::OUString& aName, sal_Bool bSlashAllowed ) { return IsValidZipEntryFileName( aName.getStr(), aName.getLength(), bSlashAllowed ); } // ---------------------------------------------------------------------- sal_Bool OStorageHelper::IsValidZipEntryFileName( const sal_Unicode *pChar, sal_Int32 nLength, sal_Bool bSlashAllowed ) { for ( sal_Int32 i = 0; i < nLength; i++ ) { switch ( pChar[i] ) { case '\\': case '?': case '<': case '>': case '\"': case '|': case ':': return sal_False; case '/': if ( !bSlashAllowed ) return sal_False; break; default: if ( pChar[i] < 32 || (pChar[i] >= 0xD800 && pChar[i] <= 0xDFFF) ) return sal_False; } } return sal_True; } // ---------------------------------------------------------------------- sal_Bool OStorageHelper::PathHasSegment( const ::rtl::OUString& aPath, const ::rtl::OUString& aSegment ) { sal_Bool bResult = sal_False; const sal_Int32 nPathLen = aPath.getLength(); const sal_Int32 nSegLen = aSegment.getLength(); if ( nSegLen && nPathLen >= nSegLen ) { ::rtl::OUString aEndSegment( RTL_CONSTASCII_USTRINGPARAM( "/" ) ); aEndSegment += aSegment; ::rtl::OUString aInternalSegment( aEndSegment ); aInternalSegment += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) ); if ( aPath.indexOf( aInternalSegment ) >= 0 ) bResult = sal_True; if ( !bResult && !aPath.compareTo( aSegment, nSegLen ) ) { if ( nPathLen == nSegLen || aPath.getStr()[nSegLen] == (sal_Unicode)'/' ) bResult = sal_True; } if ( !bResult && nPathLen > nSegLen && aPath.copy( nPathLen - nSegLen - 1, nSegLen + 1 ).equals( aEndSegment ) ) bResult = sal_True; } return bResult; } }