unotools/source/misc/mediadescriptor.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 <comphelper/docpasswordhelper.hxx>
  21 #include <unotools/mediadescriptor.hxx>
  22 #include <unotools/securityoptions.hxx>
  23 #include <comphelper/namedvaluecollection.hxx>
  24 #include <comphelper/stillreadwriteinteraction.hxx>
  25
  26 #include <com/sun/star/ucb/XContent.hpp>
  27 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  28 #include <com/sun/star/task/XInteractionHandler.hpp>
  29 #include <com/sun/star/io/XStream.hpp>
  30 #include <com/sun/star/io/XActiveDataSink.hpp>
  31 #include <com/sun/star/io/XSeekable.hpp>
  32 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  33 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  34 #include <com/sun/star/util/XURLTransformer.hpp>
  35 #include <com/sun/star/ucb/InteractiveIOException.hpp>
  36 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
  37 #include <com/sun/star/ucb/CommandFailedException.hpp>
  38 #include <com/sun/star/task/XInteractionAbort.hpp>
  39 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  40 #include <com/sun/star/uri/XUriReference.hpp>
  41 #include <com/sun/star/ucb/PostCommandArgument2.hpp>
  42 #include <com/sun/star/container/XNameAccess.hpp>
  43 #include <officecfg/Office/Common.hxx>
  44 #include <ucbhelper/interceptedinteraction.hxx>
  45 #include <ucbhelper/content.hxx>
  46 #include <ucbhelper/commandenvironment.hxx>
  47 #include <ucbhelper/activedatasink.hxx>
  48 #include <comphelper/processfactory.hxx>
  49
  50 namespace utl {
  51
  52 namespace {
  53
  54 OUString removeFragment(OUString const & uri) {
  55     css::uno::Reference< css::uri::XUriReference > ref(
  56         css::uri::UriReferenceFactory::create(
  57             comphelper::getProcessComponentContext())->
  58         parse(uri));
  59     if (ref.is()) {
  60         ref->clearFragment();
  61         return ref->getUriReference();
  62     } else {
  63         SAL_WARN("unotools.misc", "cannot parse <" << uri << ">");
  64         return uri;
  65     }
  66 }
  67
  68 }
  69
  70 const OUString& MediaDescriptor::PROP_ABORTED()
  71 {
  72     static const OUString sProp("Aborted");
  73     return sProp;
  74 }
  75
  76 const OUString& MediaDescriptor::PROP_ASTEMPLATE()
  77 {
  78     static const OUString sProp("AsTemplate");
  79     return sProp;
  80 }
  81
  82 const OUString& MediaDescriptor::PROP_COMPONENTDATA()
  83 {
  84     static const OUString sProp("ComponentData");
  85     return sProp;
  86 }
  87
  88 const OUString& MediaDescriptor::PROP_DOCUMENTSERVICE()
  89 {
  90     static const OUString sProp("DocumentService");
  91     return sProp;
  92 }
  93
  94 const OUString& MediaDescriptor::PROP_ENCRYPTIONDATA()
  95 {
  96     static const OUString sProp("EncryptionData");
  97     return sProp;
  98 }
  99
 100 const OUString& MediaDescriptor::PROP_FILENAME()
 101 {
 102     static const OUString sProp("FileName");
 103     return sProp;
 104 }
 105
 106 const OUString& MediaDescriptor::PROP_FILTERNAME()
 107 {
 108     static const OUString sProp("FilterName");
 109     return sProp;
 110 }
 111
 112 const OUString& MediaDescriptor::PROP_FILTERPROVIDER()
 113 {
 114     static const OUString aProp("FilterProvider");
 115     return aProp;
 116 }
 117
 118 const OUString& MediaDescriptor::PROP_FILTEROPTIONS()
 119 {
 120     static const OUString sProp("FilterOptions");
 121     return sProp;
 122 }
 123
 124 const OUString& MediaDescriptor::PROP_FRAME()
 125 {
 126     static const OUString sProp("Frame");
 127     return sProp;
 128 }
 129
 130 const OUString& MediaDescriptor::PROP_FRAMENAME()
 131 {
 132     static const OUString sProp("FrameName");
 133     return sProp;
 134 }
 135
 136 const OUString& MediaDescriptor::PROP_HIDDEN()
 137 {
 138     static const OUString sProp("Hidden");
 139     return sProp;
 140 }
 141
 142 const OUString& MediaDescriptor::PROP_INPUTSTREAM()
 143 {
 144     static const OUString sProp("InputStream");
 145     return sProp;
 146 }
 147
 148 const OUString& MediaDescriptor::PROP_INTERACTIONHANDLER()
 149 {
 150     static const OUString sProp("InteractionHandler");
 151     return sProp;
 152 }
 153
 154 const OUString& MediaDescriptor::PROP_JUMPMARK()
 155 {
 156     static const OUString sProp("JumpMark");
 157     return sProp;
 158 }
 159
 160 const OUString& MediaDescriptor::PROP_MACROEXECUTIONMODE()
 161 {
 162     static const OUString sProp("MacroExecutionMode");
 163     return sProp;
 164 }
 165
 166 const OUString& MediaDescriptor::PROP_MEDIATYPE()
 167 {
 168     static const OUString sProp("MediaType");
 169     return sProp;
 170 }
 171
 172 const OUString& MediaDescriptor::PROP_MINIMIZED()
 173 {
 174     static const OUString sProp("Minimized");
 175     return sProp;
 176 }
 177
 178 const OUString& MediaDescriptor::PROP_NOAUTOSAVE()
 179 {
 180     static const OUString sProp("NoAutoSave");
 181     return sProp;
 182 }
 183
 184 const OUString& MediaDescriptor::PROP_OPENNEWVIEW()
 185 {
 186     static const OUString sProp("OpenNewView");
 187     return sProp;
 188 }
 189
 190 const OUString& MediaDescriptor::PROP_OUTPUTSTREAM()
 191 {
 192     static const OUString sProp("OutputStream");
 193     return sProp;
 194 }
 195
 196 const OUString& MediaDescriptor::PROP_POSTDATA()
 197 {
 198     static const OUString sProp("PostData");
 199     return sProp;
 200 }
 201
 202 const OUString& MediaDescriptor::PROP_PREVIEW()
 203 {
 204     static const OUString sProp("Preview");
 205     return sProp;
 206 }
 207
 208 const OUString& MediaDescriptor::PROP_READONLY()
 209 {
 210     static const OUString sProp("ReadOnly");
 211     return sProp;
 212 }
 213
 214 const OUString& MediaDescriptor::PROP_REFERRER()
 215 {
 216     static const OUString sProp("Referer");
 217     return sProp;
 218 }
 219
 220 const OUString& MediaDescriptor::PROP_STATUSINDICATOR()
 221 {
 222     static const OUString sProp("StatusIndicator");
 223     return sProp;
 224 }
 225
 226 const OUString& MediaDescriptor::PROP_STREAM()
 227 {
 228     static const OUString sProp("Stream");
 229     return sProp;
 230 }
 231
 232 const OUString& MediaDescriptor::PROP_STREAMFOROUTPUT()
 233 {
 234     static const OUString sProp("StreamForOutput");
 235     return sProp;
 236 }
 237
 238 const OUString& MediaDescriptor::PROP_TEMPLATENAME()
 239 {
 240     static const OUString sProp("TemplateName");
 241     return sProp;
 242 }
 243
 244 const OUString& MediaDescriptor::PROP_TYPENAME()
 245 {
 246     static const OUString sProp("TypeName");
 247     return sProp;
 248 }
 249
 250 const OUString& MediaDescriptor::PROP_UCBCONTENT()
 251 {
 252     static const OUString sProp("UCBContent");
 253     return sProp;
 254 }
 255
 256 const OUString& MediaDescriptor::PROP_UPDATEDOCMODE()
 257 {
 258     static const OUString sProp("UpdateDocMode");
 259     return sProp;
 260 }
 261
 262 const OUString& MediaDescriptor::PROP_URL()
 263 {
 264     static const OUString sProp("URL");
 265     return sProp;
 266 }
 267
 268 const OUString& MediaDescriptor::PROP_VERSION()
 269 {
 270     static const OUString sProp("Version");
 271     return sProp;
 272 }
 273
 274 const OUString& MediaDescriptor::PROP_DOCUMENTTITLE()
 275 {
 276     static const OUString sProp("DocumentTitle");
 277     return sProp;
 278 }
 279
 280 const OUString& MediaDescriptor::PROP_MODEL()
 281 {
 282     static const OUString sProp("Model");
 283     return sProp;
 284 }
 285
 286 const OUString& MediaDescriptor::PROP_PASSWORD()
 287 {
 288     static const OUString sProp("Password");
 289     return sProp;
 290 }
 291
 292 const OUString& MediaDescriptor::PROP_TITLE()
 293 {
 294     static const OUString sProp("Title");
 295     return sProp;
 296 }
 297
 298 const OUString& MediaDescriptor::PROP_SALVAGEDFILE()
 299 {
 300     static const OUString sProp("SalvagedFile");
 301     return sProp;
 302 }
 303
 304 const OUString& MediaDescriptor::PROP_VIEWONLY()
 305 {
 306     static const OUString sProp("ViewOnly");
 307     return sProp;
 308 }
 309
 310 const OUString& MediaDescriptor::PROP_DOCUMENTBASEURL()
 311 {
 312     static const OUString sProp("DocumentBaseURL");
 313     return sProp;
 314 }
 315
 316 MediaDescriptor::MediaDescriptor()
 317     : SequenceAsHashMap()
 318 {
 319 }
 320
 321 MediaDescriptor::MediaDescriptor(const css::uno::Sequence< css::beans::PropertyValue >& lSource)
 322     : SequenceAsHashMap(lSource)
 323 {
 324 }
 325
 326 bool MediaDescriptor::isStreamReadOnly() const
 327 {
 328     static OUString CONTENTSCHEME_FILE( "file" );
 329     static OUString CONTENTPROP_ISREADONLY( "IsReadOnly" );
 330     static bool READONLY_FALLBACK = false;
 331
 332     bool bReadOnly = READONLY_FALLBACK;
 333
 334     // check for explicit readonly state
 335     const_iterator pIt = find(MediaDescriptor::PROP_READONLY());
 336     if (pIt != end())
 337     {
 338         pIt->second >>= bReadOnly;
 339         return bReadOnly;
 340     }
 341
 342     // streams based on post data are readonly by definition
 343     pIt = find(MediaDescriptor::PROP_POSTDATA());
 344     if (pIt != end())
 345         return true;
 346
 347     // A XStream capsulate XInputStream and XOutputStream ...
 348     // If it exists - the file must be open in read/write mode!
 349     pIt = find(MediaDescriptor::PROP_STREAM());
 350     if (pIt != end())
 351         return false;
 352
 353     // Only file system content provider is able to provide XStream
 354     // so for this content impossibility to create XStream triggers
 355     // switch to readonly mode.
 356     try
 357     {
 358         css::uno::Reference< css::ucb::XContent > xContent = getUnpackedValueOrDefault(MediaDescriptor::PROP_UCBCONTENT(), css::uno::Reference< css::ucb::XContent >());
 359         if (xContent.is())
 360         {
 361             css::uno::Reference< css::ucb::XContentIdentifier > xId(xContent->getIdentifier(), css::uno::UNO_QUERY);
 362             OUString aScheme;
 363             if (xId.is())
 364                 aScheme = xId->getContentProviderScheme();
 365
 366             if (aScheme.equalsIgnoreAsciiCase(CONTENTSCHEME_FILE))
 367                 bReadOnly = true;
 368             else
 369             {
 370                 ::ucbhelper::Content aContent(xContent, css::uno::Reference< css::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext());
 371                 aContent.getPropertyValue(CONTENTPROP_ISREADONLY) >>= bReadOnly;
 372             }
 373         }
 374     }
 375     catch(const css::uno::RuntimeException& )
 376         { throw; }
 377     catch(const css::uno::Exception&)
 378         {}
 379
 380     return bReadOnly;
 381 }
 382
 383 css::uno::Any MediaDescriptor::getComponentDataEntry( const OUString& rName ) const
 384 {
 385     comphelper::SequenceAsHashMap::const_iterator aPropertyIter = find( PROP_COMPONENTDATA() );
 386     if( aPropertyIter != end() )
 387         return comphelper::NamedValueCollection( aPropertyIter->second ).get( rName );
 388     return css::uno::Any();
 389 }
 390
 391 void MediaDescriptor::setComponentDataEntry( const OUString& rName, const css::uno::Any& rValue )
 392 {
 393     if( rValue.hasValue() )
 394     {
 395         // get or create the 'ComponentData' property entry
 396         css::uno::Any& rCompDataAny = operator[]( PROP_COMPONENTDATA() );
 397         // insert the value (retain sequence type, create NamedValue elements by default)
 398         bool bHasNamedValues = !rCompDataAny.hasValue() || rCompDataAny.has< css::uno::Sequence< css::beans::NamedValue > >();
 399         bool bHasPropValues = rCompDataAny.has< css::uno::Sequence< css::beans::PropertyValue > >();
 400         OSL_ENSURE( bHasNamedValues || bHasPropValues, "MediaDescriptor::setComponentDataEntry - incompatible 'ComponentData' property in media descriptor" );
 401         if( bHasNamedValues || bHasPropValues )
 402         {
 403             // insert or overwrite the passed value
 404             comphelper::SequenceAsHashMap aCompDataMap( rCompDataAny );
 405             aCompDataMap[ rName ] = rValue;
 406             // write back the sequence (restore sequence with correct element type)
 407             rCompDataAny = aCompDataMap.getAsConstAny( bHasPropValues );
 408         }
 409     }
 410     else
 411     {
 412         // if an empty Any is passed, clear the entry
 413         clearComponentDataEntry( rName );
 414     }
 415 }
 416
 417 void MediaDescriptor::clearComponentDataEntry( const OUString& rName )
 418 {
 419     comphelper::SequenceAsHashMap::iterator aPropertyIter = find( PROP_COMPONENTDATA() );
 420     if( aPropertyIter != end() )
 421     {
 422         css::uno::Any& rCompDataAny = aPropertyIter->second;
 423         bool bHasNamedValues = rCompDataAny.has< css::uno::Sequence< css::beans::NamedValue > >();
 424         bool bHasPropValues = rCompDataAny.has< css::uno::Sequence< css::beans::PropertyValue > >();
 425         OSL_ENSURE( bHasNamedValues || bHasPropValues, "MediaDescriptor::clearComponentDataEntry - incompatible 'ComponentData' property in media descriptor" );
 426         if( bHasNamedValues || bHasPropValues )
 427         {
 428             // remove the value with the passed name
 429             comphelper::SequenceAsHashMap aCompDataMap( rCompDataAny );
 430             aCompDataMap.erase( rName );
 431             // write back the sequence, or remove it completely if it is empty
 432             if( aCompDataMap.empty() )
 433                 erase( aPropertyIter );
 434             else
 435                 rCompDataAny = aCompDataMap.getAsConstAny( bHasPropValues );
 436         }
 437     }
 438 }
 439
 440 ::com::sun::star::uno::Sequence< ::com::sun::star::beans::NamedValue > MediaDescriptor::requestAndVerifyDocPassword(
 441         comphelper::IDocPasswordVerifier& rVerifier,
 442         comphelper::DocPasswordRequestType eRequestType,
 443         const ::std::vector< OUString >* pDefaultPasswords )
 444 {
 445     css::uno::Sequence< css::beans::NamedValue > aMediaEncData = getUnpackedValueOrDefault(
 446         PROP_ENCRYPTIONDATA(), css::uno::Sequence< css::beans::NamedValue >() );
 447     OUString aMediaPassword = getUnpackedValueOrDefault(
 448         PROP_PASSWORD(), OUString() );
 449     css::uno::Reference< css::task::XInteractionHandler > xInteractHandler = getUnpackedValueOrDefault(
 450         PROP_INTERACTIONHANDLER(), css::uno::Reference< css::task::XInteractionHandler >() );
 451     OUString aDocumentName = getUnpackedValueOrDefault(
 452         PROP_URL(), OUString() );
 453
 454     bool bIsDefaultPassword = false;
 455     css::uno::Sequence< css::beans::NamedValue > aEncryptionData = comphelper::DocPasswordHelper::requestAndVerifyDocPassword(
 456         rVerifier, aMediaEncData, aMediaPassword, xInteractHandler, aDocumentName, eRequestType, pDefaultPasswords, &bIsDefaultPassword );
 457
 458     erase( PROP_PASSWORD() );
 459     erase( PROP_ENCRYPTIONDATA() );
 460
 461     // insert valid password into media descriptor (but not a default password)
 462     if( (aEncryptionData.getLength() > 0) && !bIsDefaultPassword )
 463         (*this)[ PROP_ENCRYPTIONDATA() ] <<= aEncryptionData;
 464
 465     return aEncryptionData;
 466 }
 467
 468 bool MediaDescriptor::addInputStream()
 469 {
 470     return impl_addInputStream( true );
 471 }
 472
 473 /*-----------------------------------------------*/
 474 bool MediaDescriptor::addInputStreamOwnLock()
 475 {
 476     return impl_addInputStream(
 477         officecfg::Office::Common::Misc::UseDocumentSystemFileLocking::get());
 478 }
 479
 480 /*-----------------------------------------------*/
 481 bool MediaDescriptor::impl_addInputStream( bool bLockFile )
 482 {
 483     // check for an already existing stream item first
 484     const_iterator pIt = find(MediaDescriptor::PROP_INPUTSTREAM());
 485     if (pIt != end())
 486         return true;
 487
 488     try
 489     {
 490         // No stream available - create a new one
 491         // a) data comes as PostData ...
 492         pIt = find(MediaDescriptor::PROP_POSTDATA());
 493         if (pIt != end())
 494         {
 495             const css::uno::Any& rPostData = pIt->second;
 496             css::uno::Reference< css::io::XInputStream > xPostData;
 497             rPostData >>= xPostData;
 498
 499             return impl_openStreamWithPostData( xPostData );
 500         }
 501
 502         // b) ... or we must get it from the given URL
 503         OUString sURL = getUnpackedValueOrDefault(MediaDescriptor::PROP_URL(), OUString());
 504         if (sURL.isEmpty())
 505             throw css::uno::Exception("Found no URL.",
 506                     css::uno::Reference< css::uno::XInterface >());
 507
 508         return impl_openStreamWithURL( removeFragment(sURL), bLockFile );
 509     }
 510     catch(const css::uno::Exception& ex)
 511     {
 512         SAL_WARN(
 513             "unotools.misc",
 514             "invalid MediaDescriptor detected: " << ex.Message);
 515         return false;
 516     }
 517 }
 518
 519 bool MediaDescriptor::impl_openStreamWithPostData( const css::uno::Reference< css::io::XInputStream >& _rxPostData )
 520     throw(::com::sun::star::uno::RuntimeException)
 521 {
 522     if ( !_rxPostData.is() )
 523         throw css::lang::IllegalArgumentException("Found invalid PostData.",
 524                 css::uno::Reference< css::uno::XInterface >(), 1);
 525
 526     // PostData can't be used in read/write mode!
 527     (*this)[MediaDescriptor::PROP_READONLY()] <<= sal_True;
 528
 529     // prepare the environment
 530     css::uno::Reference< css::task::XInteractionHandler > xInteraction = getUnpackedValueOrDefault(
 531         MediaDescriptor::PROP_INTERACTIONHANDLER(),
 532         css::uno::Reference< css::task::XInteractionHandler >());
 533     css::uno::Reference< css::ucb::XProgressHandler > xProgress;
 534     ::ucbhelper::CommandEnvironment* pCommandEnv = new ::ucbhelper::CommandEnvironment(xInteraction, xProgress);
 535     css::uno::Reference< css::ucb::XCommandEnvironment > xCommandEnv(static_cast< css::ucb::XCommandEnvironment* >(pCommandEnv), css::uno::UNO_QUERY);
 536
 537     // media type
 538     OUString sMediaType = getUnpackedValueOrDefault(MediaDescriptor::PROP_MEDIATYPE(), OUString());
 539     if (sMediaType.isEmpty())
 540     {
 541         sMediaType = "application/x-www-form-urlencoded";
 542         (*this)[MediaDescriptor::PROP_MEDIATYPE()] <<= sMediaType;
 543     }
 544
 545     // url
 546     OUString sURL( getUnpackedValueOrDefault( PROP_URL(), OUString() ) );
 547
 548     css::uno::Reference< css::io::XInputStream > xResultStream;
 549     try
 550     {
 551         // seek PostData stream to the beginning
 552         css::uno::Reference< css::io::XSeekable > xSeek( _rxPostData, css::uno::UNO_QUERY );
 553         if ( xSeek.is() )
 554             xSeek->seek( 0 );
 555
 556         // a content for the URL
 557         ::ucbhelper::Content aContent( sURL, xCommandEnv, comphelper::getProcessComponentContext() );
 558
 559         // use post command
 560         css::ucb::PostCommandArgument2 aPostArgument;
 561         aPostArgument.Source = _rxPostData;
 562         css::uno::Reference< css::io::XActiveDataSink > xSink( new ucbhelper::ActiveDataSink );
 563         aPostArgument.Sink = xSink;
 564         aPostArgument.MediaType = sMediaType;
 565         aPostArgument.Referer = getUnpackedValueOrDefault( PROP_REFERRER(), OUString() );
 566
 567         OUString sCommandName( "post" );
 568         aContent.executeCommand( sCommandName, css::uno::makeAny( aPostArgument ) );
 569
 570         // get result
 571         xResultStream = xSink->getInputStream();
 572     }
 573     catch( const css::uno::Exception& )
 574     {
 575     }
 576
 577     // success?
 578     if ( !xResultStream.is() )
 579     {
 580         OSL_FAIL( "no valid reply to the HTTP-Post" );
 581         return false;
 582     }
 583
 584     (*this)[MediaDescriptor::PROP_INPUTSTREAM()] <<= xResultStream;
 585     return true;
 586 }
 587
 588 /*-----------------------------------------------*/
 589 bool MediaDescriptor::impl_openStreamWithURL( const OUString& sURL, bool bLockFile )
 590     throw(::com::sun::star::uno::RuntimeException)
 591 {
 592     OUString referer(getUnpackedValueOrDefault(PROP_REFERRER(), OUString()));
 593     if (SvtSecurityOptions().isUntrustedReferer(referer)) {
 594         return false;
 595     }
 596
 597     // prepare the environment
 598     css::uno::Reference< css::task::XInteractionHandler > xOrgInteraction = getUnpackedValueOrDefault(
 599         MediaDescriptor::PROP_INTERACTIONHANDLER(),
 600         css::uno::Reference< css::task::XInteractionHandler >());
 601
 602     comphelper::StillReadWriteInteraction* pInteraction = new comphelper::StillReadWriteInteraction(xOrgInteraction);
 603     css::uno::Reference< css::task::XInteractionHandler > xInteraction(static_cast< css::task::XInteractionHandler* >(pInteraction), css::uno::UNO_QUERY);
 604
 605     css::uno::Reference< css::ucb::XProgressHandler > xProgress;
 606     ::ucbhelper::CommandEnvironment* pCommandEnv = new ::ucbhelper::CommandEnvironment(xInteraction, xProgress);
 607     css::uno::Reference< css::ucb::XCommandEnvironment > xCommandEnv(static_cast< css::ucb::XCommandEnvironment* >(pCommandEnv), css::uno::UNO_QUERY);
 608
 609     // try to create the content
 610     // no content -> no stream => return immediately with FALSE
 611     ::ucbhelper::Content                      aContent;
 612     css::uno::Reference< css::ucb::XContent > xContent;
 613     try
 614     {
 615         aContent = ::ucbhelper::Content(sURL, xCommandEnv, comphelper::getProcessComponentContext());
 616         xContent = aContent.get();
 617     }
 618     catch(const css::uno::RuntimeException&)
 619         { throw; }
 620     catch(const css::ucb::ContentCreationException& e)
 621         {
 622             SAL_WARN(
 623                 "unotools.misc",
 624                 "caught ContentCreationException \"" << e.Message
 625                     << "\" while opening <" << sURL << ">");
 626             return false; // TODO error handling
 627         }
 628     catch(const css::uno::Exception& e)
 629         {
 630             SAL_WARN(
 631                 "unotools.misc",
 632                 "caught Exception \"" << e.Message << "\" while opening <"
 633                     << sURL << ">");
 634             return false; // TODO error handling
 635         }
 636
 637     // try to open the file in read/write mode
 638     // (if its allowed to do so).
 639     // But handle errors in a "hidden mode". Because
 640     // we try it readonly later - if read/write isnt an option.
 641     css::uno::Reference< css::io::XStream >      xStream;
 642     css::uno::Reference< css::io::XInputStream > xInputStream;
 643
 644     bool bReadOnly = false;
 645     bool bModeRequestedExplicitly = false;
 646     const_iterator pIt = find(MediaDescriptor::PROP_READONLY());
 647     if (pIt != end())
 648     {
 649         pIt->second >>= bReadOnly;
 650         bModeRequestedExplicitly = true;
 651     }
 652
 653     if ( !bReadOnly && bLockFile )
 654     {
 655         try
 656         {
 657             // TODO: use "special" still interaction to supress error messages
 658             xStream = aContent.openWriteableStream();
 659             if (xStream.is())
 660                 xInputStream = xStream->getInputStream();
 661         }
 662         catch(const css::uno::RuntimeException&)
 663             { throw; }
 664         catch(const css::uno::Exception& e)
 665             {
 666                 // ignore exception, if reason was problem reasoned on
 667                 // open it in WRITEABLE mode! Then we try it READONLY
 668                 // later a second time.
 669                 // All other errors must be handled as real error an
 670                 // break this method.
 671                 if (!pInteraction->wasWriteError() || bModeRequestedExplicitly)
 672                 {
 673                     SAL_WARN(
 674                         "unotools.misc",
 675                         "caught Exception \"" << e.Message
 676                             << "\" while opening <" << sURL << ">");
 677                     return false;
 678                 }
 679                 xStream.clear();
 680                 xInputStream.clear();
 681             }
 682     }
 683
 684     // If opening of the stream in read/write mode wasnt allowed
 685     // or failed by an error - we must try it in readonly mode.
 686     if (!xInputStream.is())
 687     {
 688         OUString aScheme;
 689
 690         try
 691         {
 692             css::uno::Reference< css::ucb::XContentIdentifier > xContId(
 693                 aContent.get().is() ? aContent.get()->getIdentifier() : 0 );
 694
 695             if ( xContId.is() )
 696                 aScheme = xContId->getContentProviderScheme();
 697
 698             // Only file system content provider is able to provide XStream
 699             // so for this content impossibility to create XStream triggers
 700             // switch to readonly mode in case of opening with locking on
 701             if( bLockFile && aScheme.equalsIgnoreAsciiCase("file") )
 702                 bReadOnly = true;
 703             else
 704             {
 705                 bool bRequestReadOnly = bReadOnly;
 706                 aContent.getPropertyValue("IsReadOnly") >>= bReadOnly;
 707                 if ( bReadOnly && !bRequestReadOnly && bModeRequestedExplicitly )
 708                         return false; // the document is explicitly requested with WRITEABLE mode
 709             }
 710         }
 711         catch(const css::uno::RuntimeException&)
 712             { throw; }
 713         catch(const css::uno::Exception&)
 714             { /* no error handling if IsReadOnly property does not exist for UCP */ }
 715
 716         if ( bReadOnly )
 717                (*this)[MediaDescriptor::PROP_READONLY()] <<= bReadOnly;
 718
 719         pInteraction->resetInterceptions();
 720         pInteraction->resetErrorStates();
 721         try
 722         {
 723             // all the contents except file-URLs should be opened as usual
 724             if ( bLockFile || !aScheme.equalsIgnoreAsciiCase("file") )
 725                 xInputStream = aContent.openStream();
 726             else
 727                 xInputStream = aContent.openStreamNoLock();
 728         }
 729         catch(const css::uno::RuntimeException&)
 730             { throw; }
 731         catch(const css::uno::Exception& e)
 732             {
 733                 SAL_WARN(
 734                     "unotools.misc",
 735                     "caught Exception \"" << e.Message << "\" while opening <"
 736                         << sURL << ">");
 737                 return false;
 738             }
 739     }
 740
 741     // add streams to the descriptor
 742     if (xContent.is())
 743         (*this)[MediaDescriptor::PROP_UCBCONTENT()] <<= xContent;
 744     if (xStream.is())
 745         (*this)[MediaDescriptor::PROP_STREAM()] <<= xStream;
 746     if (xInputStream.is())
 747         (*this)[MediaDescriptor::PROP_INPUTSTREAM()] <<= xInputStream;
 748
 749     // At least we need an input stream. The r/w stream is optional ...
 750     return xInputStream.is();
 751 }
 752
 753 } // namespace comphelper
 754
 755 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */