cdcfd8b1df
warn:unotools.misc:21376:31920:unotools/source/misc/mediadescriptor.cxx:372: url: 'private:factory/scalc' com.sun.star.ucb.ContentCreationException message: "No Content Provider available for URL: private:factory/scalc at C:/lo/core/ucbhelper/source/client/content.cxx:205" eError: (com.sun.star.ucb.ContentCreationError) NO_CONTENT_PROVIDER Change-Id: Ibb430ed0779f2064975b8fcc43204164adaeb8d0 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/168895 Reviewed-by: Mike Kaganski <mike.kaganski@collabora.com> Tested-by: Jenkins
500 lines
19 KiB
C++
500 lines
19 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* 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/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* 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 .
|
|
*/
|
|
|
|
#include <comphelper/docpasswordhelper.hxx>
|
|
#include <sal/log.hxx>
|
|
#include <unotools/configmgr.hxx>
|
|
#include <unotools/mediadescriptor.hxx>
|
|
#include <unotools/securityoptions.hxx>
|
|
#include <unotools/ucbhelper.hxx>
|
|
#include <comphelper/namedvaluecollection.hxx>
|
|
#include <comphelper/stillreadwriteinteraction.hxx>
|
|
|
|
#include <com/sun/star/ucb/ContentCreationException.hpp>
|
|
#include <com/sun/star/ucb/XContent.hpp>
|
|
#include <com/sun/star/task/XInteractionHandler.hpp>
|
|
#include <com/sun/star/io/XStream.hpp>
|
|
#include <com/sun/star/io/XActiveDataSink.hpp>
|
|
#include <com/sun/star/io/XSeekable.hpp>
|
|
#include <com/sun/star/lang/IllegalArgumentException.hpp>
|
|
#include <com/sun/star/uri/UriReferenceFactory.hpp>
|
|
#include <com/sun/star/uri/XUriReference.hpp>
|
|
#include <com/sun/star/ucb/PostCommandArgument2.hpp>
|
|
#include <officecfg/Office/Common.hxx>
|
|
#include <ucbhelper/content.hxx>
|
|
#include <ucbhelper/commandenvironment.hxx>
|
|
#include <ucbhelper/activedatasink.hxx>
|
|
#include <comphelper/processfactory.hxx>
|
|
#include <tools/urlobj.hxx>
|
|
#include <osl/diagnose.h>
|
|
#include <comphelper/diagnose_ex.hxx>
|
|
|
|
namespace utl {
|
|
|
|
namespace {
|
|
|
|
OUString removeFragment(OUString const & uri) {
|
|
css::uno::Reference< css::uri::XUriReference > ref(
|
|
css::uri::UriReferenceFactory::create(
|
|
comphelper::getProcessComponentContext())->
|
|
parse(uri));
|
|
if (ref.is()) {
|
|
ref->clearFragment();
|
|
return ref->getUriReference();
|
|
} else {
|
|
SAL_WARN("unotools.misc", "cannot parse <" << uri << ">");
|
|
return uri;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
MediaDescriptor::MediaDescriptor()
|
|
{
|
|
}
|
|
|
|
MediaDescriptor::MediaDescriptor(const css::uno::Sequence< css::beans::PropertyValue >& lSource)
|
|
: SequenceAsHashMap(lSource)
|
|
{
|
|
}
|
|
|
|
bool MediaDescriptor::isStreamReadOnly() const
|
|
{
|
|
bool bReadOnly = false;
|
|
|
|
// check for explicit readonly state
|
|
const_iterator pIt = find(MediaDescriptor::PROP_READONLY);
|
|
if (pIt != end())
|
|
{
|
|
pIt->second >>= bReadOnly;
|
|
return bReadOnly;
|
|
}
|
|
|
|
// streams based on post data are readonly by definition
|
|
pIt = find(MediaDescriptor::PROP_POSTDATA);
|
|
if (pIt != end())
|
|
return true;
|
|
|
|
// A XStream capsulate XInputStream and XOutputStream ...
|
|
// If it exists - the file must be open in read/write mode!
|
|
pIt = find(MediaDescriptor::PROP_STREAM);
|
|
if (pIt != end())
|
|
return false;
|
|
|
|
// Only file system content provider is able to provide XStream
|
|
// so for this content impossibility to create XStream triggers
|
|
// switch to readonly mode.
|
|
try
|
|
{
|
|
css::uno::Reference< css::ucb::XContent > xContent = getUnpackedValueOrDefault(MediaDescriptor::PROP_UCBCONTENT, css::uno::Reference< css::ucb::XContent >());
|
|
if (xContent.is())
|
|
{
|
|
css::uno::Reference< css::ucb::XContentIdentifier > xId = xContent->getIdentifier();
|
|
OUString aScheme;
|
|
if (xId.is())
|
|
aScheme = xId->getContentProviderScheme();
|
|
|
|
if (aScheme.equalsIgnoreAsciiCase("file"))
|
|
bReadOnly = true;
|
|
else
|
|
{
|
|
::ucbhelper::Content aContent(xContent,
|
|
utl::UCBContentHelper::getDefaultCommandEnvironment(),
|
|
comphelper::getProcessComponentContext());
|
|
aContent.getPropertyValue(u"IsReadOnly"_ustr) >>= bReadOnly;
|
|
}
|
|
}
|
|
}
|
|
catch(const css::uno::RuntimeException& )
|
|
{ throw; }
|
|
catch(const css::uno::Exception&)
|
|
{}
|
|
|
|
return bReadOnly;
|
|
}
|
|
|
|
css::uno::Any MediaDescriptor::getComponentDataEntry( const OUString& rName ) const
|
|
{
|
|
comphelper::SequenceAsHashMap::const_iterator aPropertyIter = find( PROP_COMPONENTDATA );
|
|
if( aPropertyIter != end() )
|
|
return comphelper::NamedValueCollection( aPropertyIter->second ).get( rName );
|
|
return css::uno::Any();
|
|
}
|
|
|
|
void MediaDescriptor::setComponentDataEntry( const OUString& rName, const css::uno::Any& rValue )
|
|
{
|
|
if( rValue.hasValue() )
|
|
{
|
|
// get or create the 'ComponentData' property entry
|
|
css::uno::Any& rCompDataAny = operator[]( PROP_COMPONENTDATA );
|
|
// insert the value (retain sequence type, create NamedValue elements by default)
|
|
bool bHasNamedValues = !rCompDataAny.hasValue() || rCompDataAny.has< css::uno::Sequence< css::beans::NamedValue > >();
|
|
bool bHasPropValues = rCompDataAny.has< css::uno::Sequence< css::beans::PropertyValue > >();
|
|
OSL_ENSURE( bHasNamedValues || bHasPropValues, "MediaDescriptor::setComponentDataEntry - incompatible 'ComponentData' property in media descriptor" );
|
|
if( bHasNamedValues || bHasPropValues )
|
|
{
|
|
// insert or overwrite the passed value
|
|
comphelper::SequenceAsHashMap aCompDataMap( rCompDataAny );
|
|
aCompDataMap[ rName ] = rValue;
|
|
// write back the sequence (restore sequence with correct element type)
|
|
rCompDataAny = aCompDataMap.getAsConstAny( bHasPropValues );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if an empty Any is passed, clear the entry
|
|
clearComponentDataEntry( rName );
|
|
}
|
|
}
|
|
|
|
void MediaDescriptor::clearComponentDataEntry( const OUString& rName )
|
|
{
|
|
comphelper::SequenceAsHashMap::iterator aPropertyIter = find( PROP_COMPONENTDATA );
|
|
if( aPropertyIter == end() )
|
|
return;
|
|
|
|
css::uno::Any& rCompDataAny = aPropertyIter->second;
|
|
bool bHasNamedValues = rCompDataAny.has< css::uno::Sequence< css::beans::NamedValue > >();
|
|
bool bHasPropValues = rCompDataAny.has< css::uno::Sequence< css::beans::PropertyValue > >();
|
|
OSL_ENSURE( bHasNamedValues || bHasPropValues, "MediaDescriptor::clearComponentDataEntry - incompatible 'ComponentData' property in media descriptor" );
|
|
if( bHasNamedValues || bHasPropValues )
|
|
{
|
|
// remove the value with the passed name
|
|
comphelper::SequenceAsHashMap aCompDataMap( rCompDataAny );
|
|
aCompDataMap.erase( rName );
|
|
// write back the sequence, or remove it completely if it is empty
|
|
if( aCompDataMap.empty() )
|
|
erase( aPropertyIter );
|
|
else
|
|
rCompDataAny = aCompDataMap.getAsConstAny( bHasPropValues );
|
|
}
|
|
}
|
|
|
|
css::uno::Sequence< css::beans::NamedValue > MediaDescriptor::requestAndVerifyDocPassword(
|
|
comphelper::IDocPasswordVerifier& rVerifier,
|
|
comphelper::DocPasswordRequestType eRequestType,
|
|
const ::std::vector< OUString >* pDefaultPasswords )
|
|
{
|
|
css::uno::Sequence< css::beans::NamedValue > aMediaEncData = getUnpackedValueOrDefault(
|
|
PROP_ENCRYPTIONDATA, css::uno::Sequence< css::beans::NamedValue >() );
|
|
OUString aMediaPassword = getUnpackedValueOrDefault(
|
|
PROP_PASSWORD, OUString() );
|
|
css::uno::Reference< css::task::XInteractionHandler > xInteractHandler = getUnpackedValueOrDefault(
|
|
PROP_INTERACTIONHANDLER, css::uno::Reference< css::task::XInteractionHandler >() );
|
|
OUString aDocumentName = getUnpackedValueOrDefault(
|
|
PROP_URL, OUString() );
|
|
|
|
bool bIsDefaultPassword = false;
|
|
css::uno::Sequence< css::beans::NamedValue > aEncryptionData = comphelper::DocPasswordHelper::requestAndVerifyDocPassword(
|
|
rVerifier, aMediaEncData, aMediaPassword, xInteractHandler, aDocumentName, eRequestType, pDefaultPasswords, &bIsDefaultPassword );
|
|
|
|
erase( PROP_PASSWORD );
|
|
erase( PROP_ENCRYPTIONDATA );
|
|
|
|
// insert encryption info into media descriptor
|
|
// TODO
|
|
if( aEncryptionData.hasElements() )
|
|
(*this)[ PROP_ENCRYPTIONDATA ] <<= aEncryptionData;
|
|
|
|
return aEncryptionData;
|
|
}
|
|
|
|
bool MediaDescriptor::addInputStream()
|
|
{
|
|
return impl_addInputStream( true );
|
|
}
|
|
|
|
/*-----------------------------------------------*/
|
|
bool MediaDescriptor::addInputStreamOwnLock()
|
|
{
|
|
const bool bLock = !comphelper::IsFuzzing()
|
|
&& officecfg::Office::Common::Misc::UseDocumentSystemFileLocking::get();
|
|
return impl_addInputStream(bLock);
|
|
}
|
|
|
|
/*-----------------------------------------------*/
|
|
bool MediaDescriptor::impl_addInputStream( bool bLockFile )
|
|
{
|
|
// check for an already existing stream item first
|
|
const_iterator pIt = find(MediaDescriptor::PROP_INPUTSTREAM);
|
|
if (pIt != end())
|
|
return true;
|
|
|
|
try
|
|
{
|
|
// No stream available - create a new one
|
|
// a) data comes as PostData ...
|
|
pIt = find(MediaDescriptor::PROP_POSTDATA);
|
|
if (pIt != end())
|
|
{
|
|
const css::uno::Any& rPostData = pIt->second;
|
|
css::uno::Reference< css::io::XInputStream > xPostData;
|
|
rPostData >>= xPostData;
|
|
|
|
return impl_openStreamWithPostData( xPostData );
|
|
}
|
|
|
|
// b) ... or we must get it from the given URL
|
|
OUString sURL = getUnpackedValueOrDefault(MediaDescriptor::PROP_URL, OUString());
|
|
if (sURL.isEmpty())
|
|
throw css::uno::Exception(u"Found no URL."_ustr,
|
|
css::uno::Reference< css::uno::XInterface >());
|
|
|
|
return impl_openStreamWithURL( removeFragment(sURL), bLockFile );
|
|
}
|
|
catch(const css::uno::Exception&)
|
|
{
|
|
TOOLS_WARN_EXCEPTION("unotools.misc", "invalid MediaDescriptor detected");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool MediaDescriptor::impl_openStreamWithPostData( const css::uno::Reference< css::io::XInputStream >& _rxPostData )
|
|
{
|
|
if ( !_rxPostData.is() )
|
|
throw css::lang::IllegalArgumentException(u"Found invalid PostData."_ustr,
|
|
css::uno::Reference< css::uno::XInterface >(), 1);
|
|
|
|
// PostData can't be used in read/write mode!
|
|
(*this)[MediaDescriptor::PROP_READONLY] <<= true;
|
|
|
|
// prepare the environment
|
|
css::uno::Reference< css::task::XInteractionHandler > xInteraction = getUnpackedValueOrDefault(
|
|
MediaDescriptor::PROP_INTERACTIONHANDLER,
|
|
css::uno::Reference< css::task::XInteractionHandler >());
|
|
css::uno::Reference< css::ucb::XProgressHandler > xProgress;
|
|
rtl::Reference<::ucbhelper::CommandEnvironment> xCommandEnv = new ::ucbhelper::CommandEnvironment(xInteraction, xProgress);
|
|
|
|
// media type
|
|
OUString sMediaType = getUnpackedValueOrDefault(MediaDescriptor::PROP_MEDIATYPE, OUString());
|
|
if (sMediaType.isEmpty())
|
|
{
|
|
sMediaType = "application/x-www-form-urlencoded";
|
|
(*this)[MediaDescriptor::PROP_MEDIATYPE] <<= sMediaType;
|
|
}
|
|
|
|
// url
|
|
OUString sURL( getUnpackedValueOrDefault( PROP_URL, OUString() ) );
|
|
|
|
css::uno::Reference< css::io::XInputStream > xResultStream;
|
|
try
|
|
{
|
|
// seek PostData stream to the beginning
|
|
css::uno::Reference< css::io::XSeekable > xSeek( _rxPostData, css::uno::UNO_QUERY );
|
|
if ( xSeek.is() )
|
|
xSeek->seek( 0 );
|
|
|
|
// a content for the URL
|
|
::ucbhelper::Content aContent( sURL, xCommandEnv, comphelper::getProcessComponentContext() );
|
|
|
|
// use post command
|
|
css::ucb::PostCommandArgument2 aPostArgument;
|
|
aPostArgument.Source = _rxPostData;
|
|
css::uno::Reference< css::io::XActiveDataSink > xSink( new ucbhelper::ActiveDataSink );
|
|
aPostArgument.Sink = xSink;
|
|
aPostArgument.MediaType = sMediaType;
|
|
aPostArgument.Referer = getUnpackedValueOrDefault( PROP_REFERRER, OUString() );
|
|
|
|
aContent.executeCommand( u"post"_ustr, css::uno::Any( aPostArgument ) );
|
|
|
|
// get result
|
|
xResultStream = xSink->getInputStream();
|
|
}
|
|
catch( const css::uno::Exception& )
|
|
{
|
|
}
|
|
|
|
// success?
|
|
if ( !xResultStream.is() )
|
|
{
|
|
OSL_FAIL( "no valid reply to the HTTP-Post" );
|
|
return false;
|
|
}
|
|
|
|
(*this)[MediaDescriptor::PROP_INPUTSTREAM] <<= xResultStream;
|
|
return true;
|
|
}
|
|
|
|
/*-----------------------------------------------*/
|
|
bool MediaDescriptor::impl_openStreamWithURL( const OUString& sURL, bool bLockFile )
|
|
{
|
|
if (sURL.matchIgnoreAsciiCase(".component:") || sURL.matchIgnoreAsciiCase("private:factory/"))
|
|
return false; // No UCB content for .component URLs and factory URLs
|
|
|
|
OUString referer(getUnpackedValueOrDefault(PROP_REFERRER, OUString()));
|
|
if (SvtSecurityOptions::isUntrustedReferer(referer)) {
|
|
return false;
|
|
}
|
|
|
|
// prepare the environment
|
|
css::uno::Reference< css::task::XInteractionHandler > xOrgInteraction = getUnpackedValueOrDefault(
|
|
MediaDescriptor::PROP_INTERACTIONHANDLER,
|
|
css::uno::Reference< css::task::XInteractionHandler >());
|
|
|
|
css::uno::Reference< css::task::XInteractionHandler > xAuthenticationInteraction = getUnpackedValueOrDefault(
|
|
MediaDescriptor::PROP_AUTHENTICATIONHANDLER,
|
|
css::uno::Reference< css::task::XInteractionHandler >());
|
|
|
|
rtl::Reference<comphelper::StillReadWriteInteraction> xInteraction = new comphelper::StillReadWriteInteraction(xOrgInteraction,xAuthenticationInteraction);
|
|
|
|
css::uno::Reference< css::ucb::XProgressHandler > xProgress;
|
|
rtl::Reference<::ucbhelper::CommandEnvironment> xCommandEnv = new ::ucbhelper::CommandEnvironment(xInteraction, xProgress);
|
|
|
|
// try to create the content
|
|
// no content -> no stream => return immediately with FALSE
|
|
::ucbhelper::Content aContent;
|
|
css::uno::Reference< css::ucb::XContent > xContent;
|
|
try
|
|
{
|
|
aContent = ::ucbhelper::Content(sURL, xCommandEnv, comphelper::getProcessComponentContext());
|
|
xContent = aContent.get();
|
|
}
|
|
catch(const css::uno::RuntimeException&)
|
|
{ throw; }
|
|
catch(const css::ucb::ContentCreationException&)
|
|
{
|
|
TOOLS_WARN_EXCEPTION("unotools.misc", "url: '" << sURL << "'");
|
|
return false; // TODO error handling
|
|
}
|
|
catch(const css::uno::Exception&)
|
|
{
|
|
TOOLS_WARN_EXCEPTION("unotools.misc", "url: '" << sURL << "'");
|
|
return false; // TODO error handling
|
|
}
|
|
|
|
// try to open the file in read/write mode
|
|
// (if it's allowed to do so).
|
|
// But handle errors in a "hidden mode". Because
|
|
// we try it readonly later - if read/write is not an option.
|
|
css::uno::Reference< css::io::XStream > xStream;
|
|
css::uno::Reference< css::io::XInputStream > xInputStream;
|
|
|
|
bool bReadOnly = false;
|
|
bool bModeRequestedExplicitly = false;
|
|
const_iterator pIt = find(MediaDescriptor::PROP_READONLY);
|
|
if (pIt != end())
|
|
{
|
|
pIt->second >>= bReadOnly;
|
|
bModeRequestedExplicitly = true;
|
|
}
|
|
|
|
if ( !bReadOnly && bLockFile )
|
|
{
|
|
try
|
|
{
|
|
// TODO: use "special" still interaction to suppress error messages
|
|
xStream = aContent.openWriteableStream();
|
|
if (xStream.is())
|
|
xInputStream = xStream->getInputStream();
|
|
}
|
|
catch(const css::uno::RuntimeException&)
|
|
{ throw; }
|
|
catch(const css::uno::Exception&)
|
|
{
|
|
css::uno::Any ex( cppu::getCaughtException() );
|
|
// ignore exception, if reason was problem reasoned on
|
|
// open it in WRITABLE mode! Then we try it READONLY
|
|
// later a second time.
|
|
// All other errors must be handled as real error an
|
|
// break this method.
|
|
if (!xInteraction->wasWriteError() || bModeRequestedExplicitly)
|
|
{
|
|
SAL_WARN("unotools.misc","url: '" << sURL << "' " << exceptionToString(ex));
|
|
// If the protocol is webdav, then we need to treat the stream as readonly, even if the
|
|
// operation was requested as read/write explicitly (the WebDAV UCB implementation is monodirectional
|
|
// read or write not both at the same time).
|
|
if ( !INetURLObject( sURL ).isAnyKnownWebDAVScheme() )
|
|
return false;
|
|
}
|
|
xStream.clear();
|
|
xInputStream.clear();
|
|
}
|
|
}
|
|
|
|
// If opening of the stream in read/write mode was not allowed
|
|
// or failed by an error - we must try it in readonly mode.
|
|
if (!xInputStream.is())
|
|
{
|
|
OUString aScheme;
|
|
|
|
try
|
|
{
|
|
css::uno::Reference< css::ucb::XContentIdentifier > xContId(
|
|
aContent.get().is() ? aContent.get()->getIdentifier() : nullptr );
|
|
|
|
if ( xContId.is() )
|
|
aScheme = xContId->getContentProviderScheme();
|
|
|
|
// Only file system content provider is able to provide XStream
|
|
// so for this content impossibility to create XStream triggers
|
|
// switch to readonly mode in case of opening with locking on
|
|
if( bLockFile && aScheme.equalsIgnoreAsciiCase("file") )
|
|
bReadOnly = true;
|
|
else
|
|
{
|
|
bool bRequestReadOnly = bReadOnly;
|
|
aContent.getPropertyValue(u"IsReadOnly"_ustr) >>= bReadOnly;
|
|
if ( bReadOnly && !bRequestReadOnly && bModeRequestedExplicitly )
|
|
return false; // the document is explicitly requested with WRITABLE mode
|
|
}
|
|
}
|
|
catch(const css::uno::RuntimeException&)
|
|
{ throw; }
|
|
catch(const css::uno::Exception&)
|
|
{ /* no error handling if IsReadOnly property does not exist for UCP */ }
|
|
|
|
if ( bReadOnly )
|
|
(*this)[MediaDescriptor::PROP_READONLY] <<= bReadOnly;
|
|
|
|
xInteraction->resetInterceptions();
|
|
xInteraction->resetErrorStates();
|
|
try
|
|
{
|
|
// all the contents except file-URLs should be opened as usual
|
|
if ( bLockFile || !aScheme.equalsIgnoreAsciiCase("file") )
|
|
xInputStream = aContent.openStream();
|
|
else
|
|
xInputStream = aContent.openStreamNoLock();
|
|
}
|
|
catch(const css::uno::RuntimeException&)
|
|
{
|
|
throw;
|
|
}
|
|
catch(const css::uno::Exception&)
|
|
{
|
|
TOOLS_INFO_EXCEPTION("unotools.misc","url: '" << sURL << "'");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// add streams to the descriptor
|
|
if (xContent.is())
|
|
(*this)[MediaDescriptor::PROP_UCBCONTENT] <<= xContent;
|
|
if (xStream.is())
|
|
(*this)[MediaDescriptor::PROP_STREAM] <<= xStream;
|
|
if (xInputStream.is())
|
|
(*this)[MediaDescriptor::PROP_INPUTSTREAM] <<= xInputStream;
|
|
|
|
// At least we need an input stream. The r/w stream is optional ...
|
|
return xInputStream.is();
|
|
}
|
|
|
|
} // namespace comphelper
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|