unotools/source/ucbhelper/ucblockbytes.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "ucblockbytes.hxx"
  21
  22 #include <sal/log.hxx>
  23 #include <comphelper/processfactory.hxx>
  24 #include <salhelper/condition.hxx>
  25 #include <osl/thread.hxx>
  26 #include <osl/diagnose.h>
  27 #include <tools/urlobj.hxx>
  28 #include <tools/solar.h>
  29 #include <ucbhelper/interactionrequest.hxx>
  30 #include <com/sun/star/task/XInteractionAbort.hpp>
  31 #include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp>
  32 #include <com/sun/star/ucb/CommandFailedException.hpp>
  33 #include <com/sun/star/ucb/ContentCreationException.hpp>
  34 #include <com/sun/star/ucb/CommandAbortedException.hpp>
  35 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
  36 #include <com/sun/star/ucb/InteractiveIOException.hpp>
  37 #include <com/sun/star/ucb/XContentIdentifier.hpp>
  38 #include <com/sun/star/ucb/XContent.hpp>
  39 #include <com/sun/star/io/IOException.hpp>
  40 #include <com/sun/star/io/XActiveDataStreamer.hpp>
  41 #include <com/sun/star/io/TempFile.hpp>
  42 #include <com/sun/star/ucb/XCommandProcessor.hpp>
  43 #include <com/sun/star/task/XInteractionHandler.hpp>
  44 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  45 #include <com/sun/star/ucb/PostCommandArgument2.hpp>
  46 #include <com/sun/star/ucb/OpenMode.hpp>
  47 #include <com/sun/star/beans/PropertyValue.hpp>
  48 #include <com/sun/star/beans/XPropertiesChangeNotifier.hpp>
  49 #include <com/sun/star/beans/XPropertiesChangeListener.hpp>
  50 #include <com/sun/star/io/XActiveDataSink.hpp>
  51 #include <com/sun/star/io/XActiveDataControl.hpp>
  52 #include <com/sun/star/io/XSeekable.hpp>
  53 #include <cppuhelper/implbase.hxx>
  54 #include <tools/debug.hxx>
  55 #include <com/sun/star/io/XTruncate.hpp>
  56 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  57
  58 #include <comphelper/storagehelper.hxx>
  59 #include <ucbhelper/content.hxx>
  60
  61 using namespace ::com::sun::star::uno;
  62 using namespace ::com::sun::star::io;
  63 using namespace ::com::sun::star::ucb;
  64 using namespace ::com::sun::star::task;
  65 using namespace ::com::sun::star::lang;
  66 using namespace ::com::sun::star::beans;
  67
  68 namespace utl
  69 {
  70
  71 /**
  72     Helper class for getting a XInputStream when opening a content
  73  */
  74 class UcbDataSink_Impl : public ::cppu::WeakImplHelper< XActiveDataControl, XActiveDataSink >
  75 {
  76     UcbLockBytesRef         m_xLockBytes;
  77
  78 public:
  79     explicit UcbDataSink_Impl( UcbLockBytes* pLockBytes )
  80         : m_xLockBytes( pLockBytes )
  81     {}
  82
  83     // XActiveDataControl.
  84     virtual void SAL_CALL   addListener ( const Reference<XStreamListener> &/*rxListener*/) override {}
  85     virtual void SAL_CALL   removeListener ( const Reference<XStreamListener> &/*rxListener*/) override {}
  86     virtual void SAL_CALL   start() override {}
  87     virtual void SAL_CALL   terminate() override
  88                             { m_xLockBytes->terminate_Impl(); }
  89
  90     // XActiveDataSink.
  91     virtual void SAL_CALL   setInputStream ( const Reference<XInputStream> &rxInputStream) override
  92                             { m_xLockBytes->setInputStream_Impl (rxInputStream); }
  93     virtual Reference<XInputStream> SAL_CALL getInputStream() override
  94                             { return m_xLockBytes->getInputStream_Impl(); }
  95 };
  96
  97 /**
  98     Helper class for getting a XStream when opening a content
  99  */
 100 class UcbStreamer_Impl : public ::cppu::WeakImplHelper< XActiveDataStreamer, XActiveDataControl >
 101 {
 102     Reference < XStream >   m_xStream;
 103     UcbLockBytesRef         m_xLockBytes;
 104
 105 public:
 106     explicit UcbStreamer_Impl( UcbLockBytes* pLockBytes )
 107         : m_xLockBytes( pLockBytes )
 108     {}
 109
 110     // XActiveDataControl.
 111     virtual void SAL_CALL   addListener ( const Reference<XStreamListener> &/*rxListener*/) override {}
 112     virtual void SAL_CALL   removeListener ( const Reference<XStreamListener> &/*rxListener*/) override {}
 113     virtual void SAL_CALL   start() override {}
 114     virtual void SAL_CALL   terminate() override
 115                             { m_xLockBytes->terminate_Impl(); }
 116
 117     // XActiveDataStreamer
 118     virtual void SAL_CALL   setStream( const Reference< XStream >& aStream ) override
 119                             { m_xStream = aStream; m_xLockBytes->setStream_Impl( aStream ); }
 120     virtual Reference< XStream > SAL_CALL getStream() override
 121                             { return m_xStream; }
 122 };
 123
 124 /**
 125     Helper class for managing interactions and progress when executing UCB commands
 126  */
 127 class UcbTaskEnvironment : public ::cppu::WeakImplHelper< XCommandEnvironment >
 128 {
 129     Reference< XInteractionHandler >                m_xInteractionHandler;
 130     Reference< XProgressHandler >                   m_xProgressHandler;
 131
 132 public:
 133                             UcbTaskEnvironment( const Reference< XInteractionHandler>& rxInteractionHandler,
 134                                                 const Reference< XProgressHandler>& rxProgressHandler )
 135                                 : m_xInteractionHandler( rxInteractionHandler )
 136                                 , m_xProgressHandler( rxProgressHandler )
 137                             {}
 138
 139     virtual Reference<XInteractionHandler> SAL_CALL getInteractionHandler() override
 140     { return m_xInteractionHandler; }
 141
 142     virtual Reference<XProgressHandler> SAL_CALL    getProgressHandler() override
 143     { return m_xProgressHandler; }
 144 };
 145
 146 /**
 147     Helper class for property change notifies when executing UCB commands
 148 */
 149 class UcbPropertiesChangeListener_Impl : public ::cppu::WeakImplHelper< XPropertiesChangeListener >
 150 {
 151 public:
 152     UcbLockBytesRef         m_xLockBytes;
 153
 154     explicit UcbPropertiesChangeListener_Impl( UcbLockBytesRef const & rRef )
 155         : m_xLockBytes( rRef )
 156     {}
 157
 158     virtual void SAL_CALL   disposing ( const EventObject &/*rEvent*/) override {}
 159     virtual void SAL_CALL   propertiesChange ( const Sequence<PropertyChangeEvent> &rEvent) override;
 160 };
 161
 162 void SAL_CALL UcbPropertiesChangeListener_Impl::propertiesChange ( const Sequence<PropertyChangeEvent> &rEvent)
 163 {
 164     for (const auto& rPropChangeEvent : rEvent)
 165     {
 166         if (rPropChangeEvent.PropertyName == "DocumentHeader")
 167         {
 168             m_xLockBytes->SetStreamValid_Impl();
 169         }
 170     }
 171 }
 172
 173 class Moderator
 174     : public osl::Thread
 175 {
 176     // usage restriction:
 177     // It might be possible, that the call to the interactionhandler and/or
 178     // progresshandler is done asynchronously, while the 'execute' simply
 179     // returns. This would imply that these class must be refcounted!!!
 180
 181 public:
 182     /// @throws ContentCreationException
 183     /// @throws RuntimeException
 184     Moderator(
 185         Reference < XContent > const & xContent,
 186         Reference < XInteractionHandler > const & xInteract,
 187         const Command& rArg
 188     );
 189
 190     enum class ResultType {
 191         NORESULT,
 192
 193         INTERACTIONREQUEST,    // reply expected
 194
 195         INPUTSTREAM,
 196         STREAM,
 197
 198         RESULT,
 199         TIMEDOUT,
 200         COMMANDABORTED,
 201         COMMANDFAILED,
 202         INTERACTIVEIO,
 203         UNSUPPORTED,
 204         GENERAL
 205     };
 206
 207     class ConditionRes
 208         : public salhelper::Condition
 209     {
 210     public:
 211         ConditionRes(osl::Mutex& aMutex,Moderator& aModerator)
 212             : salhelper::Condition(aMutex),
 213               m_aModerator(aModerator)
 214         {
 215         }
 216
 217     protected:
 218         bool applies() const override {
 219             return m_aModerator.m_aResultType != ResultType::NORESULT;
 220         }
 221
 222     private:
 223         Moderator& m_aModerator;
 224     };
 225
 226     struct Result {
 227         ResultType        type;
 228         Any               result;
 229         IOErrorCode       ioErrorCode;
 230     };
 231
 232     Result getResult(const sal_uInt32 milliSec);
 233
 234     enum ReplyType {
 235         NOREPLY,
 236         EXIT,
 237         REQUESTHANDLED
 238     };
 239
 240     class ConditionRep
 241         : public salhelper::Condition
 242     {
 243     public:
 244         ConditionRep(osl::Mutex& aMutex,Moderator& aModerator)
 245             : salhelper::Condition(aMutex),
 246               m_aModerator(aModerator)
 247         {
 248         }
 249
 250     protected:
 251         bool applies() const override {
 252             return m_aModerator.m_aReplyType != NOREPLY;
 253         }
 254
 255     private:
 256         Moderator& m_aModerator;
 257     };
 258
 259     void setReply(ReplyType);
 260
 261     void handle( const Reference<XInteractionRequest >& Request );
 262
 263     void setStream(const Reference< XStream >& aStream);
 264     void setInputStream(const Reference<XInputStream> &rxInputStream);
 265
 266 protected:
 267     virtual void SAL_CALL run() override;
 268     virtual void SAL_CALL onTerminated() override;
 269
 270 private:
 271     osl::Mutex        m_aMutex;
 272
 273     friend class ConditionRes;
 274
 275     ConditionRes      m_aRes;
 276     ResultType        m_aResultType;
 277     IOErrorCode       m_nIOErrorCode;
 278     Any               m_aResult;
 279
 280     friend class ConditionRep;
 281
 282     ConditionRep      m_aRep;
 283     ReplyType         m_aReplyType;
 284
 285     Command                           m_aArg;
 286     ::ucbhelper::Content              m_aContent;
 287 };
 288
 289 class ModeratorsActiveDataStreamer
 290     : public ::cppu::WeakImplHelper<XActiveDataStreamer>
 291 {
 292 public:
 293
 294     explicit ModeratorsActiveDataStreamer(Moderator &theModerator);
 295
 296     // XActiveDataStreamer
 297     virtual void SAL_CALL
 298     setStream(
 299         const Reference< XStream >& aStream
 300     ) override;
 301
 302     virtual Reference<XStream> SAL_CALL getStream () override
 303     {
 304         osl::MutexGuard aGuard(m_aMutex);
 305         return m_xStream;
 306     }
 307
 308 private:
 309     Moderator& m_aModerator;
 310
 311     osl::Mutex m_aMutex;
 312     Reference<XStream> m_xStream;
 313 };
 314
 315 class ModeratorsActiveDataSink
 316     : public ::cppu::WeakImplHelper<XActiveDataSink>
 317 {
 318 public:
 319
 320     explicit ModeratorsActiveDataSink(Moderator &theModerator);
 321
 322     // XActiveDataSink.
 323     virtual void SAL_CALL
 324     setInputStream (
 325         const Reference<XInputStream> &rxInputStream
 326     ) override;
 327
 328     virtual Reference<XInputStream> SAL_CALL getInputStream() override
 329     {
 330         osl::MutexGuard aGuard(m_aMutex);
 331         return m_xStream;
 332     }
 333
 334 private:
 335     Moderator& m_aModerator;
 336     osl::Mutex m_aMutex;
 337     Reference<XInputStream> m_xStream;
 338 };
 339
 340 ModeratorsActiveDataSink::ModeratorsActiveDataSink(Moderator &theModerator)
 341     : m_aModerator(theModerator)
 342 {
 343 }
 344
 345 // XActiveDataSink.
 346 void SAL_CALL
 347 ModeratorsActiveDataSink::setInputStream (
 348     const Reference<XInputStream> &rxInputStream
 349 )
 350 {
 351     m_aModerator.setInputStream(rxInputStream);
 352     osl::MutexGuard aGuard(m_aMutex);
 353     m_xStream = rxInputStream;
 354 }
 355
 356 ModeratorsActiveDataStreamer::ModeratorsActiveDataStreamer(
 357     Moderator &theModerator
 358 )
 359     : m_aModerator(theModerator)
 360 {
 361 }
 362
 363 // XActiveDataStreamer.
 364 void SAL_CALL
 365 ModeratorsActiveDataStreamer::setStream (
 366     const Reference<XStream> &rxStream
 367 )
 368 {
 369     m_aModerator.setStream(rxStream);
 370     osl::MutexGuard aGuard(m_aMutex);
 371     m_xStream = rxStream;
 372 }
 373
 374 class ModeratorsInteractionHandler
 375     : public ::cppu::WeakImplHelper<XInteractionHandler>
 376 {
 377 public:
 378
 379     explicit ModeratorsInteractionHandler(Moderator &theModerator);
 380
 381     virtual void SAL_CALL
 382     handle( const Reference<XInteractionRequest >& Request ) override;
 383
 384 private:
 385
 386     Moderator& m_aModerator;
 387 };
 388
 389 ModeratorsInteractionHandler::ModeratorsInteractionHandler(
 390     Moderator &aModerator)
 391     : m_aModerator(aModerator)
 392 {
 393 }
 394
 395 void SAL_CALL
 396 ModeratorsInteractionHandler::handle(
 397     const Reference<XInteractionRequest >& Request
 398 )
 399 {
 400     // wakes up the mainthread
 401     m_aModerator.handle(Request);
 402 }
 403
 404 Moderator::Moderator(
 405     Reference < XContent > const & xContent,
 406     Reference < XInteractionHandler > const & xInteract,
 407     const Command& rArg
 408 )
 409     : m_aMutex(),
 410
 411       m_aRes(m_aMutex,*this),
 412       m_aResultType(ResultType::NORESULT),
 413       m_nIOErrorCode(IOErrorCode_ABORT),
 414       m_aResult(),
 415
 416       m_aRep(m_aMutex,*this),
 417       m_aReplyType(NOREPLY),
 418
 419       m_aArg(rArg),
 420       m_aContent(
 421           xContent,
 422           new UcbTaskEnvironment(
 423               xInteract.is() ? new ModeratorsInteractionHandler(*this) : nullptr,
 424               nullptr),
 425           comphelper::getProcessComponentContext())
 426 {
 427     // now exchange the whole data sink stuff
 428     // with a thread safe version
 429
 430     Reference<XInterface> *pxSink = nullptr;
 431
 432     PostCommandArgument2 aPostArg;
 433     OpenCommandArgument2 aOpenArg;
 434
 435     int dec(2);
 436     if(m_aArg.Argument >>= aPostArg) {
 437         pxSink = &aPostArg.Sink;
 438         dec = 0;
 439     }
 440     else if(m_aArg.Argument >>= aOpenArg) {
 441         pxSink = &aOpenArg.Sink;
 442         dec = 1;
 443     }
 444
 445     if(dec ==2)
 446         throw ContentCreationException();
 447
 448     Reference < XActiveDataSink > xActiveSink(*pxSink,UNO_QUERY);
 449     if(xActiveSink.is())
 450         pxSink->set( static_cast<cppu::OWeakObject*>(new ModeratorsActiveDataSink(*this)));
 451
 452     Reference<XActiveDataStreamer> xStreamer( *pxSink, UNO_QUERY );
 453     if ( xStreamer.is() )
 454         pxSink->set( static_cast<cppu::OWeakObject*>(new ModeratorsActiveDataStreamer(*this)));
 455
 456     if(dec == 0)
 457         m_aArg.Argument <<= aPostArg;
 458     else if(dec == 1)
 459         m_aArg.Argument <<= aOpenArg;
 460 }
 461
 462 Moderator::Result Moderator::getResult(const sal_uInt32 milliSec)
 463 {
 464     Result ret;
 465     try {
 466         salhelper::ConditionWaiter aWaiter(m_aRes,milliSec);
 467         ret.type = m_aResultType;
 468         ret.result = m_aResult;
 469         ret.ioErrorCode = m_nIOErrorCode;
 470
 471         // reset
 472         m_aResultType = ResultType::NORESULT;
 473     }
 474     catch (const salhelper::ConditionWaiter::timedout&)
 475     {
 476         ret.type = ResultType::TIMEDOUT;
 477     }
 478
 479     return ret;
 480 }
 481
 482 void Moderator::setReply(ReplyType aReplyType )
 483 {
 484     salhelper::ConditionModifier aMod(m_aRep);
 485     m_aReplyType = aReplyType;
 486 }
 487
 488 void Moderator::handle( const Reference<XInteractionRequest >& Request )
 489 {
 490     ReplyType aReplyType;
 491
 492     do {
 493         {
 494             salhelper::ConditionModifier aMod(m_aRes);
 495             m_aResultType = ResultType::INTERACTIONREQUEST;
 496             m_aResult <<= Request;
 497         }
 498
 499         {
 500             salhelper::ConditionWaiter aWait(m_aRep);
 501             aReplyType = m_aReplyType;
 502
 503             // reset
 504             m_aReplyType = NOREPLY;
 505         }
 506
 507         if(aReplyType == EXIT) {
 508             const Sequence<Reference<XInteractionContinuation> > aSeq(
 509                 Request->getContinuations());
 510             for(const auto& rContinuation : aSeq) {
 511                 Reference<XInteractionAbort> aRef(rContinuation,UNO_QUERY);
 512                 if(aRef.is()) {
 513                     aRef->select();
 514                 }
 515             }
 516
 517             // resignal the exit condition
 518             setReply(EXIT);
 519             break;
 520         }
 521     } while(aReplyType != REQUESTHANDLED);
 522 }
 523
 524 void Moderator::setStream(const Reference< XStream >& aStream)
 525 {
 526     {
 527         salhelper::ConditionModifier aMod(m_aRes);
 528         m_aResultType = ResultType::STREAM;
 529         m_aResult <<= aStream;
 530     }
 531     ReplyType aReplyType;
 532     {
 533         salhelper::ConditionWaiter aWait(m_aRep);
 534         aReplyType = m_aReplyType;
 535         m_aReplyType = NOREPLY;
 536     }
 537     if(aReplyType == EXIT)
 538         setReply(EXIT);
 539 }
 540
 541 void Moderator::setInputStream(const Reference<XInputStream> &rxInputStream)
 542 {
 543     {
 544         salhelper::ConditionModifier aMod(m_aRes);
 545         m_aResultType = ResultType::INPUTSTREAM;
 546         m_aResult <<= rxInputStream;
 547     }
 548     ReplyType aReplyType;
 549     {
 550         salhelper::ConditionWaiter aWait(m_aRep);
 551         aReplyType = m_aReplyType;
 552         m_aReplyType = NOREPLY;
 553     }
 554     if(aReplyType == EXIT)
 555         setReply(EXIT);
 556 }
 557
 558 void SAL_CALL Moderator::run()
 559 {
 560     osl_setThreadName("utl::Moderator");
 561
 562     ResultType  aResultType;
 563     Any         aResult;
 564     IOErrorCode nIOErrorCode = IOErrorCode_ABORT;
 565
 566     try
 567     {
 568         aResult = m_aContent.executeCommand(m_aArg.Name,m_aArg.Argument);
 569         aResultType = ResultType::RESULT;
 570     }
 571     catch (const CommandAbortedException&)
 572     {
 573         aResultType = ResultType::COMMANDABORTED;
 574     }
 575     catch (const CommandFailedException&)
 576     {
 577         aResultType = ResultType::COMMANDFAILED;
 578     }
 579     catch (const InteractiveIOException& r)
 580     {
 581         nIOErrorCode = r.Code;
 582         aResultType = ResultType::INTERACTIVEIO;
 583     }
 584     catch (const UnsupportedDataSinkException &)
 585     {
 586         aResultType = ResultType::UNSUPPORTED;
 587     }
 588     catch (const Exception&)
 589     {
 590         aResultType = ResultType::GENERAL;
 591     }
 592
 593     {
 594         salhelper::ConditionModifier aMod(m_aRes);
 595         m_aResultType = aResultType;
 596         m_aResult = aResult;
 597         m_nIOErrorCode = nIOErrorCode;
 598     }
 599 }
 600
 601 void SAL_CALL Moderator::onTerminated()
 602 {
 603     {
 604         salhelper::ConditionWaiter aWaiter(m_aRep);
 605     }
 606     delete this;
 607 }
 608
 609 /**
 610    Function for opening UCB contents synchronously,
 611    but with handled timeout;
 612 */
 613 static bool UCBOpenContentSync_(
 614     const UcbLockBytesRef& xLockBytes,
 615     const Reference < XContent >& xContent,
 616     const Command& rArg,
 617     const Reference < XInterface >& xSink,
 618     const Reference < XInteractionHandler >& xInteract );
 619
 620 static bool UCBOpenContentSync(
 621     const UcbLockBytesRef& xLockBytes,
 622     Reference < XContent > const & xContent,
 623     const Command& rArg,
 624     const Reference < XInterface >& xSink,
 625     Reference < XInteractionHandler > const & xInteract )
 626 {
 627     // http protocol must be handled in a special way:
 628     //        during the opening process the input stream may change
 629     //        only the last inputstream after notifying the document
 630     //        headers is valid
 631
 632     Reference<XContentIdentifier> xContId(
 633         xContent.is() ? xContent->getIdentifier() : nullptr );
 634
 635     OUString aScheme;
 636     if(xContId.is())
 637         aScheme = xContId->getContentProviderScheme();
 638
 639     // now determine whether we use a timeout or not;
 640     if( ! aScheme.equalsIgnoreAsciiCase("http")                &&
 641         ! aScheme.equalsIgnoreAsciiCase("https")               &&
 642         ! aScheme.equalsIgnoreAsciiCase("vnd.sun.star.webdav") &&
 643         ! aScheme.equalsIgnoreAsciiCase("vnd.sun.star.webdavs") &&
 644         ! aScheme.equalsIgnoreAsciiCase("ftp"))
 645         return UCBOpenContentSync_(
 646             xLockBytes,xContent,rArg,xSink,xInteract);
 647
 648     if ( !aScheme.equalsIgnoreAsciiCase( "http" ) &&
 649          !aScheme.equalsIgnoreAsciiCase( "https" ) )
 650         xLockBytes->SetStreamValid_Impl();
 651
 652     Reference< XPropertiesChangeListener > xListener;
 653     Reference< XPropertiesChangeNotifier > xProps(xContent,UNO_QUERY);
 654     if(xProps.is()) {
 655         xListener =
 656             new UcbPropertiesChangeListener_Impl(xLockBytes);
 657         xProps->addPropertiesChangeListener(
 658             Sequence< OUString >(),
 659             xListener);
 660     }
 661
 662     bool bException(false);
 663     bool bAborted(false);
 664     bool bResultAchieved(false);
 665
 666     Moderator* pMod = nullptr;
 667     try
 668     {
 669         pMod = new Moderator(xContent,xInteract,rArg);
 670         pMod->create();
 671     }
 672     catch (const ContentCreationException&)
 673     {
 674         bResultAchieved = bException = true;
 675         xLockBytes->SetError( ERRCODE_IO_GENERAL );
 676     }
 677
 678     sal_uInt32 nTimeout(5000); // initially 5000 milliSec
 679     while(!bResultAchieved) {
 680
 681         // try to get the result for with timeout
 682         Moderator::Result res = pMod->getResult(nTimeout);
 683
 684         switch(res.type) {
 685         case Moderator::ResultType::STREAM:
 686             {
 687                 Reference<XStream> result;
 688                 if(res.result >>= result) {
 689                     Reference < XActiveDataStreamer > xStreamer(
 690                         xSink, UNO_QUERY
 691                     );
 692
 693                     if(xStreamer.is())
 694                         xStreamer->setStream(result);
 695                 }
 696                 pMod->setReply(Moderator::REQUESTHANDLED);
 697                 break;
 698             }
 699         case Moderator::ResultType::INPUTSTREAM:
 700             {
 701                 Reference<XInputStream> result;
 702                 res.result >>= result;
 703                 Reference < XActiveDataSink > xActiveSink(
 704                     xSink, UNO_QUERY
 705                 );
 706
 707                 if(xActiveSink.is())
 708                     xActiveSink->setInputStream(result);
 709                 pMod->setReply(Moderator::REQUESTHANDLED);
 710                 break;
 711             }
 712         case Moderator::ResultType::TIMEDOUT:
 713             {
 714                 Reference<XInteractionRetry> xRet;
 715                 if(xInteract.is()) {
 716                     InteractiveNetworkConnectException aExcep;
 717                     INetURLObject aURL(
 718                         xContId.is() ?
 719                         xContId->getContentIdentifier() :
 720                         OUString() );
 721                     aExcep.Server = aURL.GetHost();
 722                     aExcep.Classification = InteractionClassification_ERROR;
 723                     aExcep.Message = "server not responding after five seconds";
 724                     Any request;
 725                     request <<= aExcep;
 726                     ucbhelper::InteractionRequest *ir =
 727                         new ucbhelper::InteractionRequest(request);
 728                     Reference<XInteractionRequest> xIR(ir);
 729                     Sequence<Reference<XInteractionContinuation> > aSeq(2);
 730                     ucbhelper::InteractionRetry *retryP =
 731                         new ucbhelper::InteractionRetry(ir);
 732                     aSeq[0] = retryP;
 733                     ucbhelper::InteractionAbort *abortP =
 734                         new ucbhelper::InteractionAbort(ir);
 735                     aSeq[1] = abortP;
 736
 737                     ir->setContinuations(aSeq);
 738                     xInteract->handle(xIR);
 739                     rtl::Reference< ucbhelper::InteractionContinuation > ref
 740                         = ir->getSelection();
 741                     if(ref.is()) {
 742                         Reference<XInterface> xInt(ref.get());
 743                         xRet.set(xInt,UNO_QUERY);
 744                     }
 745                 }
 746
 747                 if(!xRet.is()) {
 748                     bAborted = true;
 749                     xLockBytes->SetError(ERRCODE_ABORT);
 750                 }
 751
 752                 break;
 753             }
 754         case Moderator::ResultType::INTERACTIONREQUEST:
 755             {
 756                 Reference<XInteractionRequest> Request;
 757                 res.result >>= Request;
 758                 xInteract->handle(Request);
 759                 pMod->setReply(Moderator::REQUESTHANDLED);
 760                 break;
 761             }
 762         case Moderator::ResultType::RESULT:
 763             {
 764                 bResultAchieved = true;
 765                 break;
 766             }
 767         case Moderator::ResultType::COMMANDABORTED:
 768             {
 769                 bAborted = true;
 770                 xLockBytes->SetError( ERRCODE_ABORT );
 771                 break;
 772             }
 773         case Moderator::ResultType::COMMANDFAILED:
 774             {
 775                 bAborted = true;
 776                 xLockBytes->SetError( ERRCODE_ABORT );
 777                 break;
 778             }
 779         case Moderator::ResultType::INTERACTIVEIO:
 780             {
 781                 bException = true;
 782                 if ( res.ioErrorCode == IOErrorCode_ACCESS_DENIED ||
 783                      res.ioErrorCode == IOErrorCode_LOCKING_VIOLATION )
 784                     xLockBytes->SetError( ERRCODE_IO_ACCESSDENIED );
 785                 else if ( res.ioErrorCode == IOErrorCode_NOT_EXISTING )
 786                     xLockBytes->SetError( ERRCODE_IO_NOTEXISTS );
 787                 else if ( res.ioErrorCode == IOErrorCode_CANT_READ )
 788                     xLockBytes->SetError( ERRCODE_IO_CANTREAD );
 789                 else
 790                     xLockBytes->SetError( ERRCODE_IO_GENERAL );
 791                 break;
 792             }
 793         case Moderator::ResultType::UNSUPPORTED:
 794             {
 795                 bException = true;
 796                 xLockBytes->SetError( ERRCODE_IO_NOTSUPPORTED );
 797                 break;
 798             }
 799         default:
 800             {
 801                 bException = true;
 802                 xLockBytes->SetError( ERRCODE_IO_GENERAL );
 803                 break;
 804             }
 805         }
 806
 807         bResultAchieved |= bException;
 808         bResultAchieved |= bAborted;
 809         if(nTimeout == 5000) nTimeout *= 2;
 810     }
 811
 812     if(pMod) pMod->setReply(Moderator::EXIT);
 813
 814     if ( bAborted || bException )
 815     {
 816         Reference < XActiveDataSink > xActiveSink( xSink, UNO_QUERY );
 817         if ( xActiveSink.is() )
 818             xActiveSink->setInputStream( Reference < XInputStream >() );
 819
 820         Reference < XActiveDataStreamer > xStreamer( xSink, UNO_QUERY );
 821         if ( xStreamer.is() )
 822             xStreamer->setStream( Reference < XStream >() );
 823     }
 824
 825     Reference < XActiveDataControl > xControl( xSink, UNO_QUERY );
 826     if ( xControl.is() )
 827         xControl->terminate();
 828
 829     if ( xProps.is() )
 830         xProps->removePropertiesChangeListener(
 831             Sequence< OUString >(),
 832             xListener );
 833
 834     return ( bAborted || bException );
 835 }
 836
 837 /**
 838     Function for opening UCB contents synchronously
 839  */
 840 static bool UCBOpenContentSync_(
 841     const UcbLockBytesRef& xLockBytes,
 842     const Reference < XContent >& xContent,
 843     const Command& rArg,
 844     const Reference < XInterface >& xSink,
 845     const Reference < XInteractionHandler >& xInteract )
 846 {
 847     ::ucbhelper::Content aContent(
 848         xContent, new UcbTaskEnvironment( xInteract, nullptr ),
 849         comphelper::getProcessComponentContext() );
 850     Reference < XContentIdentifier > xIdent = xContent->getIdentifier();
 851     OUString aScheme = xIdent->getContentProviderScheme();
 852
 853     // http protocol must be handled in a special way: during the opening process the input stream may change
 854     // only the last inputstream after notifying the document headers is valid
 855     if ( !aScheme.equalsIgnoreAsciiCase("http") )
 856         xLockBytes->SetStreamValid_Impl();
 857
 858     Reference< XPropertiesChangeListener > xListener = new UcbPropertiesChangeListener_Impl( xLockBytes );
 859     Reference< XPropertiesChangeNotifier > xProps ( xContent, UNO_QUERY );
 860     if ( xProps.is() )
 861         xProps->addPropertiesChangeListener( Sequence< OUString >(), xListener );
 862
 863     bool bException = false;
 864     bool bAborted = false;
 865
 866     try
 867     {
 868         aContent.executeCommand( rArg.Name, rArg.Argument );
 869     }
 870     catch (const CommandAbortedException&)
 871     {
 872         bAborted = true;
 873         xLockBytes->SetError( ERRCODE_ABORT );
 874     }
 875     catch (const CommandFailedException&)
 876     {
 877         bAborted = true;
 878         xLockBytes->SetError( ERRCODE_ABORT );
 879     }
 880     catch (const InteractiveIOException& r)
 881     {
 882         bException = true;
 883         if ( r.Code == IOErrorCode_ACCESS_DENIED || r.Code == IOErrorCode_LOCKING_VIOLATION )
 884             xLockBytes->SetError( ERRCODE_IO_ACCESSDENIED );
 885         else if ( r.Code == IOErrorCode_NOT_EXISTING )
 886             xLockBytes->SetError( ERRCODE_IO_NOTEXISTS );
 887         else if ( r.Code == IOErrorCode_CANT_READ )
 888             xLockBytes->SetError( ERRCODE_IO_CANTREAD );
 889         else
 890             xLockBytes->SetError( ERRCODE_IO_GENERAL );
 891     }
 892     catch (const UnsupportedDataSinkException&)
 893     {
 894         bException = true;
 895         xLockBytes->SetError( ERRCODE_IO_NOTSUPPORTED );
 896     }
 897     catch (const Exception&)
 898     {
 899         bException = true;
 900         xLockBytes->SetError( ERRCODE_IO_GENERAL );
 901     }
 902
 903     if ( bAborted || bException )
 904     {
 905         Reference < XActiveDataSink > xActiveSink( xSink, UNO_QUERY );
 906         if ( xActiveSink.is() )
 907             xActiveSink->setInputStream( Reference < XInputStream >() );
 908
 909         Reference < XActiveDataStreamer > xStreamer( xSink, UNO_QUERY );
 910         if ( xStreamer.is() )
 911             xStreamer->setStream( Reference < XStream >() );
 912     }
 913
 914     Reference < XActiveDataControl > xControl( xSink, UNO_QUERY );
 915     if ( xControl.is() )
 916         xControl->terminate();
 917
 918     if ( xProps.is() )
 919         xProps->removePropertiesChangeListener( Sequence< OUString >(), xListener );
 920
 921     return ( bAborted || bException );
 922 }
 923
 924 UcbLockBytes::UcbLockBytes()
 925     : m_nError( ERRCODE_NONE )
 926     , m_bTerminated  (false)
 927     , m_bDontClose( false )
 928     , m_bStreamValid  (false)
 929 {
 930     SetSynchronMode();
 931 }
 932
 933 UcbLockBytes::~UcbLockBytes()
 934 {
 935     if ( !m_bDontClose )
 936     {
 937         if ( m_xInputStream.is() )
 938         {
 939             try
 940             {
 941                 m_xInputStream->closeInput();
 942             }
 943             catch (const RuntimeException&)
 944             {
 945             }
 946             catch (const IOException&)
 947             {
 948             }
 949         }
 950     }
 951
 952     if ( !m_xInputStream.is() && m_xOutputStream.is() )
 953     {
 954         try
 955         {
 956             m_xOutputStream->closeOutput();
 957         }
 958         catch (const RuntimeException&)
 959         {
 960         }
 961         catch (const IOException&)
 962         {
 963         }
 964     }
 965 }
 966
 967 Reference < XInputStream > UcbLockBytes::getInputStream()
 968 {
 969     osl::MutexGuard aGuard( m_aMutex );
 970     m_bDontClose = true;
 971     return m_xInputStream;
 972 }
 973
 974 void UcbLockBytes::setStream_Impl( const Reference<XStream>& aStream )
 975 {
 976     osl::MutexGuard aGuard( m_aMutex );
 977     if ( aStream.is() )
 978     {
 979         m_xOutputStream = aStream->getOutputStream();
 980         setInputStream_Impl( aStream->getInputStream(), false );
 981         m_xSeekable.set( aStream, UNO_QUERY );
 982     }
 983     else
 984     {
 985         m_xOutputStream.clear();
 986         setInputStream_Impl( Reference < XInputStream >() );
 987     }
 988 }
 989
 990 bool UcbLockBytes::setInputStream_Impl( const Reference<XInputStream> &rxInputStream, bool bSetXSeekable )
 991 {
 992     bool bRet = false;
 993
 994     try
 995     {
 996         osl::MutexGuard aGuard( m_aMutex );
 997
 998         if ( !m_bDontClose && m_xInputStream.is() )
 999             m_xInputStream->closeInput();
1000
1001         m_xInputStream = rxInputStream;
1002
1003         if( bSetXSeekable )
1004         {
1005             m_xSeekable.set( rxInputStream, UNO_QUERY );
1006             if( !m_xSeekable.is() && rxInputStream.is() )
1007             {
1008                 Reference < XComponentContext > xContext = ::comphelper::getProcessComponentContext();
1009                 Reference< XOutputStream > rxTempOut( css::io::TempFile::create(xContext), UNO_QUERY_THROW );
1010
1011                 ::comphelper::OStorageHelper::CopyInputToOutput( rxInputStream, rxTempOut );
1012                 m_xInputStream.set( rxTempOut, UNO_QUERY );
1013                 m_xSeekable.set( rxTempOut, UNO_QUERY );
1014             }
1015         }
1016
1017         bRet = m_xInputStream.is();
1018     }
1019     catch (const Exception&)
1020     {
1021     }
1022
1023     if ( m_bStreamValid && m_xInputStream.is() )
1024         m_aInitialized.set();
1025
1026     return bRet;
1027 }
1028
1029 void UcbLockBytes::SetStreamValid_Impl()
1030 {
1031     m_bStreamValid = true;
1032     if ( m_xInputStream.is() )
1033         m_aInitialized.set();
1034 }
1035
1036 void UcbLockBytes::terminate_Impl()
1037 {
1038     m_bTerminated = true;
1039     m_aInitialized.set();
1040     m_aTerminated.set();
1041
1042     if ( GetError() == ERRCODE_NONE && !m_xInputStream.is() )
1043     {
1044         OSL_FAIL("No InputStream, but no error set!" );
1045         SetError( ERRCODE_IO_NOTEXISTS );
1046     }
1047 }
1048
1049 ErrCode UcbLockBytes::ReadAt(sal_uInt64 const nPos,
1050         void *pBuffer, std::size_t nCount, std::size_t *pRead) const
1051 {
1052     if ( IsSynchronMode() )
1053     {
1054         UcbLockBytes* pThis = const_cast < UcbLockBytes* >( this );
1055         pThis->m_aInitialized.wait();
1056     }
1057
1058     Reference <XInputStream> xStream = getInputStream_Impl();
1059     if ( !xStream.is() )
1060     {
1061         if ( m_bTerminated )
1062             return ERRCODE_IO_CANTREAD;
1063         else
1064             return ERRCODE_IO_PENDING;
1065     }
1066
1067     if ( pRead )
1068         *pRead = 0;
1069
1070     Reference <XSeekable> xSeekable = getSeekable_Impl();
1071     if ( !xSeekable.is() )
1072         return ERRCODE_IO_CANTREAD;
1073
1074     try
1075     {
1076         xSeekable->seek( nPos );
1077     }
1078     catch (const IOException&)
1079     {
1080         return ERRCODE_IO_CANTSEEK;
1081     }
1082     catch (const css::lang::IllegalArgumentException&)
1083     {
1084         return ERRCODE_IO_CANTSEEK;
1085     }
1086
1087     Sequence<sal_Int8> aData;
1088     sal_Int32          nSize;
1089
1090     if(nCount > 0x7FFFFFFF)
1091     {
1092         nCount = 0x7FFFFFFF;
1093     }
1094     try
1095     {
1096         if ( !m_bTerminated && !IsSynchronMode() )
1097         {
1098             sal_uInt64 nLen = xSeekable->getLength();
1099             if ( nPos + nCount > nLen )
1100                 return ERRCODE_IO_PENDING;
1101         }
1102
1103         nSize = xStream->readBytes( aData, sal_Int32(nCount) );
1104     }
1105     catch (const IOException&)
1106     {
1107         return ERRCODE_IO_CANTREAD;
1108     }
1109
1110     memcpy (pBuffer, aData.getConstArray(), nSize);
1111     if (pRead)
1112         *pRead = static_cast<std::size_t>(nSize);
1113
1114     return ERRCODE_NONE;
1115 }
1116
1117 ErrCode UcbLockBytes::WriteAt(sal_uInt64 const nPos, const void *pBuffer,
1118         std::size_t nCount, std::size_t *pWritten)
1119 {
1120     if ( pWritten )
1121         *pWritten = 0;
1122
1123     DBG_ASSERT( IsSynchronMode(), "Writing is only possible in SynchronMode!" );
1124     DBG_ASSERT( m_aInitialized.check(), "Writing bevor stream is ready!" );
1125
1126     Reference <XSeekable> xSeekable = getSeekable_Impl();
1127     Reference <XOutputStream> xOutputStream = getOutputStream_Impl();
1128     if ( !xOutputStream.is() || !xSeekable.is() )
1129         return ERRCODE_IO_CANTWRITE;
1130
1131     try
1132     {
1133         xSeekable->seek( nPos );
1134     }
1135     catch (const IOException&)
1136     {
1137         return ERRCODE_IO_CANTSEEK;
1138     }
1139
1140     sal_Int8 const * pData = static_cast<sal_Int8 const *>(pBuffer);
1141     Sequence<sal_Int8> aData( pData, nCount );
1142     try
1143     {
1144         xOutputStream->writeBytes( aData );
1145         if ( pWritten )
1146             *pWritten = nCount;
1147     }
1148     catch (const Exception&)
1149     {
1150         return ERRCODE_IO_CANTWRITE;
1151     }
1152
1153     return ERRCODE_NONE;
1154 }
1155
1156 ErrCode UcbLockBytes::Flush() const
1157 {
1158     Reference <XOutputStream > xOutputStream = getOutputStream_Impl();
1159     if ( !xOutputStream.is() )
1160         return ERRCODE_IO_CANTWRITE;
1161
1162     try
1163     {
1164         xOutputStream->flush();
1165     }
1166     catch (const Exception&)
1167     {
1168         return ERRCODE_IO_CANTWRITE;
1169     }
1170
1171     return ERRCODE_NONE;
1172 }
1173
1174 ErrCode UcbLockBytes::SetSize (sal_uInt64 const nNewSize)
1175 {
1176     SvLockBytesStat aStat;
1177     Stat( &aStat );
1178     std::size_t nSize = aStat.nSize;
1179
1180     if ( nSize > nNewSize )
1181     {
1182         Reference < XTruncate > xTrunc( getOutputStream_Impl(), UNO_QUERY );
1183         if ( xTrunc.is() )
1184         {
1185             xTrunc->truncate();
1186             nSize = 0;
1187         }
1188         else {
1189             SAL_INFO("unotools.ucbhelper", "Not truncable!");
1190         }
1191     }
1192
1193     if ( nSize < nNewSize )
1194     {
1195         std::size_t nDiff = nNewSize-nSize, nCount=0;
1196         std::unique_ptr<sal_uInt8[]> pBuffer(new sal_uInt8[ nDiff ]);
1197         memset(pBuffer.get(), 0, nDiff); // initialize for enhanced security
1198         WriteAt( nSize, pBuffer.get(), nDiff, &nCount );
1199         if ( nCount != nDiff )
1200             return ERRCODE_IO_CANTWRITE;
1201     }
1202
1203     return ERRCODE_NONE;
1204 }
1205
1206 ErrCode UcbLockBytes::Stat( SvLockBytesStat *pStat ) const
1207 {
1208     if ( IsSynchronMode() )
1209     {
1210         UcbLockBytes* pThis = const_cast < UcbLockBytes* >( this );
1211         pThis->m_aInitialized.wait();
1212     }
1213
1214     if (!pStat)
1215         return ERRCODE_IO_INVALIDPARAMETER;
1216
1217     Reference <XInputStream> xStream = getInputStream_Impl();
1218     Reference <XSeekable> xSeekable = getSeekable_Impl();
1219
1220     if ( !xStream.is() )
1221     {
1222         if ( m_bTerminated )
1223             return ERRCODE_IO_INVALIDACCESS;
1224         else
1225             return ERRCODE_IO_PENDING;
1226     }
1227     else if( !xSeekable.is() )
1228         return ERRCODE_IO_CANTTELL;
1229
1230     try
1231     {
1232         pStat->nSize = sal_uLong(xSeekable->getLength());
1233     }
1234     catch (const IOException&)
1235     {
1236         return ERRCODE_IO_CANTTELL;
1237     }
1238
1239     return ERRCODE_NONE;
1240 }
1241
1242 UcbLockBytesRef UcbLockBytes::CreateInputLockBytes( const Reference< XInputStream >& xInputStream )
1243 {
1244     if( !xInputStream.is() )
1245         return nullptr;
1246
1247     UcbLockBytesRef xLockBytes = new UcbLockBytes;
1248     xLockBytes->setDontClose_Impl();
1249     xLockBytes->setInputStream_Impl( xInputStream );
1250     xLockBytes->terminate_Impl();
1251     return xLockBytes;
1252 }
1253
1254 UcbLockBytesRef UcbLockBytes::CreateLockBytes( const Reference< XStream >& xStream )
1255 {
1256     if( !xStream.is() )
1257         return nullptr;
1258
1259     UcbLockBytesRef xLockBytes = new UcbLockBytes;
1260     xLockBytes->setDontClose_Impl();
1261     xLockBytes->setStream_Impl( xStream );
1262     xLockBytes->terminate_Impl();
1263     return xLockBytes;
1264 }
1265
1266 UcbLockBytesRef UcbLockBytes::CreateLockBytes( const Reference < XContent >& xContent, const Sequence < PropertyValue >& rProps,
1267         StreamMode eOpenMode, const Reference < XInteractionHandler >& xInteractionHandler )
1268 {
1269     if( !xContent.is() )
1270         return nullptr;
1271
1272     UcbLockBytesRef xLockBytes = new UcbLockBytes;
1273     xLockBytes->SetSynchronMode();
1274     Reference< XActiveDataControl > xSink;
1275     if ( eOpenMode & StreamMode::WRITE )
1276         xSink = new UcbStreamer_Impl(xLockBytes.get());
1277     else
1278         xSink = new UcbDataSink_Impl(xLockBytes.get());
1279
1280     if ( rProps.hasElements() )
1281     {
1282         Reference < XCommandProcessor > xProcessor( xContent, UNO_QUERY );
1283         Command aCommand;
1284         aCommand.Name     = "setPropertyValues";
1285         aCommand.Handle   = -1; /* unknown */
1286         aCommand.Argument <<= rProps;
1287         xProcessor->execute( aCommand, 0, Reference < XCommandEnvironment >() );
1288     }
1289
1290     OpenCommandArgument2 aArgument;
1291     aArgument.Sink = xSink;
1292     aArgument.Mode = OpenMode::DOCUMENT;
1293
1294     Command aCommand;
1295     aCommand.Name = "open";
1296     aCommand.Argument <<= aArgument;
1297
1298     bool bError = UCBOpenContentSync( xLockBytes,
1299                                       xContent,
1300                                       aCommand,
1301                                       xSink,
1302                                       xInteractionHandler );
1303
1304     if ( xLockBytes->GetError() == ERRCODE_NONE && ( bError || !xLockBytes->getInputStream().is() ) )
1305     {
1306         OSL_FAIL("No InputStream, but no error set!" );
1307         xLockBytes->SetError( ERRCODE_IO_GENERAL );
1308     }
1309
1310     return xLockBytes;
1311 }
1312
1313 }
1314
1315 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */