xref: /aoo41x/main/unotools/source/ucbhelper/ucblockbytes.cxx (revision b5088357)

/**************************************************************
 *
 * 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;
}

}