/**************************************************************
*
* 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_unotools.hxx"
#include <unotools/ucblockbytes.hxx>
#include <comphelper/processfactory.hxx>
#include <salhelper/condition.hxx>
#ifndef _OSL_THREAD_HXX_
#include <osl/thread.hxx>
#endif
#include <tools/urlobj.hxx>
#include <ucbhelper/interactionrequest.hxx>
#include <com/sun/star/task/XInteractionAbort.hpp>
#include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp>
#include <com/sun/star/ucb/CommandFailedException.hpp>
#include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
#ifndef _COM_SUN_STAR_UCB_INTERACTIVEIODEXCEPTION_HPP_
#include <com/sun/star/ucb/InteractiveIOException.hpp>
#endif
#include <com/sun/star/io/XActiveDataStreamer.hpp>
#include <com/sun/star/ucb/DocumentHeaderField.hpp>
#include <com/sun/star/ucb/XCommandInfo.hpp>
#include <com/sun/star/ucb/XCommandProcessor.hpp>
#include <com/sun/star/task/XInteractionHandler.hpp>
#include <com/sun/star/ucb/OpenCommandArgument2.hpp>
#include <com/sun/star/ucb/PostCommandArgument2.hpp>
#include <com/sun/star/ucb/OpenMode.hpp>
#include <com/sun/star/beans/Property.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/XPropertiesChangeNotifier.hpp>
#include <com/sun/star/beans/XPropertiesChangeListener.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/io/XActiveDataSink.hpp>
#include <com/sun/star/io/XActiveDataControl.hpp>
#include <com/sun/star/io/XSeekable.hpp>
#include <cppuhelper/implbase1.hxx>
#include <cppuhelper/implbase2.hxx>
#include <tools/inetmsg.hxx>
#include <com/sun/star/io/XTruncate.hpp>
#include <com/sun/star/lang/IllegalArgumentException.hpp>
#include <comphelper/storagehelper.hxx>
#include <ucbhelper/contentbroker.hxx>
#include <ucbhelper/content.hxx>
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::io;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::ucb;
using namespace ::com::sun::star::task;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
namespace utl
{
/**
Helper class for getting a XInputStream when opening a content
*/
class UcbDataSink_Impl : public ::cppu::WeakImplHelper2< XActiveDataControl, XActiveDataSink >
{
UcbLockBytesRef m_xLockBytes;
public:
UcbDataSink_Impl( UcbLockBytes* pLockBytes )
: m_xLockBytes( pLockBytes )
{}
SvLockBytes* getLockBytes (void)
{ return m_xLockBytes; }
// XActiveDataControl.
virtual void SAL_CALL addListener ( const Reference<XStreamListener> &/*rxListener*/) throw(RuntimeException) {}
virtual void SAL_CALL removeListener ( const Reference<XStreamListener> &/*rxListener*/) throw(RuntimeException) {}
virtual void SAL_CALL start (void) throw(RuntimeException) {}
virtual void SAL_CALL terminate (void) throw(RuntimeException)
{ m_xLockBytes->terminate_Impl(); }
// XActiveDataSink.
virtual void SAL_CALL setInputStream ( const Reference<XInputStream> &rxInputStream) throw(RuntimeException)
{ m_xLockBytes->setInputStream_Impl (rxInputStream); }
virtual Reference<XInputStream> SAL_CALL getInputStream (void) throw(RuntimeException)
{ return m_xLockBytes->getInputStream_Impl(); }
};
/**
Helper class for getting a XStream when opening a content
*/
class UcbStreamer_Impl : public ::cppu::WeakImplHelper2< XActiveDataStreamer, XActiveDataControl >
{
Reference < XStream > m_xStream;
UcbLockBytesRef m_xLockBytes;
public:
UcbStreamer_Impl( UcbLockBytes* pLockBytes )
: m_xLockBytes( pLockBytes )
{}
// XActiveDataControl.
virtual void SAL_CALL addListener ( const Reference<XStreamListener> &/*rxListener*/) throw(RuntimeException) {}
virtual void SAL_CALL removeListener ( const Reference<XStreamListener> &/*rxListener*/) throw(RuntimeException) {}
virtual void SAL_CALL start (void) throw(RuntimeException) {}
virtual void SAL_CALL terminate (void) throw(RuntimeException)
{ m_xLockBytes->terminate_Impl(); }
// XActiveDataStreamer
virtual void SAL_CALL setStream( const Reference< XStream >& aStream ) throw(RuntimeException)
{ m_xStream = aStream; m_xLockBytes->setStream_Impl( aStream ); }
virtual Reference< XStream > SAL_CALL getStream() throw(RuntimeException)
{ return m_xStream; }
};
/**
Helper class for progress handling while executing UCB commands
*/
class ProgressHandler_Impl: public ::cppu::WeakImplHelper1< XProgressHandler >
{
Link m_aProgress;
public:
ProgressHandler_Impl( const Link& rLink )
: m_aProgress( rLink )
{}
// XProgressHandler
virtual void SAL_CALL push(const Any & /*rStatus*/) throw (RuntimeException) {}
virtual void SAL_CALL pop() throw (RuntimeException) {}
virtual void SAL_CALL update(const Any & /*rStatus*/) throw (RuntimeException)
{ if ( m_aProgress.IsSet() ) m_aProgress.Call( 0 ); }
};
/**
Helper class for managing interactions and progress when executing UCB commands
*/
class UcbTaskEnvironment : public ::cppu::WeakImplHelper1< XCommandEnvironment >
{
Reference< XInteractionHandler > m_xInteractionHandler;
Reference< XProgressHandler > m_xProgressHandler;
public:
UcbTaskEnvironment( const Reference< XInteractionHandler>& rxInteractionHandler,
const Reference< XProgressHandler>& rxProgressHandler )
: m_xInteractionHandler( rxInteractionHandler )
, m_xProgressHandler( rxProgressHandler )
{}
virtual Reference<XInteractionHandler> SAL_CALL getInteractionHandler() throw (RuntimeException)
{ return m_xInteractionHandler; }
virtual Reference<XProgressHandler> SAL_CALL getProgressHandler() throw (RuntimeException)
{ return m_xProgressHandler; }
};
/**
Helper class for property change notifies when executing UCB commands
*/
class UcbPropertiesChangeListener_Impl : public ::cppu::WeakImplHelper1< XPropertiesChangeListener >
{
public:
UcbLockBytesRef m_xLockBytes;
UcbPropertiesChangeListener_Impl( UcbLockBytesRef rRef )
: m_xLockBytes( rRef )
{}
virtual void SAL_CALL disposing ( const EventObject &/*rEvent*/) throw(RuntimeException) {}
virtual void SAL_CALL propertiesChange ( const Sequence<PropertyChangeEvent> &rEvent) throw(RuntimeException);
};
void SAL_CALL UcbPropertiesChangeListener_Impl::propertiesChange ( const Sequence<PropertyChangeEvent> &rEvent) throw(RuntimeException)
{
sal_Int32 i, n = rEvent.getLength();
for (i = 0; i < n; i++)
{
PropertyChangeEvent evt (rEvent[i]);
if (evt.PropertyName == ::rtl::OUString::createFromAscii ("DocumentHeader"))
{
Sequence<DocumentHeaderField> aHead;
if (evt.NewValue >>= aHead)
{
sal_Int32 k, m = aHead.getLength();
for (k = 0; k < m; k++)
{
String aName( aHead[k].Name );
String aValue( aHead[k].Value );
if (aName.CompareIgnoreCaseToAscii("Expires") == COMPARE_EQUAL)
{
DateTime aExpires (0, 0);
if (INetRFC822Message::ParseDateField (aValue, aExpires))
{
aExpires.ConvertToLocalTime();
m_xLockBytes->SetExpireDate_Impl( aExpires );
}
}
}
}
m_xLockBytes->SetStreamValid_Impl();
}
else if (evt.PropertyName == rtl::OUString::createFromAscii ("PresentationURL"))
{
::rtl::OUString aUrl;
if (evt.NewValue >>= aUrl)
{
::rtl::OUString aBad (::rtl::OUString::createFromAscii ("private:"));
if (!(aUrl.compareTo (aBad, aBad.getLength()) == 0))
{
// URL changed (Redirection).
m_xLockBytes->SetRealURL_Impl( aUrl );
}
}
}
else if (evt.PropertyName == ::rtl::OUString::createFromAscii ("MediaType"))
{
::rtl::OUString aContentType;
if (evt.NewValue >>= aContentType)
m_xLockBytes->SetContentType_Impl( aContentType );
}
}
}
class Moderator
: public osl::Thread
{
// usage restriction:
// It might be possible, that the call to the interactionhandler and/or
// progresshandler is done asynchrounsly, while the 'execute' simply
// returns. This would imply that these class must be refcounted !!!
public:
Moderator(
Reference < XContent >& xContent,
Reference < XInteractionHandler >& xInteract,
Reference < XProgressHandler >& xProgress,
const Command& rArg
)
throw(
ContentCreationException,
RuntimeException
);
~Moderator();
enum ResultType {
NORESULT,
INTERACTIONREQUEST, // reply expected
PROGRESSPUSH,
PROGRESSUPDATE,
PROGRESSPOP,
INPUTSTREAM,
STREAM,
RESULT,
TIMEDOUT,
COMMANDABORTED,
COMMANDFAILED,
INTERACTIVEIO,
UNSUPPORTED,
GENERAL
};
class ConditionRes
: public salhelper::Condition
{
public:
ConditionRes(osl::Mutex& aMutex,Moderator& aModerator)
: salhelper::Condition(aMutex),
m_aModerator(aModerator)
{
}
protected:
bool applies() const {
return m_aModerator.m_aResultType != NORESULT;
}
private:
Moderator& m_aModerator;
};
struct Result {
ResultType type;
Any result;
sal_Int32 ioErrorCode;
};
Result getResult(const sal_uInt32 milliSec);
enum ReplyType {
NOREPLY,
EXIT,
RETRY,
REQUESTHANDLED
};
class ConditionRep
: public salhelper::Condition
{
public:
ConditionRep(osl::Mutex& aMutex,Moderator& aModerator)
: salhelper::Condition(aMutex),
m_aModerator(aModerator)
{
}
protected:
bool applies() const {
return m_aModerator.m_aReplyType != NOREPLY;
}
private:
Moderator& m_aModerator;
};
void setReply(ReplyType);
void handle( const Reference<XInteractionRequest >& Request );
void push( const Any& Status );
void update( const Any& Status );
void pop( );
void setStream(const Reference< XStream >& aStream);
void setInputStream(const Reference<XInputStream> &rxInputStream);
protected:
virtual void SAL_CALL run();
virtual void SAL_CALL onTerminated();
private:
osl::Mutex m_aMutex;
friend class ConditionRes;
ConditionRes m_aRes;
ResultType m_aResultType;
sal_Int32 m_nIOErrorCode;
Any m_aResult;
friend class ConditionRep;
ConditionRep m_aRep;
ReplyType m_aReplyType;
Command m_aArg;
::ucbhelper::Content m_aContent;
};
class ModeratorsActiveDataStreamer
: public ::cppu::WeakImplHelper1<XActiveDataStreamer>
{
public:
ModeratorsActiveDataStreamer(Moderator &theModerator);
~ModeratorsActiveDataStreamer();
// XActiveDataStreamer
virtual void SAL_CALL
setStream(
const Reference< XStream >& aStream
)
throw(
RuntimeException
);
virtual Reference<XStream> SAL_CALL
getStream (
void
) throw(
RuntimeException
)
{
osl::MutexGuard aGuard(m_aMutex);
return m_xStream;
}
private:
Moderator& m_aModerator;
osl::Mutex m_aMutex;
Reference<XStream> m_xStream;
};
class ModeratorsActiveDataSink
: public ::cppu::WeakImplHelper1<XActiveDataSink>
{
public:
ModeratorsActiveDataSink(Moderator &theModerator);
~ModeratorsActiveDataSink();
// XActiveDataSink.
virtual void SAL_CALL
setInputStream (
const Reference<XInputStream> &rxInputStream
)
throw(
RuntimeException
);
virtual Reference<XInputStream> SAL_CALL
getInputStream (
void
) throw(
RuntimeException
)
{
osl::MutexGuard aGuard(m_aMutex);
return m_xStream;
}
private:
Moderator& m_aModerator;
osl::Mutex m_aMutex;
Reference<XInputStream> m_xStream;
};
ModeratorsActiveDataSink::ModeratorsActiveDataSink(Moderator &theModerator)
: m_aModerator(theModerator)
{
}
ModeratorsActiveDataSink::~ModeratorsActiveDataSink()
{
}
// XActiveDataSink.
void SAL_CALL
ModeratorsActiveDataSink::setInputStream (
const Reference<XInputStream> &rxInputStream
)
throw(
RuntimeException
)
{
m_aModerator.setInputStream(rxInputStream);
osl::MutexGuard aGuard(m_aMutex);
m_xStream = rxInputStream;
}
ModeratorsActiveDataStreamer::ModeratorsActiveDataStreamer(
Moderator &theModerator
)
: m_aModerator(theModerator)
{
}
ModeratorsActiveDataStreamer::~ModeratorsActiveDataStreamer()
{
}
// XActiveDataStreamer.
void SAL_CALL
ModeratorsActiveDataStreamer::setStream (
const Reference<XStream> &rxStream
)
throw(
RuntimeException
)
{
m_aModerator.setStream(rxStream);
osl::MutexGuard aGuard(m_aMutex);
m_xStream = rxStream;
}
class ModeratorsInteractionHandler
: public ::cppu::WeakImplHelper1<XInteractionHandler>
{
public:
ModeratorsInteractionHandler(Moderator &theModerator);
~ModeratorsInteractionHandler();
virtual void SAL_CALL
handle( const Reference<XInteractionRequest >& Request )
throw (RuntimeException);
private:
Moderator& m_aModerator;
};
class ModeratorsProgressHandler
: public ::cppu::WeakImplHelper1<XProgressHandler>
{
public:
ModeratorsProgressHandler(Moderator &theModerator);
~ModeratorsProgressHandler();
virtual void SAL_CALL push( const Any& Status )
throw (
RuntimeException);
virtual void SAL_CALL update( const Any& Status )
throw (RuntimeException);
virtual void SAL_CALL pop( )
throw (RuntimeException);
private:
Moderator& m_aModerator;
};
ModeratorsProgressHandler::ModeratorsProgressHandler(Moderator &theModerator)
: m_aModerator(theModerator)
{
}
ModeratorsProgressHandler::~ModeratorsProgressHandler()
{
}
void SAL_CALL ModeratorsProgressHandler::push( const Any& Status )
throw (
RuntimeException)
{
m_aModerator.push(Status);
}
void SAL_CALL ModeratorsProgressHandler::update( const Any& Status )
throw (RuntimeException)
{
m_aModerator.update(Status);
}
void SAL_CALL ModeratorsProgressHandler::pop( )
throw (RuntimeException)
{
m_aModerator.pop();
}
ModeratorsInteractionHandler::ModeratorsInteractionHandler(
Moderator &aModerator)
: m_aModerator(aModerator)
{
}
ModeratorsInteractionHandler::~ModeratorsInteractionHandler()
{
}
void SAL_CALL
ModeratorsInteractionHandler::handle(
const Reference<XInteractionRequest >& Request
)
throw (
RuntimeException
)
{
// wakes up the mainthread
m_aModerator.handle(Request);
}
Moderator::Moderator(
Reference < XContent >& xContent,
Reference < XInteractionHandler >& xInteract,
Reference < XProgressHandler >& xProgress,
const Command& rArg
)
throw(
::com::sun::star::ucb::ContentCreationException,
::com::sun::star::uno::RuntimeException
)
: m_aMutex(),
m_aRes(m_aMutex,*this),
m_aResultType(NORESULT),
m_nIOErrorCode(0),
m_aResult(),
m_aRep(m_aMutex,*this),
m_aReplyType(NOREPLY),
m_aArg(rArg),
m_aContent(
xContent,
new UcbTaskEnvironment(
xInteract.is() ? new ModeratorsInteractionHandler(*this) : 0,
xProgress.is() ? new ModeratorsProgressHandler(*this) : 0
))
{
// now exchange the whole data sink stuff
// with a thread safe version
Reference<XInterface> *pxSink = NULL;
PostCommandArgument2 aPostArg;
OpenCommandArgument2 aOpenArg;
int dec(2);
if(m_aArg.Argument >>= aPostArg) {
pxSink = &aPostArg.Sink;
dec = 0;
}
else if(m_aArg.Argument >>= aOpenArg) {
pxSink = &aOpenArg.Sink;
dec = 1;
}
if(dec ==2)
throw ContentCreationException();
Reference < XActiveDataSink > xActiveSink(*pxSink,UNO_QUERY);
if(xActiveSink.is())
*pxSink = Reference<XInterface>(
(cppu::OWeakObject*)new ModeratorsActiveDataSink(*this));
Reference<XActiveDataStreamer> xStreamer( *pxSink, UNO_QUERY );
if ( xStreamer.is() )
*pxSink = Reference<XInterface>(
(cppu::OWeakObject*)new ModeratorsActiveDataStreamer(*this));
if(dec == 0)
m_aArg.Argument <<= aPostArg;
else if(dec == 1)
m_aArg.Argument <<= aOpenArg;
}
Moderator::~Moderator()
{
}
Moderator::Result Moderator::getResult(const sal_uInt32 milliSec)
{
Result ret;
try {
salhelper::ConditionWaiter aWaiter(m_aRes,milliSec);
ret.type = m_aResultType;
ret.result = m_aResult;
ret.ioErrorCode = m_nIOErrorCode;
// reset
m_aResultType = NORESULT;
}
catch(const salhelper::ConditionWaiter::timedout&)
{
ret.type = TIMEDOUT;
}
return ret;
}
void Moderator::setReply(ReplyType aReplyType )
{
salhelper::ConditionModifier aMod(m_aRep);
m_aReplyType = aReplyType;
}
void Moderator::handle( const Reference<XInteractionRequest >& Request )
{
ReplyType aReplyType;
do {
{
salhelper::ConditionModifier aMod(m_aRes);
m_aResultType = INTERACTIONREQUEST;
m_aResult <<= Request;
}
{
salhelper::ConditionWaiter aWait(m_aRep);
aReplyType = m_aReplyType;
// reset
m_aReplyType = NOREPLY;
}
if(aReplyType == EXIT) {
Sequence<Reference<XInteractionContinuation> > aSeq(
Request->getContinuations());
for(sal_Int32 i = 0; i < aSeq.getLength(); ++i) {
Reference<XInteractionAbort> aRef(aSeq[i],UNO_QUERY);
if(aRef.is()) {
aRef->select();
}
}
// resignal the exitcondition
setReply(EXIT);
break;
}
} while(aReplyType != REQUESTHANDLED);
}
void Moderator::push( const Any& Status )
{
{
salhelper::ConditionModifier aMod(m_aRes);
m_aResultType = PROGRESSPUSH;
m_aResult = Status;
}
ReplyType aReplyType;
{
salhelper::ConditionWaiter aWait(m_aRep);
aReplyType = m_aReplyType;
m_aReplyType = NOREPLY;
}
if(aReplyType == EXIT)
setReply(EXIT);
}
void Moderator::update( const Any& Status )
{
{
salhelper::ConditionModifier aMod(m_aRes);
m_aResultType = PROGRESSUPDATE;
m_aResult = Status;
}
ReplyType aReplyType;
{
salhelper::ConditionWaiter aWait(m_aRep);
aReplyType = m_aReplyType;
m_aReplyType = NOREPLY;
}
if(aReplyType == EXIT)
setReply(EXIT);
}
void Moderator::pop( )
{
{
salhelper::ConditionModifier aMod(m_aRes);
m_aResultType = PROGRESSPOP;
}
ReplyType aReplyType;
{
salhelper::ConditionWaiter aWait(m_aRep);
aReplyType = m_aReplyType;
m_aReplyType = NOREPLY;
}
if(aReplyType == EXIT)
setReply(EXIT);
}
void Moderator::setStream(const Reference< XStream >& aStream)
{
{
salhelper::ConditionModifier aMod(m_aRes);
m_aResultType = STREAM;
m_aResult <<= aStream;
}
ReplyType aReplyType;
{
salhelper::ConditionWaiter aWait(m_aRep);
aReplyType = m_aReplyType;
m_aReplyType = NOREPLY;
}
if(aReplyType == EXIT)
setReply(EXIT);
}
void Moderator::setInputStream(const Reference<XInputStream> &rxInputStream)
{
{
salhelper::ConditionModifier aMod(m_aRes);
m_aResultType = INPUTSTREAM;
m_aResult <<= rxInputStream;
}
ReplyType aReplyType;
{
salhelper::ConditionWaiter aWait(m_aRep);
aReplyType = m_aReplyType;
m_aReplyType = NOREPLY;
}
if(aReplyType == EXIT)
setReply(EXIT);
}
void SAL_CALL Moderator::run()
{
ResultType aResultType;
Any aResult;
sal_Int32 nIOErrorCode = 0;
try
{
aResult = m_aContent.executeCommand(m_aArg.Name,m_aArg.Argument);
aResultType = RESULT;
}
catch ( CommandAbortedException )
{
aResultType = COMMANDABORTED;
}
catch ( CommandFailedException )
{
aResultType = COMMANDFAILED;
}
catch ( InteractiveIOException& r )
{
nIOErrorCode = r.Code;
aResultType = INTERACTIVEIO;
}
catch ( UnsupportedDataSinkException& )
{
aResultType = UNSUPPORTED;
}
catch ( Exception )
{
aResultType = GENERAL;
}
{
salhelper::ConditionModifier aMod(m_aRes);
m_aResultType = aResultType;
m_aResult = aResult;
m_nIOErrorCode = nIOErrorCode;
}
}
void SAL_CALL Moderator::onTerminated()
{
{
salhelper::ConditionWaiter aWaiter(m_aRep);
}
delete this;
}
/**
Function for opening UCB contents synchronously,
but with handled timeout;
*/
static sal_Bool _UCBOpenContentSync(
UcbLockBytesRef xLockBytes,
Reference < XContent > xContent,
const Command& rArg,
Reference < XInterface > xSink,
Reference < XInteractionHandler > xInteract,
Reference < XProgressHandler > xProgress,
UcbLockBytesHandlerRef xHandler );
static sal_Bool UCBOpenContentSync(
UcbLockBytesRef xLockBytes,
Reference < XContent > xContent,
const Command& rArg,
Reference < XInterface > xSink,
Reference < XInteractionHandler > xInteract,
Reference < XProgressHandler > xProgress,
UcbLockBytesHandlerRef xHandler )
{
// http protocol must be handled in a special way:
// during the opening process the input stream may change
// only the last inputstream after notifying the document
// headers is valid
Reference<XContentIdentifier> xContId(
xContent.is() ? xContent->getIdentifier() : 0 );
rtl::OUString aScheme;
if(xContId.is())
aScheme = xContId->getContentProviderScheme();
// now determine wether we use a timeout or not;
if( ! aScheme.equalsIgnoreAsciiCaseAscii("http") &&
! aScheme.equalsIgnoreAsciiCaseAscii("https") &&
! aScheme.equalsIgnoreAsciiCaseAscii("vnd.sun.star.webdav") &&
! aScheme.equalsIgnoreAsciiCaseAscii("ftp"))
return _UCBOpenContentSync(
xLockBytes,xContent,rArg,xSink,xInteract,xProgress,xHandler);
if ( (aScheme.compareToAscii( "http" ) != COMPARE_EQUAL) ||
(aScheme.compareToAscii( "https" ) != COMPARE_EQUAL) )
xLockBytes->SetStreamValid_Impl();
Reference< XPropertiesChangeListener > xListener;
Reference< XPropertiesChangeNotifier > xProps(xContent,UNO_QUERY);
if(xProps.is()) {
xListener =
new UcbPropertiesChangeListener_Impl(xLockBytes);
xProps->addPropertiesChangeListener(
Sequence< ::rtl::OUString >(),
xListener);
}
Any aResult;
bool bException(false);
bool bAborted(false);
bool bResultAchieved(false);
Moderator* pMod = 0;
try {
pMod = new Moderator(xContent,xInteract,xProgress,rArg);
pMod->create();
} catch(const ContentCreationException&) {
bResultAchieved = bException = true;
xLockBytes->SetError( ERRCODE_IO_GENERAL );
}
sal_uInt32 nTimeout(5000); // initially 5000 milliSec
while(!bResultAchieved) {
Moderator::Result res;
// try to get the result for with timeout
res = pMod->getResult(nTimeout);
switch(res.type) {
case Moderator::PROGRESSPUSH:
{
if(xProgress.is())
xProgress->push(res.result);
pMod->setReply(Moderator::REQUESTHANDLED);
break;
}
case Moderator::PROGRESSUPDATE:
{
if(xProgress.is())
xProgress->update(res.result);
pMod->setReply(Moderator::REQUESTHANDLED);
break;
}
case Moderator::PROGRESSPOP:
{
if(xProgress.is())
xProgress->pop();
pMod->setReply(Moderator::REQUESTHANDLED);
break;
}
case Moderator::STREAM:
{
Reference<XStream> result;
if(res.result >>= result) {
Reference < XActiveDataStreamer > xStreamer(
xSink, UNO_QUERY
);
if(xStreamer.is())
xStreamer->setStream(result);
}
pMod->setReply(Moderator::REQUESTHANDLED);
break;
}
case Moderator::INPUTSTREAM:
{
Reference<XInputStream> result;
res.result >>= result;
Reference < XActiveDataSink > xActiveSink(
xSink, UNO_QUERY
);
if(xActiveSink.is())
xActiveSink->setInputStream(result);
pMod->setReply(Moderator::REQUESTHANDLED);
break;
}
case Moderator::TIMEDOUT:
{
Reference<XInteractionRetry> xRet;
if(xInteract.is()) {
InteractiveNetworkConnectException aExcep;
INetURLObject aURL(
xContId.is() ?
xContId->getContentIdentifier() :
rtl::OUString() );
aExcep.Server = aURL.GetHost();
aExcep.Classification = InteractionClassification_ERROR;
aExcep.Message =
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"server not responding after five seconds"));
Any request;
request <<= aExcep;
ucbhelper::InteractionRequest *ir =
new ucbhelper::InteractionRequest(request);
Reference<XInteractionRequest> xIR(ir);
Sequence<Reference<XInteractionContinuation> > aSeq(2);
ucbhelper::InteractionRetry *retryP =
new ucbhelper::InteractionRetry(ir);
aSeq[0] = retryP;
ucbhelper::InteractionAbort *abortP =
new ucbhelper::InteractionAbort(ir);
aSeq[1] = abortP;
ir->setContinuations(aSeq);
xInteract->handle(xIR);
rtl::Reference< ucbhelper::InteractionContinuation > ref
= ir->getSelection();
if(ref.is()) {
Reference<XInterface> xInt(ref.get());
xRet = Reference<XInteractionRetry>(xInt,UNO_QUERY);
}
}
if(!xRet.is()) {
bAborted = true;
xLockBytes->SetError(ERRCODE_ABORT);
}
break;
}
case Moderator::INTERACTIONREQUEST:
{
Reference<XInteractionRequest> Request;
res.result >>= Request;
xInteract->handle(Request);
pMod->setReply(Moderator::REQUESTHANDLED);
break;
}
case Moderator::RESULT:
{
bResultAchieved = true;
aResult = res.result;
break;
}
case Moderator::COMMANDABORTED:
{
bAborted = true;
xLockBytes->SetError( ERRCODE_ABORT );
break;
}
case Moderator::COMMANDFAILED:
{
bAborted = true;
xLockBytes->SetError( ERRCODE_ABORT );
break;
}
case Moderator::INTERACTIVEIO:
{
bException = true;
if ( res.ioErrorCode == IOErrorCode_ACCESS_DENIED ||
res.ioErrorCode == IOErrorCode_LOCKING_VIOLATION )
xLockBytes->SetError( ERRCODE_IO_ACCESSDENIED );
else if ( res.ioErrorCode == IOErrorCode_NOT_EXISTING )
xLockBytes->SetError( ERRCODE_IO_NOTEXISTS );
else if ( res.ioErrorCode == IOErrorCode_CANT_READ )
xLockBytes->SetError( ERRCODE_IO_CANTREAD );
else
xLockBytes->SetError( ERRCODE_IO_GENERAL );
break;
}
case Moderator::UNSUPPORTED:
{
bException = true;
xLockBytes->SetError( ERRCODE_IO_NOTSUPPORTED );
break;
}
default:
{
bException = true;
xLockBytes->SetError( ERRCODE_IO_GENERAL );
break;
}
}
bResultAchieved |= bException;
bResultAchieved |= bAborted;
if(nTimeout == 5000) nTimeout *= 2;
}
if(pMod) pMod->setReply(Moderator::EXIT);
if ( bAborted || bException )
{
if( xHandler.Is() )
xHandler->Handle( UcbLockBytesHandler::CANCEL, xLockBytes );
Reference < XActiveDataSink > xActiveSink( xSink, UNO_QUERY );
if ( xActiveSink.is() )
xActiveSink->setInputStream( Reference < XInputStream >() );
Reference < XActiveDataStreamer > xStreamer( xSink, UNO_QUERY );
if ( xStreamer.is() )
xStreamer->setStream( Reference < XStream >() );
}
Reference < XActiveDataControl > xControl( xSink, UNO_QUERY );
if ( xControl.is() )
xControl->terminate();
if ( xProps.is() )
xProps->removePropertiesChangeListener(
Sequence< ::rtl::OUString >(),
xListener );
return ( bAborted || bException );
}
/**
Function for opening UCB contents synchronously
*/
static sal_Bool _UCBOpenContentSync(
UcbLockBytesRef xLockBytes,
Reference < XContent > xContent,
const Command& rArg,
Reference < XInterface > xSink,
Reference < XInteractionHandler > xInteract,
Reference < XProgressHandler > xProgress,
UcbLockBytesHandlerRef xHandler )
{
::ucbhelper::Content aContent( xContent, new UcbTaskEnvironment( xInteract, xProgress ) );
Reference < XContentIdentifier > xIdent = xContent->getIdentifier();
::rtl::OUString aScheme = xIdent->getContentProviderScheme();
// http protocol must be handled in a special way: during the opening process the input stream may change
// only the last inputstream after notifying the document headers is valid
if ( aScheme.compareToAscii("http") != COMPARE_EQUAL )
xLockBytes->SetStreamValid_Impl();
Reference< XPropertiesChangeListener > xListener = new UcbPropertiesChangeListener_Impl( xLockBytes );
Reference< XPropertiesChangeNotifier > xProps ( xContent, UNO_QUERY );
if ( xProps.is() )
xProps->addPropertiesChangeListener( Sequence< ::rtl::OUString >(), xListener );
Any aResult;
bool bException = false;
bool bAborted = false;
try
{
aResult = aContent.executeCommand( rArg.Name, rArg.Argument );
}
catch ( CommandAbortedException )
{
bAborted = true;
xLockBytes->SetError( ERRCODE_ABORT );
}
catch ( CommandFailedException )
{
bAborted = true;
xLockBytes->SetError( ERRCODE_ABORT );
}
catch ( InteractiveIOException& r )
{
bException = true;
if ( r.Code == IOErrorCode_ACCESS_DENIED || r.Code == IOErrorCode_LOCKING_VIOLATION )
xLockBytes->SetError( ERRCODE_IO_ACCESSDENIED );
else if ( r.Code == IOErrorCode_NOT_EXISTING )
xLockBytes->SetError( ERRCODE_IO_NOTEXISTS );
else if ( r.Code == IOErrorCode_CANT_READ )
xLockBytes->SetError( ERRCODE_IO_CANTREAD );
else
xLockBytes->SetError( ERRCODE_IO_GENERAL );
}
catch ( UnsupportedDataSinkException& )
{
bException = true;
xLockBytes->SetError( ERRCODE_IO_NOTSUPPORTED );
}
catch ( Exception )
{
bException = true;
xLockBytes->SetError( ERRCODE_IO_GENERAL );
}
if ( bAborted || bException )
{
if( xHandler.Is() )
xHandler->Handle( UcbLockBytesHandler::CANCEL, xLockBytes );
Reference < XActiveDataSink > xActiveSink( xSink, UNO_QUERY );
if ( xActiveSink.is() )
xActiveSink->setInputStream( Reference < XInputStream >() );
Reference < XActiveDataStreamer > xStreamer( xSink, UNO_QUERY );
if ( xStreamer.is() )
xStreamer->setStream( Reference < XStream >() );
}
Reference < XActiveDataControl > xControl( xSink, UNO_QUERY );
if ( xControl.is() )
xControl->terminate();
if ( xProps.is() )
xProps->removePropertiesChangeListener( Sequence< ::rtl::OUString >(), xListener );
return ( bAborted || bException );
}
//----------------------------------------------------------------------------
UcbLockBytes::UcbLockBytes( UcbLockBytesHandler* pHandler )
: m_xInputStream (NULL)
, m_pCommandThread( NULL )
, m_xHandler( pHandler )
, m_nError( ERRCODE_NONE )
, m_bTerminated (sal_False)
, m_bDontClose( sal_False )
, m_bStreamValid (sal_False)
{
SetSynchronMode( sal_True );
}
//----------------------------------------------------------------------------
UcbLockBytes::~UcbLockBytes()
{
if ( !m_bDontClose )
{
if ( m_xInputStream.is() )
{
try
{
m_xInputStream->closeInput();
}
catch ( RuntimeException const & )
{}
catch ( IOException const & )
{}
}
}
if ( !m_xInputStream.is() && m_xOutputStream.is() )
{
try
{
m_xOutputStream->closeOutput();
}
catch ( RuntimeException const & )
{}
catch ( IOException const & )
{}
}
}
Reference < XInputStream > UcbLockBytes::getInputStream()
{
vos::OClearableGuard aGuard( m_aMutex );
m_bDontClose = sal_True;
return m_xInputStream;
}
Reference < XStream > UcbLockBytes::getStream()
{
vos::OClearableGuard aGuard( m_aMutex );
Reference < XStream > xStream( m_xSeekable, UNO_QUERY );
if ( xStream.is() )
m_bDontClose = sal_True;
return xStream;
}
//----------------------------------------------------------------------------
sal_Bool UcbLockBytes::setStream_Impl( const Reference<XStream>& aStream )
{
vos::OClearableGuard aGuard( m_aMutex );
if ( aStream.is() )
{
m_xOutputStream = aStream->getOutputStream();
setInputStream_Impl( aStream->getInputStream(), sal_False );
m_xSeekable = Reference < XSeekable > ( aStream, UNO_QUERY );
}
else
{
m_xOutputStream = Reference < XOutputStream >();
setInputStream_Impl( Reference < XInputStream >() );
}
return m_xInputStream.is();
}
sal_Bool UcbLockBytes::setInputStream_Impl( const Reference<XInputStream> &rxInputStream, sal_Bool bSetXSeekable )
{
sal_Bool bRet = sal_False;
try
{
vos::OClearableGuard aGuard( m_aMutex );
if ( !m_bDontClose && m_xInputStream.is() )
m_xInputStream->closeInput();
m_xInputStream = rxInputStream;
if( bSetXSeekable )
{
m_xSeekable = Reference < XSeekable > ( rxInputStream, UNO_QUERY );
if( !m_xSeekable.is() && rxInputStream.is() )
{
Reference < XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory();
Reference< XOutputStream > rxTempOut = Reference < XOutputStream > (
xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ) ),
UNO_QUERY );
if( rxTempOut.is() )
{
::comphelper::OStorageHelper::CopyInputToOutput( rxInputStream, rxTempOut );
m_xInputStream = Reference< XInputStream >( rxTempOut, UNO_QUERY );
m_xSeekable = Reference < XSeekable > ( rxTempOut, UNO_QUERY );
}
}
}
bRet = m_xInputStream.is();
// aGuard.clear();
}
catch( Exception& )
{}
if ( m_bStreamValid && m_xInputStream.is() )
m_aInitialized.set();
return bRet;
}
void UcbLockBytes::SetStreamValid_Impl()
{
m_bStreamValid = sal_True;
if ( m_xInputStream.is() )
m_aInitialized.set();
}
//----------------------------------------------------------------------------
void UcbLockBytes::terminate_Impl()
{
m_bTerminated = sal_True;
m_aInitialized.set();
m_aTerminated.set();
if ( GetError() == ERRCODE_NONE && !m_xInputStream.is() )
{
DBG_ERROR("No InputStream, but no error set!" );
SetError( ERRCODE_IO_NOTEXISTS );
}
if ( m_xHandler.Is() )
m_xHandler->Handle( UcbLockBytesHandler::DONE, this );
}
//----------------------------------------------------------------------------
void UcbLockBytes::SetSynchronMode (sal_Bool bSynchron)
{
SvLockBytes::SetSynchronMode (bSynchron);
}
//----------------------------------------------------------------------------
ErrCode UcbLockBytes::ReadAt ( sal_uLong nPos, void *pBuffer, sal_uLong nCount, sal_uLong *pRead) const
{
if ( IsSynchronMode() )
{
UcbLockBytes* pThis = const_cast < UcbLockBytes* >( this );
pThis->m_aInitialized.wait();
}
Reference <XInputStream> xStream = getInputStream_Impl();
if ( !xStream.is() )
{
if ( m_bTerminated )
return ERRCODE_IO_CANTREAD;
else
return ERRCODE_IO_PENDING;
}
if ( pRead )
*pRead = 0;
Reference <XSeekable> xSeekable = getSeekable_Impl();
if ( !xSeekable.is() )
return ERRCODE_IO_CANTREAD;
try
{
xSeekable->seek( nPos );
}
catch ( IOException )
{
return ERRCODE_IO_CANTSEEK;
}
catch (com::sun::star::lang::IllegalArgumentException)
{
return ERRCODE_IO_CANTSEEK;
}
Sequence<sal_Int8> aData;
sal_Int32 nSize;
nCount = VOS_MIN(nCount, 0x7FFFFFFF);
try
{
if ( !m_bTerminated && !IsSynchronMode() )
{
sal_uInt64 nLen = xSeekable->getLength();
if ( nPos + nCount > nLen )
return ERRCODE_IO_PENDING;
}
nSize = xStream->readBytes( aData, sal_Int32(nCount) );
}
catch (IOException)
{
return ERRCODE_IO_CANTREAD;
}
rtl_copyMemory (pBuffer, aData.getConstArray(), nSize);
if (pRead)
*pRead = sal_uLong(nSize);
return ERRCODE_NONE;
}
//----------------------------------------------------------------------------
ErrCode UcbLockBytes::WriteAt ( sal_uLong nPos, const void *pBuffer, sal_uLong nCount, sal_uLong *pWritten)
{
if ( pWritten )
*pWritten = 0;
DBG_ASSERT( IsSynchronMode(), "Writing is only possible in SynchronMode!" );
DBG_ASSERT( m_aInitialized.check(), "Writing bevor stream is ready!" );
Reference <XSeekable> xSeekable = getSeekable_Impl();
Reference <XOutputStream> xOutputStream = getOutputStream_Impl();
if ( !xOutputStream.is() || !xSeekable.is() )
return ERRCODE_IO_CANTWRITE;
try
{
xSeekable->seek( nPos );
}
catch ( IOException )
{
return ERRCODE_IO_CANTSEEK;
}
sal_Int8* pData = (sal_Int8*) pBuffer;
Sequence<sal_Int8> aData( pData, nCount );
try
{
xOutputStream->writeBytes( aData );
if ( pWritten )
*pWritten = nCount;
}
catch ( Exception )
{
return ERRCODE_IO_CANTWRITE;
}
return ERRCODE_NONE;
}
//----------------------------------------------------------------------------
ErrCode UcbLockBytes::Flush() const
{
Reference <XOutputStream > xOutputStream = getOutputStream_Impl();
if ( !xOutputStream.is() )
return ERRCODE_IO_CANTWRITE;
try
{
xOutputStream->flush();
}
catch( Exception )
{
return ERRCODE_IO_CANTWRITE;
}
return ERRCODE_NONE;
}
//----------------------------------------------------------------------------
ErrCode UcbLockBytes::SetSize (sal_uLong nNewSize)
{
SvLockBytesStat aStat;
Stat( &aStat, (SvLockBytesStatFlag) 0 );
sal_uLong nSize = aStat.nSize;
if ( nSize > nNewSize )
{
Reference < XTruncate > xTrunc( getOutputStream_Impl(), UNO_QUERY );
if ( xTrunc.is() )
{
xTrunc->truncate();
nSize = 0;
}
else {
DBG_WARNING("Not truncatable!");
}
}
if ( nSize < nNewSize )
{
sal_uLong nDiff = nNewSize-nSize, nCount=0;
sal_uInt8* pBuffer = new sal_uInt8[ nDiff ];
memset(pBuffer, 0, nDiff); // initialize for enhanced security
WriteAt( nSize, pBuffer, nDiff, &nCount );
delete[] pBuffer;
if ( nCount != nDiff )
return ERRCODE_IO_CANTWRITE;
}
return ERRCODE_NONE;
}
//----------------------------------------------------------------------------
ErrCode UcbLockBytes::Stat( SvLockBytesStat *pStat, SvLockBytesStatFlag) const
{
if ( IsSynchronMode() )
{
UcbLockBytes* pThis = const_cast < UcbLockBytes* >( this );
pThis->m_aInitialized.wait();
}
if (!pStat)
return ERRCODE_IO_INVALIDPARAMETER;
Reference <XInputStream> xStream = getInputStream_Impl();
Reference <XSeekable> xSeekable = getSeekable_Impl();
if ( !xStream.is() )
{
if ( m_bTerminated )
return ERRCODE_IO_INVALIDACCESS;
else
return ERRCODE_IO_PENDING;
}
else if( !xSeekable.is() )
return ERRCODE_IO_CANTTELL;
try
{
pStat->nSize = sal_uLong(xSeekable->getLength());
}
catch (IOException)
{
return ERRCODE_IO_CANTTELL;
}
return ERRCODE_NONE;
}
//----------------------------------------------------------------------------
void UcbLockBytes::Cancel()
{
// is alive only for compatibility reasons
OSL_ENSURE( m_bTerminated, "UcbLockBytes is not thread safe so it can be used only syncronously!\n" );
}
//----------------------------------------------------------------------------
IMPL_LINK( UcbLockBytes, DataAvailHdl, void*, EMPTYARG )
{
if ( hasInputStream_Impl() && m_xHandler.Is() )
m_xHandler->Handle( UcbLockBytesHandler::DATA_AVAILABLE, this );
return 0;
}
UcbLockBytesRef UcbLockBytes::CreateInputLockBytes( const Reference< XInputStream >& xInputStream )
{
if( !xInputStream.is() )
return NULL;;
UcbLockBytesRef xLockBytes = new UcbLockBytes();
xLockBytes->setDontClose_Impl();
xLockBytes->setInputStream_Impl( xInputStream );
xLockBytes->terminate_Impl();
return xLockBytes;
}
UcbLockBytesRef UcbLockBytes::CreateLockBytes( const Reference< XStream >& xStream )
{
if( !xStream.is() )
return NULL;;
UcbLockBytesRef xLockBytes = new UcbLockBytes();
xLockBytes->setDontClose_Impl();
xLockBytes->setStream_Impl( xStream );
xLockBytes->terminate_Impl();
return xLockBytes;
}
UcbLockBytesRef UcbLockBytes::CreateLockBytes( const Reference < XContent >& xContent, const ::rtl::OUString& rReferer, const ::rtl::OUString& rMediaType,
const Reference < XInputStream >& xPostData, const Reference < XInteractionHandler >& xInteractionHandler, UcbLockBytesHandler* pHandler )
{
if( !xContent.is() )
return NULL;;
UcbLockBytesRef xLockBytes = new UcbLockBytes( pHandler );
xLockBytes->SetSynchronMode( !pHandler );
Reference< XActiveDataControl > xSink = (XActiveDataControl*) new UcbDataSink_Impl( xLockBytes );
PostCommandArgument2 aArgument;
aArgument.Source = xPostData;
aArgument.Sink = xSink;
aArgument.MediaType = rMediaType;
aArgument.Referer = rReferer;
Command aCommand;
aCommand.Name = ::rtl::OUString::createFromAscii ("post");
aCommand.Argument <<= aArgument;
Reference< XProgressHandler > xProgressHdl = new ProgressHandler_Impl( LINK( &xLockBytes, UcbLockBytes, DataAvailHdl ) );
sal_Bool bError = UCBOpenContentSync( xLockBytes,
xContent,
aCommand,
xSink,
xInteractionHandler,
xProgressHdl,
pHandler );
if ( xLockBytes->GetError() == ERRCODE_NONE && ( bError || !xLockBytes->getInputStream().is() ) )
{
DBG_ERROR("No InputStream, but no error set!" );
xLockBytes->SetError( ERRCODE_IO_GENERAL );
}
return xLockBytes;
}
UcbLockBytesRef UcbLockBytes::CreateLockBytes( const Reference < XContent >& xContent, const Sequence < PropertyValue >& rProps,
StreamMode eOpenMode, const Reference < XInteractionHandler >& xInteractionHandler, UcbLockBytesHandler* pHandler )
{
if( !xContent.is() )
return NULL;;
UcbLockBytesRef xLockBytes = new UcbLockBytes( pHandler );
xLockBytes->SetSynchronMode( !pHandler );
Reference< XActiveDataControl > xSink;
if ( eOpenMode & STREAM_WRITE )
xSink = (XActiveDataControl*) new UcbStreamer_Impl( xLockBytes );
else
xSink = (XActiveDataControl*) new UcbDataSink_Impl( xLockBytes );
if ( rProps.getLength() )
{
Reference < XCommandProcessor > xProcessor( xContent, UNO_QUERY );
Command aCommand;
aCommand.Name = ::rtl::OUString::createFromAscii("setPropertyValues");
aCommand.Handle = -1; /* unknown */
aCommand.Argument <<= rProps;
xProcessor->execute( aCommand, 0, Reference < XCommandEnvironment >() );
}
OpenCommandArgument2 aArgument;
aArgument.Sink = xSink;
aArgument.Mode = OpenMode::DOCUMENT;
Command aCommand;
aCommand.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("open") );
aCommand.Argument <<= aArgument;
Reference< XProgressHandler > xProgressHdl = new ProgressHandler_Impl( LINK( &xLockBytes, UcbLockBytes, DataAvailHdl ) );
sal_Bool bError = UCBOpenContentSync( xLockBytes,
xContent,
aCommand,
xSink,
xInteractionHandler,
xProgressHdl,
pHandler );
if ( xLockBytes->GetError() == ERRCODE_NONE && ( bError || !xLockBytes->getInputStream().is() ) )
{
DBG_ERROR("No InputStream, but no error set!" );
xLockBytes->SetError( ERRCODE_IO_GENERAL );
}
return xLockBytes;
}
}