ucb/source/core/ucb.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
  21 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  *************************************************************************/
  26 #include <osl/diagnose.h>
  27 #include <sal/log.hxx>
  28 #include <rtl/ustrbuf.hxx>
  29 #include <comphelper/processfactory.hxx>
  30 #include <comphelper/interfacecontainer2.hxx>
  31 #include <comphelper/propertysequence.hxx>
  32 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  33 #include <com/sun/star/ucb/DuplicateProviderException.hpp>
  34 #include <com/sun/star/ucb/GlobalTransferCommandArgument2.hpp>
  35 #include <com/sun/star/ucb/UnsupportedCommandException.hpp>
  36 #include <com/sun/star/ucb/XCommandInfo.hpp>
  37 #include <com/sun/star/ucb/XContentProviderSupplier.hpp>
  38 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  39 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  40 #include <com/sun/star/container/XNameAccess.hpp>
  41 #include <com/sun/star/uno/Any.hxx>
  42 #include <cppuhelper/weak.hxx>
  43 #include <ucbhelper/cancelcommandexecution.hxx>
  44 #include <ucbhelper/macros.hxx>
  45 #include <tools/diagnose_ex.h>
  46 #include "identify.hxx"
  47 #include "ucbcmds.hxx"
  48
  49 #include "ucb.hxx"
  50
  51 using namespace comphelper;
  52 using namespace com::sun::star::uno;
  53 using namespace com::sun::star::lang;
  54 using namespace com::sun::star::ucb;
  55 using namespace ucb_impl;
  56 using namespace com::sun::star;
  57 using namespace ucbhelper;
  58
  59 namespace {
  60
  61 bool fillPlaceholders(OUString const & rInput,
  62                       uno::Sequence< uno::Any > const & rReplacements,
  63                       OUString * pOutput)
  64 {
  65     sal_Unicode const * p = rInput.getStr();
  66     sal_Unicode const * pEnd = p + rInput.getLength();
  67     sal_Unicode const * pCopy = p;
  68     OUStringBuffer aBuffer;
  69     while (p != pEnd)
  70         switch (*p++)
  71         {
  72             case '&':
  73                 if (pEnd - p >= 4
  74                     && p[0] == 'a' && p[1] == 'm' && p[2] == 'p'
  75                     && p[3] == ';')
  76                 {
  77                     aBuffer.append(pCopy, p - 1 - pCopy);
  78                     aBuffer.append('&');
  79                     p += 4;
  80                     pCopy = p;
  81                 }
  82                 else if (pEnd - p >= 3
  83                          && p[0] == 'l' && p[1] == 't' && p[2] == ';')
  84                 {
  85                     aBuffer.append(pCopy, p - 1 - pCopy);
  86                     aBuffer.append('<');
  87                     p += 3;
  88                     pCopy = p;
  89                 }
  90                 else if (pEnd - p >= 3
  91                          && p[0] == 'g' && p[1] == 't' && p[2] == ';')
  92                 {
  93                     aBuffer.append(pCopy, p - 1 - pCopy);
  94                     aBuffer.append('>');
  95                     p += 3;
  96                     pCopy = p;
  97                 }
  98                 break;
  99
 100             case '<':
 101                 sal_Unicode const * q = p;
 102                 while (q != pEnd && *q != '>')
 103                     ++q;
 104                 if (q == pEnd)
 105                     break;
 106                 OUString aKey(p, q - p);
 107                 OUString aValue;
 108                 bool bFound = false;
 109                 for (sal_Int32 i = 2; i + 1 < rReplacements.getLength();
 110                      i += 2)
 111                 {
 112                     OUString aReplaceKey;
 113                     if ((rReplacements[i] >>= aReplaceKey)
 114                         && aReplaceKey == aKey
 115                         && (rReplacements[i + 1] >>= aValue))
 116                     {
 117                         bFound = true;
 118                         break;
 119                     }
 120                 }
 121                 if (!bFound)
 122                     return false;
 123                 aBuffer.append(pCopy, p - 1 - pCopy);
 124                 aBuffer.append(aValue);
 125                 p = q + 1;
 126                 pCopy = p;
 127                 break;
 128         }
 129     aBuffer.append(pCopy, pEnd - pCopy);
 130     *pOutput = aBuffer.makeStringAndClear();
 131     return true;
 132 }
 133
 134 void makeAndAppendXMLName(
 135                 OUStringBuffer & rBuffer, const OUString & rIn )
 136 {
 137     sal_Int32 nCount = rIn.getLength();
 138     for ( sal_Int32 n = 0; n < nCount; ++n )
 139     {
 140         const sal_Unicode c = rIn[ n ];
 141         switch ( c )
 142         {
 143             case '&':
 144                 rBuffer.append( "&amp;" );
 145                 break;
 146
 147             case '"':
 148                 rBuffer.append( "&quot;" );
 149                 break;
 150
 151             case '\'':
 152                 rBuffer.append( "&apos;" );
 153                 break;
 154
 155             case '<':
 156                 rBuffer.append( "&lt;" );
 157                 break;
 158
 159             case '>':
 160                 rBuffer.append( "&gt;" );
 161                 break;
 162
 163             default:
 164                 rBuffer.append( c );
 165                 break;
 166         }
 167     }
 168 }
 169
 170 bool createContentProviderData(
 171     const OUString & rProvider,
 172     const uno::Reference< container::XHierarchicalNameAccess >& rxHierNameAccess,
 173     ContentProviderData & rInfo)
 174 {
 175     // Obtain service name.
 176
 177     OUString aValue;
 178     try
 179     {
 180         if ( !( rxHierNameAccess->getByHierarchicalName(
 181                     rProvider +  "/ServiceName" ) >>= aValue ) )
 182         {
 183             OSL_FAIL( "UniversalContentBroker::getContentProviderData - "
 184                         "Error getting item value!" );
 185         }
 186     }
 187     catch (const container::NoSuchElementException&)
 188     {
 189         return false;
 190     }
 191
 192     rInfo.ServiceName = aValue;
 193
 194     // Obtain URL Template.
 195
 196     if ( !( rxHierNameAccess->getByHierarchicalName(
 197                 rProvider + "/URLTemplate" ) >>= aValue ) )
 198     {
 199         OSL_FAIL( "UniversalContentBroker::getContentProviderData - "
 200                     "Error getting item value!" );
 201     }
 202
 203     rInfo.URLTemplate = aValue;
 204
 205     // Obtain Arguments.
 206
 207     if ( !( rxHierNameAccess->getByHierarchicalName(
 208                 rProvider + "/Arguments" ) >>= aValue ) )
 209     {
 210         OSL_FAIL( "UniversalContentBroker::getContentProviderData - "
 211                     "Error getting item value!" );
 212     }
 213
 214     rInfo.Arguments = aValue;
 215     return true;
 216 }
 217
 218 }
 219
 220
 221 // UniversalContentBroker Implementation.
 222
 223
 224 UniversalContentBroker::UniversalContentBroker(
 225     const Reference< css::uno::XComponentContext >& xContext )
 226 : m_xContext( xContext ),
 227   m_nCommandId( 0 )
 228 {
 229     OSL_ENSURE( m_xContext.is(),
 230                 "UniversalContentBroker ctor: No service manager" );
 231 }
 232
 233
 234 // virtual
 235 UniversalContentBroker::~UniversalContentBroker()
 236 {
 237 }
 238
 239
 240 // XComponent methods.
 241
 242
 243 // virtual
 244 void SAL_CALL UniversalContentBroker::dispose()
 245 {
 246     if ( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() )
 247     {
 248         EventObject aEvt;
 249         aEvt.Source = static_cast< XComponent* >(this);
 250         m_pDisposeEventListeners->disposeAndClear( aEvt );
 251     }
 252
 253     if ( m_xNotifier.is() )
 254         m_xNotifier->removeChangesListener( this );
 255 }
 256
 257
 258 // virtual
 259 void SAL_CALL UniversalContentBroker::addEventListener(
 260                             const Reference< XEventListener >& Listener )
 261 {
 262     if ( !m_pDisposeEventListeners )
 263         m_pDisposeEventListeners.reset( new OInterfaceContainerHelper2( m_aMutex ) );
 264
 265     m_pDisposeEventListeners->addInterface( Listener );
 266 }
 267
 268
 269 // virtual
 270 void SAL_CALL UniversalContentBroker::removeEventListener(
 271                             const Reference< XEventListener >& Listener )
 272 {
 273     if ( m_pDisposeEventListeners )
 274         m_pDisposeEventListeners->removeInterface( Listener );
 275
 276     // Note: Don't want to delete empty container here -> performance.
 277 }
 278
 279
 280 // XServiceInfo methods.
 281
 282 OUString SAL_CALL UniversalContentBroker::getImplementationName()
 283 {
 284     return "com.sun.star.comp.ucb.UniversalContentBroker";
 285 }
 286 sal_Bool SAL_CALL UniversalContentBroker::supportsService( const OUString& ServiceName )
 287 {
 288     return cppu::supportsService( this, ServiceName );
 289 }
 290 css::uno::Sequence< OUString > SAL_CALL UniversalContentBroker::getSupportedServiceNames()
 291 {
 292     return { "com.sun.star.ucb.UniversalContentBroker" };
 293 }
 294
 295
 296 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 297 ucb_UniversalContentBroker_get_implementation(
 298     css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
 299 {
 300     return cppu::acquire(static_cast<cppu::OWeakObject*>(new UniversalContentBroker(context)));
 301 }
 302
 303
 304 // XInitialization methods.
 305
 306
 307 // virtual
 308 void SAL_CALL UniversalContentBroker::initialize( const css::uno::Sequence< Any >& aArguments )
 309 {
 310     {
 311         osl::MutexGuard aGuard(m_aMutex);
 312         if (m_aArguments.hasElements())
 313         {
 314             if (aArguments.hasElements()
 315                 && !(m_aArguments.getLength() == 2
 316                      && aArguments.getLength() == 2
 317                      && m_aArguments[0] == aArguments[0]
 318                      && m_aArguments[1] == aArguments[1]))
 319             {
 320                 throw IllegalArgumentException(
 321                     "UCB reinitialized with different arguments",
 322                     static_cast< cppu::OWeakObject * >(this), 0);
 323             }
 324             return;
 325         }
 326         if (!aArguments.hasElements())
 327         {
 328             m_aArguments.realloc(2);
 329             m_aArguments[0] <<= OUString("Local");
 330             m_aArguments[1] <<= OUString("Office");
 331         }
 332         else
 333         {
 334             m_aArguments = aArguments;
 335         }
 336     }
 337     configureUcb();
 338 }
 339
 340
 341 // XContentProviderManager methods.
 342
 343
 344 // virtual
 345 Reference< XContentProvider > SAL_CALL
 346 UniversalContentBroker::registerContentProvider(
 347                             const Reference< XContentProvider >& Provider,
 348                             const OUString& Scheme,
 349                             sal_Bool ReplaceExisting )
 350 {
 351     osl::MutexGuard aGuard(m_aMutex);
 352
 353     ProviderMap_Impl::iterator aIt;
 354     try
 355     {
 356         aIt = m_aProviders.find(Scheme);
 357     }
 358     catch (const IllegalArgumentException&)
 359     {
 360         return nullptr; //@@@
 361     }
 362
 363     Reference< XContentProvider > xPrevious;
 364     if (aIt == m_aProviders.end())
 365     {
 366         ProviderList_Impl aList;
 367         aList.push_front( ProviderListEntry_Impl(Provider) );
 368         try
 369         {
 370             m_aProviders.add(Scheme, aList);
 371         }
 372         catch (const IllegalArgumentException&)
 373         {
 374             return nullptr; //@@@
 375         }
 376     }
 377     else
 378     {
 379         if (!ReplaceExisting)
 380             throw DuplicateProviderException();
 381
 382         ProviderList_Impl & rList = aIt->getValue();
 383         xPrevious = rList.front().getProvider();
 384         rList.push_front( ProviderListEntry_Impl(Provider) );
 385     }
 386
 387     return xPrevious;
 388 }
 389
 390
 391 // virtual
 392 void SAL_CALL UniversalContentBroker::deregisterContentProvider(
 393                               const Reference< XContentProvider >& Provider,
 394                             const OUString& Scheme )
 395 {
 396     osl::MutexGuard aGuard(m_aMutex);
 397
 398     ProviderMap_Impl::iterator aMapIt;
 399     try
 400     {
 401         aMapIt = m_aProviders.find(Scheme);
 402     }
 403     catch (const IllegalArgumentException&)
 404     {
 405         return; //@@@
 406     }
 407
 408     if (aMapIt != m_aProviders.end())
 409     {
 410         ProviderList_Impl & rList = aMapIt->getValue();
 411
 412         auto aListIt = std::find_if(rList.begin(), rList.end(),
 413             [&Provider](const ProviderListEntry_Impl& rEntry) { return rEntry.getProvider() == Provider; });
 414         if (aListIt != rList.end())
 415             rList.erase(aListIt);
 416
 417         if (rList.empty())
 418             m_aProviders.erase(aMapIt);
 419     }
 420 }
 421
 422
 423 // virtual
 424 css::uno::Sequence< ContentProviderInfo > SAL_CALL
 425                             UniversalContentBroker::queryContentProviders()
 426 {
 427     // Return a list with information about active(!) content providers.
 428
 429     osl::MutexGuard aGuard(m_aMutex);
 430
 431     css::uno::Sequence< ContentProviderInfo > aSeq( m_aProviders.size() );
 432     ContentProviderInfo* pInfo = aSeq.getArray();
 433
 434     ProviderMap_Impl::const_iterator end = m_aProviders.end();
 435     for (ProviderMap_Impl::const_iterator it(m_aProviders.begin()); it != end;
 436          ++it)
 437     {
 438         // Note: Active provider is always the first list element.
 439         pInfo->ContentProvider = it->getValue().front().getProvider();
 440         pInfo->Scheme = it->getRegexp();
 441         ++pInfo;
 442     }
 443
 444     return aSeq;
 445 }
 446
 447
 448 // virtual
 449 Reference< XContentProvider > SAL_CALL
 450         UniversalContentBroker::queryContentProvider( const OUString&
 451                                                           Identifier )
 452 {
 453     return queryContentProvider( Identifier, false );
 454 }
 455
 456
 457 // XContentProvider methods.
 458
 459
 460 // virtual
 461 Reference< XContent > SAL_CALL UniversalContentBroker::queryContent(
 462                         const Reference< XContentIdentifier >& Identifier )
 463 {
 464
 465     // Let the content provider for the scheme given with the content
 466     // identifier create the XContent instance.
 467
 468
 469     if ( !Identifier.is() )
 470         return Reference< XContent >();
 471
 472     Reference< XContentProvider > xProv =
 473         queryContentProvider( Identifier->getContentIdentifier(), true );
 474     if ( xProv.is() )
 475         return  xProv->queryContent( Identifier );
 476
 477     return Reference< XContent >();
 478 }
 479
 480
 481 // virtual
 482 sal_Int32 SAL_CALL UniversalContentBroker::compareContentIds(
 483                                 const Reference< XContentIdentifier >& Id1,
 484                                 const Reference< XContentIdentifier >& Id2 )
 485 {
 486     OUString aURI1( Id1->getContentIdentifier() );
 487     OUString aURI2( Id2->getContentIdentifier() );
 488
 489     Reference< XContentProvider > xProv1
 490                             = queryContentProvider( aURI1, true );
 491     Reference< XContentProvider > xProv2
 492                             = queryContentProvider( aURI2, true );
 493
 494     // When both identifiers belong to the same provider, let that provider
 495     // compare them; otherwise, simply compare the URI strings (which must
 496     // be different):
 497     if ( xProv1.is() && ( xProv1 == xProv2 ) )
 498         return xProv1->compareContentIds( Id1, Id2 );
 499     else
 500         return aURI1.compareTo( aURI2 );
 501 }
 502
 503
 504 // XContentIdentifierFactory methods.
 505
 506
 507 // virtual
 508 Reference< XContentIdentifier > SAL_CALL
 509         UniversalContentBroker::createContentIdentifier(
 510                                             const OUString& ContentId )
 511 {
 512
 513     // Let the content provider for the scheme given with content
 514     // identifier create the XContentIdentifier instance, if he supports
 515     // the XContentIdentifierFactory interface. Otherwise create standard
 516     // implementation object for XContentIdentifier.
 517
 518
 519     Reference< XContentIdentifier > xIdentifier;
 520
 521     Reference< XContentProvider > xProv
 522                             = queryContentProvider( ContentId, true );
 523     if ( xProv.is() )
 524     {
 525         Reference< XContentIdentifierFactory > xFac( xProv, UNO_QUERY );
 526         if ( xFac.is() )
 527             xIdentifier = xFac->createContentIdentifier( ContentId );
 528     }
 529
 530     if ( !xIdentifier.is() )
 531         xIdentifier = new ContentIdentifier( ContentId );
 532
 533     return xIdentifier;
 534 }
 535
 536
 537 // XCommandProcessor methods.
 538
 539
 540 // virtual
 541 sal_Int32 SAL_CALL UniversalContentBroker::createCommandIdentifier()
 542 {
 543     osl::MutexGuard aGuard( m_aMutex );
 544
 545     // Just increase counter on every call to generate an identifier.
 546     return ++m_nCommandId;
 547 }
 548
 549
 550 // virtual
 551 Any SAL_CALL UniversalContentBroker::execute(
 552                           const Command& aCommand,
 553                           sal_Int32,
 554                           const Reference< XCommandEnvironment >& Environment )
 555 {
 556     Any aRet;
 557
 558
 559     // Note: Don't forget to adapt ucb_commands::CommandProcessorInfo
 560     //       ctor in ucbcmds.cxx when adding new commands!
 561
 562
 563     if ( ( aCommand.Handle == GETCOMMANDINFO_HANDLE ) || aCommand.Name == GETCOMMANDINFO_NAME )
 564     {
 565
 566         // getCommandInfo
 567
 568
 569         aRet <<= getCommandInfo();
 570     }
 571     else if ( ( aCommand.Handle == GLOBALTRANSFER_HANDLE ) || aCommand.Name == GLOBALTRANSFER_NAME )
 572     {
 573
 574         // globalTransfer
 575
 576
 577         GlobalTransferCommandArgument2 aTransferArg;
 578         if ( !( aCommand.Argument >>= aTransferArg ) )
 579         {
 580             GlobalTransferCommandArgument aArg;
 581             if ( !( aCommand.Argument >>= aArg ) )
 582             {
 583                 ucbhelper::cancelCommandExecution(
 584                     makeAny( IllegalArgumentException(
 585                                     "Wrong argument type!",
 586                                     static_cast< cppu::OWeakObject * >( this ),
 587                                     -1 ) ),
 588                     Environment );
 589                 // Unreachable
 590             }
 591
 592             // Copy infos into the new structure
 593             aTransferArg.Operation = aArg.Operation;
 594             aTransferArg.SourceURL = aArg.SourceURL;
 595             aTransferArg.TargetURL = aArg.TargetURL;
 596             aTransferArg.NewTitle = aArg.NewTitle;
 597             aTransferArg.NameClash = aArg.NameClash;
 598         }
 599
 600         globalTransfer( aTransferArg, Environment );
 601     }
 602     else if ( ( aCommand.Handle == CHECKIN_HANDLE ) || aCommand.Name == CHECKIN_NAME )
 603     {
 604         ucb::CheckinArgument aCheckinArg;
 605         if ( !( aCommand.Argument >>= aCheckinArg ) )
 606         {
 607             ucbhelper::cancelCommandExecution(
 608                 makeAny( IllegalArgumentException(
 609                                 "Wrong argument type!",
 610                                 static_cast< cppu::OWeakObject * >( this ),
 611                                 -1 ) ),
 612                 Environment );
 613             // Unreachable
 614         }
 615         aRet = checkIn( aCheckinArg, Environment );
 616     }
 617     else
 618     {
 619
 620         // Unknown command
 621
 622
 623         ucbhelper::cancelCommandExecution(
 624             makeAny( UnsupportedCommandException(
 625                             OUString(),
 626                             static_cast< cppu::OWeakObject * >( this ) ) ),
 627             Environment );
 628         // Unreachable
 629     }
 630
 631     return aRet;
 632 }
 633
 634
 635 // XCommandProcessor2 methods.
 636
 637
 638 // virtual
 639 void SAL_CALL UniversalContentBroker::releaseCommandIdentifier(sal_Int32 /*aCommandId*/)
 640 {
 641     // @@@ Not implemented ( yet).
 642 }
 643
 644
 645 // virtual
 646 void SAL_CALL UniversalContentBroker::abort( sal_Int32 )
 647 {
 648     // @@@ Not implemented ( yet).
 649 }
 650
 651
 652 // XChangesListener methods
 653
 654
 655 // virtual
 656 void SAL_CALL UniversalContentBroker::changesOccurred( const util::ChangesEvent& Event )
 657 {
 658     if ( !Event.Changes.hasElements() )
 659         return;
 660
 661     uno::Reference< container::XHierarchicalNameAccess > xHierNameAccess;
 662     Event.Base >>= xHierNameAccess;
 663
 664     OSL_ASSERT( xHierNameAccess.is() );
 665
 666     ContentProviderDataList aData;
 667     for ( const util::ElementChange& rElem : Event.Changes )
 668     {
 669         OUString aKey;
 670         rElem.Accessor >>= aKey;
 671
 672         ContentProviderData aInfo;
 673
 674         // Removal of UCPs from the configuration leads to changesOccurred
 675         // notifications, too, but it is hard to tell for a given
 676         // ElementChange whether it is an addition or a removal, so as a
 677         // heuristic consider as removals those that cause a
 678         // NoSuchElementException in createContentProviderData.
 679
 680         // For now, removal of UCPs from the configuration is simply ignored
 681         // (and not reflected in the UCB's data structures):
 682         if (createContentProviderData(aKey, xHierNameAccess, aInfo))
 683         {
 684             aData.push_back(aInfo);
 685         }
 686     }
 687
 688     prepareAndRegister(aData);
 689 }
 690
 691
 692 // XEventListener methods
 693
 694
 695 // virtual
 696 void SAL_CALL UniversalContentBroker::disposing(const lang::EventObject&)
 697 {
 698     if ( m_xNotifier.is() )
 699     {
 700         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 701
 702         if ( m_xNotifier.is() )
 703             m_xNotifier.clear();
 704     }
 705 }
 706
 707
 708 // Non-interface methods
 709
 710
 711 Reference< XContentProvider > UniversalContentBroker::queryContentProvider(
 712                                 const OUString& Identifier,
 713                                 bool bResolved )
 714 {
 715     osl::MutexGuard aGuard( m_aMutex );
 716
 717     ProviderList_Impl const * pList = m_aProviders.map( Identifier );
 718     return pList ? bResolved ? pList->front().getResolvedProvider()
 719                              : pList->front().getProvider()
 720                  : Reference< XContentProvider >();
 721 }
 722
 723 void UniversalContentBroker::configureUcb()
 724 {
 725     OUString aKey1;
 726     OUString aKey2;
 727     if (m_aArguments.getLength() < 2
 728         || !(m_aArguments[0] >>= aKey1) || !(m_aArguments[1] >>= aKey2))
 729     {
 730         OSL_FAIL("UniversalContentBroker::configureUcb(): Bad arguments");
 731         return;
 732     }
 733
 734     ContentProviderDataList aData;
 735     if (!getContentProviderData(aKey1, aKey2, aData))
 736     {
 737         SAL_WARN( "ucb", "No configuration");
 738         return;
 739     }
 740
 741     prepareAndRegister(aData);
 742 }
 743
 744 void UniversalContentBroker::prepareAndRegister(
 745     const ContentProviderDataList& rData)
 746 {
 747     for (const auto& rContentProviderData : rData)
 748     {
 749         OUString aProviderArguments;
 750         if (fillPlaceholders(rContentProviderData.Arguments,
 751                              m_aArguments,
 752                              &aProviderArguments))
 753         {
 754             registerAtUcb(this,
 755                           m_xContext,
 756                           rContentProviderData.ServiceName,
 757                           aProviderArguments,
 758                           rContentProviderData.URLTemplate);
 759
 760         }
 761         else
 762             OSL_FAIL("UniversalContentBroker::prepareAndRegister(): Bad argument placeholders");
 763     }
 764 }
 765
 766
 767 bool UniversalContentBroker::getContentProviderData(
 768             const OUString & rKey1,
 769             const OUString & rKey2,
 770             ContentProviderDataList & rListToFill )
 771 {
 772     if ( !m_xContext.is() || rKey1.isEmpty() || rKey2.isEmpty() )
 773     {
 774         OSL_FAIL( "UniversalContentBroker::getContentProviderData - Invalid argument!" );
 775         return false;
 776     }
 777
 778     try
 779     {
 780         uno::Reference< lang::XMultiServiceFactory > xConfigProv =
 781                 configuration::theDefaultProvider::get( m_xContext );
 782
 783         OUStringBuffer aFullPath(128);
 784         aFullPath.append(
 785                 "/org.openoffice.ucb.Configuration/ContentProviders"
 786                 "/['" );
 787         makeAndAppendXMLName( aFullPath, rKey1 );
 788         aFullPath.append( "']/SecondaryKeys/['" );
 789         makeAndAppendXMLName( aFullPath, rKey2 );
 790         aFullPath.append( "']/ProviderData" );
 791
 792         uno::Sequence<uno::Any> aArguments(comphelper::InitAnyPropertySequence(
 793         {
 794             {"nodepath", uno::Any(aFullPath.makeStringAndClear())}
 795         }));
 796
 797         uno::Reference< uno::XInterface > xInterface(
 798                 xConfigProv->createInstanceWithArguments(
 799                     "com.sun.star.configuration.ConfigurationAccess",
 800                     aArguments ) );
 801
 802         if ( !m_xNotifier.is() )
 803         {
 804             m_xNotifier.set( xInterface, uno::UNO_QUERY_THROW );
 805
 806             m_xNotifier->addChangesListener( this );
 807         }
 808
 809         uno::Reference< container::XNameAccess > xNameAccess(
 810                                             xInterface, uno::UNO_QUERY_THROW );
 811
 812         const uno::Sequence< OUString > aElems = xNameAccess->getElementNames();
 813
 814         if ( aElems.hasElements() )
 815         {
 816             uno::Reference< container::XHierarchicalNameAccess >
 817                                 xHierNameAccess( xInterface, uno::UNO_QUERY_THROW );
 818
 819             // Iterate over children.
 820             for ( const auto& rElem : aElems )
 821             {
 822
 823                 try
 824                 {
 825
 826                     ContentProviderData aInfo;
 827
 828                     OUStringBuffer aElemBuffer;
 829                     aElemBuffer.append( "['" );
 830                     makeAndAppendXMLName( aElemBuffer, rElem );
 831                     aElemBuffer.append( "']" );
 832
 833                     OSL_VERIFY(
 834                         createContentProviderData(
 835                             aElemBuffer.makeStringAndClear(), xHierNameAccess,
 836                             aInfo));
 837
 838                     rListToFill.push_back( aInfo );
 839                 }
 840                 catch (const container::NoSuchElementException&)
 841                 {
 842                     // getByHierarchicalName
 843                     OSL_FAIL( "UniversalContentBroker::getContentProviderData - "
 844                                 "caught NoSuchElementException!" );
 845                 }
 846             }
 847         }
 848     }
 849     catch (const uno::RuntimeException&)
 850     {
 851         TOOLS_WARN_EXCEPTION( "ucb", "" );
 852         return false;
 853     }
 854     catch (const uno::Exception&)
 855     {
 856         // createInstance, createInstanceWithArguments
 857
 858         TOOLS_WARN_EXCEPTION( "ucb", "" );
 859         return false;
 860     }
 861
 862     return true;
 863 }
 864
 865
 866 // ProviderListEntry_Impl implementation.
 867
 868
 869 Reference< XContentProvider > const & ProviderListEntry_Impl::resolveProvider() const
 870 {
 871     if ( !m_xResolvedProvider.is() )
 872     {
 873         Reference< XContentProviderSupplier > xSupplier(
 874                                                     m_xProvider, UNO_QUERY );
 875         if ( xSupplier.is() )
 876             m_xResolvedProvider = xSupplier->getContentProvider();
 877
 878         if ( !m_xResolvedProvider.is() )
 879             m_xResolvedProvider = m_xProvider;
 880     }
 881
 882     return m_xResolvedProvider;
 883 }
 884
 885 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */