stoc/source/implementationregistration/implreg.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 <string.h>
  21 #include <string_view>
  22 #include <vector>
  23
  24 #include <cppuhelper/exc_hlp.hxx>
  25 #include <cppuhelper/weak.hxx>
  26 #include <cppuhelper/implbase.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <comphelper/sequence.hxx>
  29 #include <rtl/ustring.hxx>
  30 #include <tools/diagnose_ex.h>
  31
  32 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  33 #include <com/sun/star/lang/XServiceInfo.hpp>
  34 #include <com/sun/star/lang/XInitialization.hpp>
  35 #include <com/sun/star/loader/XImplementationLoader.hpp>
  36 #include <com/sun/star/registry/XImplementationRegistration2.hpp>
  37 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  38 #include <com/sun/star/reflection/XServiceTypeDescription.hpp>
  39 #include <com/sun/star/beans/XPropertySet.hpp>
  40 #include <com/sun/star/uno/RuntimeException.hpp>
  41 #include <com/sun/star/uno/XComponentContext.hpp>
  42
  43 #include "mergekeys.hxx"
  44
  45 #if defined(_WIN32)
  46 #include <io.h>
  47 #endif
  48
  49
  50 using namespace com::sun::star;
  51 using namespace css::uno;
  52 using namespace css::loader;
  53 using namespace css::beans;
  54 using namespace css::lang;
  55 using namespace css::registry;
  56 using namespace cppu;
  57 using namespace osl;
  58
  59 namespace {
  60
  61 constexpr OUStringLiteral slash_UNO_slash_REGISTRY_LINKS
  62         = u"/UNO/REGISTRY_LINKS";
  63 constexpr OUStringLiteral slash_IMPLEMENTATIONS
  64         =  u"/IMPLEMENTATIONS";
  65 constexpr OUStringLiteral slash_UNO
  66         = u"/UNO";
  67 constexpr OUStringLiteral slash_UNO_slash_SERVICES
  68         = u"/UNO/SERVICES";
  69 constexpr OUStringLiteral slash_UNO_slash_SINGLETONS
  70         = u"/UNO/SINGLETONS";
  71 constexpr OUStringLiteral slash_SERVICES
  72         = u"/SERVICES/";
  73 constexpr OUStringLiteral slash_UNO_slash_LOCATION
  74         = u"/UNO/LOCATION";
  75 constexpr OUStringLiteral slash_UNO_slash_ACTIVATOR
  76         = u"/UNO/ACTIVATOR";
  77 constexpr OUStringLiteral colon_old
  78         = u":old";
  79 constexpr OUStringLiteral com_sun_star_registry_SimpleRegistry
  80         = u"com.sun.star.registry.SimpleRegistry";
  81 constexpr OUStringLiteral Registry
  82         = u"Registry";
  83
  84 //  static deleteAllLinkReferences()
  85
  86 void deleteAllLinkReferences(const Reference < XSimpleRegistry >& xReg,
  87                                     const Reference < XRegistryKey >& xSource)
  88     // throw ( InvalidRegistryException, RuntimeException )
  89 {
  90     Reference < XRegistryKey > xKey = xSource->openKey(
  91         slash_UNO_slash_REGISTRY_LINKS );
  92
  93     if (!(xKey.is() && (xKey->getValueType() == RegistryValueType_ASCIILIST)))
  94         return;
  95
  96     const Sequence<OUString> linkNames = xKey->getAsciiListValue();
  97
  98     if (!linkNames.hasElements())
  99         return;
 100
 101     OUString            aLinkName;
 102     OUString            aLinkParent;
 103     Reference < XRegistryKey >  xLinkParent;
 104     const sal_Unicode*  pTmpName = nullptr;
 105     const sal_Unicode*  pShortName = nullptr;
 106     sal_Int32           sEnd = 0;
 107
 108     for (const OUString& rLinkName : linkNames)
 109     {
 110         aLinkName = rLinkName;
 111
 112         pTmpName = aLinkName.getStr();
 113
 114         if (pTmpName[0] != L'/')
 115             continue;
 116
 117         sal_Int32 nIndex = rtl_ustr_indexOfChar( pTmpName, '%' );
 118         if ( nIndex == -1 )
 119             pShortName = nullptr;
 120         else
 121             pShortName = pTmpName+nIndex;
 122
 123         while (pShortName && pShortName[1] == L'%')
 124         {
 125             nIndex = rtl_ustr_indexOfChar( pShortName+2, '%' );
 126             if ( nIndex == -1 )
 127                 pShortName = nullptr;
 128             else
 129                 pShortName += nIndex+2;
 130         }
 131
 132         if (pShortName)
 133         {
 134             aLinkName = aLinkName.copy(0, pShortName - pTmpName);
 135         }
 136
 137         xReg->getRootKey()->deleteLink(aLinkName);
 138
 139         sEnd = aLinkName.lastIndexOf( '/' );
 140
 141         aLinkParent = aLinkName.copy(0, sEnd);
 142
 143         while(!aLinkParent.isEmpty())
 144         {
 145             xLinkParent = xReg->getRootKey()->openKey(aLinkParent);
 146
 147             if (xLinkParent.is() && !xLinkParent->getKeyNames().hasElements())
 148             {
 149                 aLinkName = aLinkParent;
 150
 151                 xReg->getRootKey()->deleteKey(aLinkParent);
 152
 153                 sEnd = aLinkName.lastIndexOf( '/' );
 154
 155                 aLinkParent = aLinkName.copy(0, sEnd);
 156             }
 157             else
 158             {
 159                 break;
 160             }
 161         }
 162     }
 163 }
 164
 165
 166 //  static prepareLink
 167
 168 void prepareLink( const Reference < XSimpleRegistry > & xDest,
 169                          const Reference < XRegistryKey > & xSource,
 170                          const OUString& link)
 171     // throw ( InvalidRegistryException, RuntimeException )
 172 {
 173     OUString linkRefName = xSource->getKeyName();
 174     OUString linkName(link);
 175     bool    isRelativ = false;
 176
 177     const sal_Unicode*  pTmpName = link.getStr();
 178     const sal_Unicode*  pShortName;
 179     sal_Int32           nIndex = rtl_ustr_indexOfChar( pTmpName, '%' );
 180     if ( nIndex == -1 )
 181         pShortName = nullptr;
 182     else
 183         pShortName = pTmpName+nIndex;
 184
 185     if (pTmpName[0] != L'/')
 186         isRelativ = true;
 187
 188     while (pShortName && pShortName[1] == L'%')
 189     {
 190         nIndex = rtl_ustr_indexOfChar( pShortName+2, '%' );
 191         if ( nIndex == -1 )
 192             pShortName = nullptr;
 193         else
 194             pShortName += nIndex+2;
 195     }
 196
 197     if (pShortName)
 198     {
 199         linkRefName += link.subView(pShortName - pTmpName + 1);
 200         linkName = link.copy(0, pShortName - pTmpName);
 201     }
 202
 203     if (isRelativ)
 204         xSource->createLink(linkName, linkRefName);
 205     else
 206         xDest->getRootKey()->createLink(linkName, linkRefName);
 207 }
 208
 209
 210 //  static searchImplForLink
 211
 212 OUString searchImplForLink(
 213     const Reference < XRegistryKey > & xRootKey,
 214     std::u16string_view linkName,
 215     std::u16string_view implName )
 216     // throw ( InvalidRegistryException, RuntimeException )
 217 {
 218     Reference < XRegistryKey > xKey = xRootKey->openKey( slash_IMPLEMENTATIONS );
 219     if (xKey.is())
 220     {
 221         const Sequence< Reference < XRegistryKey > > subKeys( xKey->openKeys() );
 222         OUString key_name( slash_UNO + linkName );
 223
 224         for (const Reference < XRegistryKey >& xImplKey : subKeys)
 225         {
 226             try
 227             {
 228                 if (xImplKey->getKeyType( key_name ) == RegistryKeyType_LINK)
 229                 {
 230                     OUString oldImplName = xImplKey->getKeyName().copy(strlen("/IMPLEMENTATIONS/"));
 231                     if (implName != oldImplName)
 232                     {
 233                         return oldImplName;
 234                     }
 235                 }
 236             }
 237             catch(InvalidRegistryException&)
 238             {
 239             }
 240         }
 241     }
 242
 243     return OUString();
 244 }
 245
 246
 247 //  static searchLinkTargetForImpl
 248
 249 OUString searchLinkTargetForImpl(const Reference < XRegistryKey >& xRootKey,
 250                                         std::u16string_view linkName,
 251                                         const OUString& implName)
 252 {
 253     Reference < XRegistryKey > xKey = xRootKey->openKey( slash_IMPLEMENTATIONS );
 254
 255     if (xKey.is())
 256     {
 257         const Sequence< Reference < XRegistryKey > > subKeys = xKey->openKeys();
 258
 259         OUString qualifiedLinkName( slash_UNO + linkName );
 260
 261         auto pSubKey = std::find_if(subKeys.begin(), subKeys.end(),
 262             [&implName, &qualifiedLinkName](const Reference<XRegistryKey>& rSubKey) {
 263                 OUString tmpImplName = rSubKey->getKeyName().copy(strlen("/IMPLEMENTATIONS/"));
 264                 return tmpImplName == implName
 265                     && rSubKey->getKeyType( qualifiedLinkName ) == RegistryKeyType_LINK;
 266             });
 267         if (pSubKey != subKeys.end())
 268             return (*pSubKey)->getLinkTarget( qualifiedLinkName );
 269     }
 270
 271     return OUString();
 272 }
 273
 274
 275 //  static createUniqueSubEntry
 276
 277 void createUniqueSubEntry(const Reference < XRegistryKey > & xSuperKey,
 278                                  const OUString& value)
 279     // throw ( InvalidRegistryException, RuntimeException )
 280 {
 281     if (!xSuperKey.is())
 282         return;
 283
 284     if (xSuperKey->getValueType() == RegistryValueType_ASCIILIST)
 285     {
 286         const Sequence<OUString> implEntries = xSuperKey->getAsciiListValue();
 287         sal_Int32 length = implEntries.getLength();
 288
 289         bool bReady = comphelper::findValue(implEntries, value) != -1;
 290
 291         if (bReady)
 292         {
 293             Sequence<OUString> implEntriesNew(length);
 294             auto it = implEntriesNew.getArray();
 295             *it = value;
 296
 297             std::copy_if(implEntries.begin(), implEntries.end(), std::next(it),
 298                 [&value](const OUString& rEntry) { return rEntry != value; });
 299             xSuperKey->setAsciiListValue(implEntriesNew);
 300         } else
 301         {
 302             Sequence<OUString> implEntriesNew(length+1);
 303             auto it = implEntriesNew.getArray();
 304             *it = value;
 305
 306             std::copy(implEntries.begin(), implEntries.end(), std::next(it));
 307             xSuperKey->setAsciiListValue(implEntriesNew);
 308         }
 309     } else
 310     {
 311         Sequence<OUString> implEntriesNew { value };
 312
 313         xSuperKey->setAsciiListValue(implEntriesNew);
 314     }
 315 }
 316
 317
 318 //  static deleteSubEntry
 319
 320 bool deleteSubEntry(const Reference < XRegistryKey >& xSuperKey, const OUString& value)
 321     // throw ( InvalidRegistryException, RuntimeException )
 322 {
 323     if (xSuperKey->getValueType() == RegistryValueType_ASCIILIST)
 324     {
 325         const Sequence<OUString> implEntries = xSuperKey->getAsciiListValue();
 326         sal_Int32 length = implEntries.getLength();
 327         sal_Int32 equals = static_cast<sal_Int32>(std::count(implEntries.begin(), implEntries.end(), value));
 328         bool hasNoImplementations = false;
 329
 330         if (equals == length)
 331         {
 332             hasNoImplementations = true;
 333         } else
 334         {
 335             Sequence<OUString> implEntriesNew(length - equals);
 336
 337             std::copy_if(implEntries.begin(), implEntries.end(), implEntriesNew.getArray(),
 338                 [&value](const OUString& rEntry) { return rEntry != value; });
 339             xSuperKey->setAsciiListValue(implEntriesNew);
 340         }
 341
 342         if (hasNoImplementations)
 343         {
 344             return true;
 345         }
 346     }
 347     return false;
 348 }
 349
 350
 351 //  static prepareUserLink
 352
 353 void prepareUserLink(const Reference < XSimpleRegistry >& xDest,
 354                                 const OUString& linkName,
 355                                 const OUString& linkTarget,
 356                                 std::u16string_view implName)
 357 {
 358     Reference < XRegistryKey > xRootKey = xDest->getRootKey();
 359
 360     if (xRootKey->getKeyType(linkName) == RegistryKeyType_LINK)
 361     {
 362         OUString oldImplName(searchImplForLink(xRootKey, linkName, implName));
 363
 364         if (!oldImplName.isEmpty())
 365         {
 366             createUniqueSubEntry(xDest->getRootKey()->createKey(
 367                 linkName + colon_old ), oldImplName);
 368         }
 369     }
 370
 371     if (xRootKey->isValid())
 372         xRootKey->createLink(linkName, linkTarget);
 373 }
 374
 375
 376 //  static deleteUserLink
 377
 378 void deletePathIfPossible(const Reference < XRegistryKey >& xRootKey,
 379                                  const OUString& path)
 380 {
 381     try
 382     {
 383         Sequence<OUString> keyNames(xRootKey->openKey(path)->getKeyNames());
 384
 385         if (!keyNames.hasElements() &&
 386             xRootKey->openKey(path)->getValueType() == RegistryValueType_NOT_DEFINED)
 387         {
 388             xRootKey->deleteKey(path);
 389
 390             OUString newPath = path.copy(0, path.lastIndexOf('/'));
 391
 392             if (newPath.getLength() > 1)
 393                 deletePathIfPossible(xRootKey, newPath);
 394         }
 395     }
 396     catch(InvalidRegistryException&)
 397     {
 398     }
 399 }
 400
 401
 402 //  static deleteUserLink
 403
 404 void deleteUserLink(const Reference < XRegistryKey >& xRootKey,
 405                                const OUString& linkName,
 406                                std::u16string_view linkTarget,
 407                                const OUString& implName)
 408     // throw ( InvalidRegistryException, RuntimeException )
 409 {
 410     bool bClean = false;
 411
 412     if (xRootKey->getKeyType(linkName) == RegistryKeyType_LINK)
 413     {
 414         OUString tmpTarget = xRootKey->getLinkTarget(linkName);
 415
 416         if (tmpTarget == linkTarget)
 417         {
 418             xRootKey->deleteLink(linkName);
 419         }
 420     }
 421
 422     Reference < XRegistryKey > xOldKey = xRootKey->openKey(
 423         linkName + colon_old );
 424     if (xOldKey.is())
 425     {
 426         if (xOldKey->getValueType() == RegistryValueType_ASCIILIST)
 427         {
 428             const Sequence<OUString> implEntries = xOldKey->getAsciiListValue();
 429             sal_Int32 length = implEntries.getLength();
 430             sal_Int32 equals = static_cast<sal_Int32>(std::count(implEntries.begin(), implEntries.end(), implName));
 431             bool hasNoImplementations = false;
 432
 433             if (equals == length)
 434             {
 435                 hasNoImplementations = true;
 436             } else
 437             {
 438                 OUString oldImpl;
 439
 440                 if (length > equals + 1)
 441                 {
 442                     Sequence<OUString> implEntriesNew(length - equals - 1);
 443                     auto pNewArray = implEntriesNew.getArray();
 444
 445                     sal_Int32 j = 0;
 446                     bool first = true;
 447                     for (sal_Int32 i = 0; i < length; i++)
 448                     {
 449                         if (implEntries[i] != implName)
 450                         {
 451                             if (first)
 452                             {
 453                                 oldImpl = implEntries[i];
 454                                 first = false;
 455                             } else
 456                             {
 457                                 pNewArray[j++] = implEntries[i];
 458                             }
 459                         }
 460                     }
 461
 462                     xOldKey->setAsciiListValue(implEntriesNew);
 463                 } else
 464                 {
 465                     oldImpl = implEntries[0];
 466                     OUString path(xOldKey->getKeyName());
 467                     xOldKey->closeKey();
 468                     xRootKey->deleteKey(path);
 469                 }
 470
 471                 OUString oldTarget = searchLinkTargetForImpl(xRootKey, linkName, oldImpl);
 472                 if (!oldTarget.isEmpty())
 473                 {
 474                     xRootKey->createLink(linkName, oldTarget);
 475                 }
 476             }
 477
 478             if (hasNoImplementations)
 479             {
 480                 bClean = true;
 481                 OUString path(xOldKey->getKeyName());
 482                 xOldKey->closeKey();
 483                 xRootKey->deleteKey(path);
 484             }
 485         }
 486     } else
 487     {
 488         bClean = true;
 489     }
 490
 491     if (bClean)
 492     {
 493         OUString path = linkName.copy(0, linkName.lastIndexOf('/'));
 494         deletePathIfPossible(xRootKey, path);
 495     }
 496 }
 497
 498
 499 //  static prepareUserKeys
 500
 501 void prepareUserKeys(const Reference < XSimpleRegistry >& xDest,
 502                                 const Reference < XRegistryKey >& xUnoKey,
 503                                 const Reference < XRegistryKey >& xKey,
 504                                 const OUString& implName,
 505                                 bool bRegister)
 506 {
 507     bool hasSubKeys = false;
 508
 509     Sequence<OUString> keyNames = xKey->getKeyNames();
 510
 511     OUString relativKey;
 512     if (keyNames.hasElements())
 513         relativKey = keyNames.getConstArray()[0].copy(xKey->getKeyName().getLength()+1);
 514
 515     if (keyNames.getLength() == 1 &&
 516         xKey->getKeyType(relativKey) == RegistryKeyType_LINK)
 517     {
 518         hasSubKeys = true;
 519
 520         OUString linkTarget = xKey->getLinkTarget(relativKey);
 521         OUString linkName(xKey->getKeyName().copy(xUnoKey->getKeyName().getLength()));
 522
 523         linkName += "/" + relativKey;
 524
 525         if (bRegister)
 526         {
 527             prepareUserLink(xDest, linkName, linkTarget, implName);
 528         } else
 529         {
 530             deleteUserLink(xDest->getRootKey(), linkName, linkTarget, implName);
 531         }
 532     } else
 533     {
 534         const Sequence< Reference < XRegistryKey> > subKeys = xKey->openKeys();
 535
 536         if (subKeys.hasElements())
 537         {
 538             hasSubKeys = true;
 539
 540             for (const Reference < XRegistryKey > & rSubKey : subKeys)
 541             {
 542                 prepareUserKeys(xDest, xUnoKey, rSubKey, implName, bRegister);
 543             }
 544         }
 545     }
 546
 547     if (hasSubKeys)
 548         return;
 549
 550     OUString keyName(xKey->getKeyName().copy(xUnoKey->getKeyName().getLength()));
 551
 552     Reference < XRegistryKey > xRootKey = xDest->getRootKey();
 553     if (bRegister)
 554     {
 555         createUniqueSubEntry(xRootKey->createKey(keyName), implName);
 556     }
 557     else
 558     {
 559         Reference< XRegistryKey > rKey = xRootKey->openKey(keyName);
 560         if( rKey.is() )
 561         {
 562             deleteSubEntry(rKey, implName);
 563             xRootKey->deleteKey(keyName);
 564         }
 565
 566         OUString path = keyName.copy(0, keyName.lastIndexOf('/'));
 567         if( !path.isEmpty() )
 568         {
 569             deletePathIfPossible(xRootKey, path);
 570         }
 571     }
 572 }
 573
 574
 575 //  static deleteAllImplementations
 576
 577 void deleteAllImplementations(   const Reference < XSimpleRegistry >& xReg,
 578                                         const Reference < XRegistryKey >& xSource,
 579                                         std::u16string_view locationUrl,
 580                                         std::vector<OUString> & implNames)
 581     // throw (InvalidRegistryException, RuntimeException)
 582 {
 583     Sequence < Reference < XRegistryKey > > subKeys = xSource->openKeys();
 584
 585     if (subKeys.hasElements())
 586     {
 587         bool hasLocationUrl = false;
 588
 589         for (const Reference < XRegistryKey> & xImplKey : std::as_const(subKeys))
 590         {
 591             Reference < XRegistryKey > xKey = xImplKey->openKey(
 592                 slash_UNO_slash_LOCATION );
 593
 594             if (xKey.is() && (xKey->getValueType() == RegistryValueType_ASCII))
 595             {
 596                 if (xKey->getAsciiValue() == locationUrl)
 597                 {
 598                     hasLocationUrl = true;
 599
 600                     OUString implName(xImplKey->getKeyName().copy(1));
 601                     sal_Int32 firstDot = implName.indexOf('/');
 602
 603                     if (firstDot >= 0)
 604                         implName = implName.copy(firstDot + 1);
 605
 606                     implNames.push_back(implName);
 607
 608                     deleteAllLinkReferences(xReg, xImplKey);
 609
 610                     xKey = xImplKey->openKey( slash_UNO );
 611                     if (xKey.is())
 612                     {
 613                         const Sequence< Reference < XRegistryKey > > subKeys2 = xKey->openKeys();
 614
 615                         for (const Reference < XRegistryKey > & rSubKey2 : subKeys2)
 616                         {
 617                             if (rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SERVICES ) &&
 618                                 rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_REGISTRY_LINKS ) &&
 619                                 rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_ACTIVATOR ) &&
 620                                 rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SINGLETONS ) &&
 621                                 rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_LOCATION) )
 622                             {
 623                                 prepareUserKeys(xReg, xKey, rSubKey2, implName, false);
 624                             }
 625                         }
 626                     }
 627                 }
 628             }
 629
 630             if (hasLocationUrl)
 631             {
 632                 hasLocationUrl = false;
 633                 OUString path(xImplKey->getKeyName());
 634                 xImplKey->closeKey();
 635                 xReg->getRootKey()->deleteKey(path);
 636             }
 637         }
 638
 639         subKeys = xSource->openKeys();
 640         if (!subKeys.hasElements())
 641         {
 642             OUString path(xSource->getKeyName());
 643             xSource->closeKey();
 644             xReg->getRootKey()->deleteKey(path);
 645         }
 646     } else
 647     {
 648         OUString path(xSource->getKeyName());
 649         xSource->closeKey();
 650         xReg->getRootKey()->deleteKey(path);
 651     }
 652 }
 653
 654
 655 void delete_all_singleton_entries(
 656     Reference < registry::XRegistryKey > const & xSingletons_section,
 657     ::std::vector< OUString > const & impl_names )
 658     // throw (InvalidRegistryException, RuntimeException)
 659 {
 660     Sequence< Reference< registry::XRegistryKey > > singletons( xSingletons_section->openKeys() );
 661     Reference< registry::XRegistryKey > const * subkeys = singletons.getConstArray();
 662     for ( sal_Int32 nPos = singletons.getLength(); nPos--; )
 663     {
 664         Reference< registry::XRegistryKey > const & xSingleton = subkeys[ nPos ];
 665         Reference< registry::XRegistryKey > xRegisteredImplNames(
 666             xSingleton->openKey( "REGISTERED_BY" ) );
 667         if (xRegisteredImplNames.is() && xRegisteredImplNames->isValid())
 668         {
 669             Sequence< OUString > registered_implnames;
 670             try
 671             {
 672                 registered_implnames = xRegisteredImplNames->getAsciiListValue();
 673             }
 674             catch (registry::InvalidValueException &)
 675             {
 676             }
 677             OUString const * p = registered_implnames.getConstArray();
 678             sal_Int32 nOrigRegLength = registered_implnames.getLength();
 679             sal_Int32 nNewLength = nOrigRegLength;
 680             for ( sal_Int32 n = nOrigRegLength; n--; )
 681             {
 682                 OUString const & registered_implname = p[ n ];
 683
 684                 for (auto const& impl_name : impl_names)
 685                 {
 686                     if (impl_name == registered_implname)
 687                     {
 688                         registered_implnames[ n ] = p[ nNewLength -1 ];
 689                         --nNewLength;
 690                     }
 691                 }
 692             }
 693
 694             if (nNewLength != nOrigRegLength)
 695             {
 696                 if (0 == nNewLength)
 697                 {
 698                     // remove whole entry
 699                     xRegisteredImplNames->closeKey();
 700                     xSingleton->deleteKey( "REGISTERED_BY" );
 701                     // registry key cannot provide its relative name, only absolute :(
 702                     OUString abs( xSingleton->getKeyName() );
 703                     xSingletons_section->deleteKey( abs.copy( abs.lastIndexOf( '/' ) +1 ) );
 704                 }
 705                 else
 706                 {
 707                     registered_implnames.realloc( nNewLength );
 708                     xRegisteredImplNames->setAsciiListValue( registered_implnames );
 709                 }
 710             }
 711         }
 712     }
 713 }
 714
 715
 716 //  static deleteAllServiceEntries
 717
 718 void deleteAllServiceEntries(    const Reference < XSimpleRegistry >& xReg,
 719                                         const Reference < XRegistryKey >& xSource,
 720                                         const OUString& implName)
 721     // throw ( InvalidRegistryException, RuntimeException )
 722 {
 723     Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys();
 724
 725     if (subKeys.hasElements())
 726     {
 727         bool hasNoImplementations = false;
 728
 729         for (const Reference < XRegistryKey > & xServiceKey : std::as_const(subKeys))
 730         {
 731             if (xServiceKey->getValueType() == RegistryValueType_ASCIILIST)
 732             {
 733                 const Sequence<OUString> implEntries = xServiceKey->getAsciiListValue();
 734                 sal_Int32 length = implEntries.getLength();
 735                 sal_Int32 equals = static_cast<sal_Int32>(std::count(implEntries.begin(), implEntries.end(), implName));
 736
 737                 if (equals == length)
 738                 {
 739                     hasNoImplementations = true;
 740                 } else
 741                 {
 742                     if (equals > 0)
 743                     {
 744                         Sequence<OUString> implEntriesNew(length-equals);
 745
 746                         std::copy_if(implEntries.begin(), implEntries.end(), implEntriesNew.getArray(),
 747                             [&implName](const OUString& rEntry) { return rEntry != implName; });
 748
 749                         xServiceKey->setAsciiListValue(implEntriesNew);
 750                     }
 751                 }
 752             }
 753
 754             if (hasNoImplementations)
 755             {
 756                 hasNoImplementations = false;
 757                 OUString path(xServiceKey->getKeyName());
 758                 xServiceKey->closeKey();
 759                 xReg->getRootKey()->deleteKey(path);
 760             }
 761         }
 762
 763         subKeys = xSource->openKeys();
 764         if (!subKeys.hasElements())
 765         {
 766             OUString path(xSource->getKeyName());
 767             xSource->closeKey();
 768             xReg->getRootKey()->deleteKey(path);
 769         }
 770     } else
 771     {
 772         OUString path(xSource->getKeyName());
 773         xSource->closeKey();
 774         xReg->getRootKey()->deleteKey(path);
 775     }
 776 }
 777
 778
 779 bool is_supported_service(
 780     OUString const & service_name,
 781     Reference< reflection::XServiceTypeDescription > const & xService_td )
 782 {
 783     if (xService_td->getName() == service_name)
 784         return true;
 785     const Sequence< Reference< reflection::XServiceTypeDescription > > seq(
 786         xService_td->getMandatoryServices() );
 787     return std::any_of(seq.begin(), seq.end(), [&service_name](const auto& rService) {
 788         return is_supported_service( service_name, rService ); });
 789 }
 790
 791
 792 void insert_singletons(
 793     Reference< registry::XSimpleRegistry > const & xDest,
 794     Reference< registry::XRegistryKey > const & xImplKey,
 795     Reference< XComponentContext > const & xContext )
 796     // throw( registry::InvalidRegistryException, registry::CannotRegisterImplementationException, RuntimeException )
 797 {
 798     // singletons
 799     Reference< registry::XRegistryKey > xKey( xImplKey->openKey( "UNO/SINGLETONS" ) );
 800     if (!(xKey.is() && xKey->isValid()))
 801         return;
 802
 803     OUString implname( xImplKey->getKeyName().copy( sizeof ("/IMPLEMENTATIONS/") -1 ) );
 804     // singleton entries
 805     Sequence< Reference< registry::XRegistryKey > > xSingletons_section( xKey->openKeys() );
 806     Reference< registry::XRegistryKey > const * p = xSingletons_section.getConstArray();
 807     for ( sal_Int32 nPos = xSingletons_section.getLength(); nPos--; )
 808     {
 809         Reference< registry::XRegistryKey > const & xSingleton = p[ nPos ];
 810         OUString singleton_name(
 811             xSingleton->getKeyName().copy(
 812                 implname.getLength() + sizeof ("/IMPLEMENTATIONS//UNO/SINGLETONS/") -1 ) );
 813         OUString service_name( xSingleton->getStringValue() );
 814
 815         OUString keyname( "/SINGLETONS/" + singleton_name );
 816         Reference< registry::XRegistryKey > xKey2( xDest->getRootKey()->openKey( keyname ) );
 817         if (xKey2.is() && xKey2->isValid())
 818         {
 819             try
 820             {
 821                 OUString existing_name( xKey2->getStringValue() );
 822                 if ( existing_name != service_name )
 823                 {
 824                     Reference< container::XHierarchicalNameAccess > xTDMgr;
 825                     OUString the_tdmgr =
 826                         "/singletons/com.sun.star.reflection.theTypeDescriptionManager";
 827                     xContext->getValueByName( the_tdmgr ) >>= xTDMgr;
 828                     if (! xTDMgr.is())
 829                     {
 830                         throw RuntimeException( "cannot get singleton " + the_tdmgr );
 831                     }
 832                     try
 833                     {
 834                         Reference< reflection::XServiceTypeDescription > xExistingService_td;
 835                         xTDMgr->getByHierarchicalName( existing_name ) >>= xExistingService_td;
 836                         if (! xExistingService_td.is())
 837                         {
 838                             throw RuntimeException( "cannot get service type description: " + existing_name );
 839                         }
 840
 841                         // everything's fine if existing service entry supports the one
 842                         // to be registered
 843                         if (! is_supported_service( service_name, xExistingService_td ))
 844                         {
 845                             throw registry::CannotRegisterImplementationException(
 846                                 "existing singleton service (" + singleton_name + "=" + existing_name + ") "
 847                                 " does not support given one: " + service_name);
 848                         }
 849                     }
 850                     catch (const container::NoSuchElementException & exc)
 851                     {
 852                         css::uno::Any anyEx = cppu::getCaughtException();
 853                         throw css::lang::WrappedTargetRuntimeException(
 854                                 "cannot get service type description: " + exc.Message,
 855                                 nullptr, anyEx );
 856                     }
 857                 }
 858             }
 859             catch (registry::InvalidValueException &)
 860             {
 861                 // repair
 862                 xKey2->setStringValue( service_name );
 863             }
 864         }
 865         else
 866         {
 867             // insert singleton entry
 868             xKey2 = xDest->getRootKey()->createKey( keyname );
 869             xKey2->setStringValue( service_name );
 870         }
 871
 872         Reference< registry::XRegistryKey > xRegisteredImplNames(
 873             xKey2->openKey( "REGISTERED_BY" ) );
 874         if (!xRegisteredImplNames.is() || !xRegisteredImplNames->isValid())
 875         {
 876             // create
 877             xRegisteredImplNames = xKey2->createKey( "REGISTERED_BY" );
 878         }
 879
 880         Sequence< OUString > implnames;
 881         try
 882         {
 883             implnames = xRegisteredImplNames->getAsciiListValue();
 884         }
 885         catch (registry::InvalidValueException &)
 886         {
 887         }
 888         // check implname is already in
 889         if (comphelper::findValue(implnames, implname) == -1)
 890         {
 891             // append and write back
 892             implnames.realloc( implnames.getLength() +1 );
 893             implnames[ implnames.getLength() -1 ] = implname;
 894             xRegisteredImplNames->setAsciiListValue( implnames );
 895         }
 896     }
 897 }
 898
 899
 900 //  static prepareRegistry
 901
 902 void prepareRegistry(
 903     const Reference < XSimpleRegistry >& xDest,
 904     const Reference < XRegistryKey >& xSource,
 905     const OUString& implementationLoaderUrl,
 906     const OUString& locationUrl,
 907     Reference< XComponentContext > const & xContext )
 908     // throw ( InvalidRegistryException, CannotRegisterImplementationException, RuntimeException )
 909 {
 910     const Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys();
 911
 912     if (!subKeys.hasElements())
 913     {
 914         throw InvalidRegistryException(
 915             "prepareRegistry(): source registry is empty" );
 916     }
 917
 918     for (const Reference < XRegistryKey >& xImplKey : subKeys)
 919     {
 920         Reference < XRegistryKey >  xKey = xImplKey->openKey(
 921             slash_UNO_slash_SERVICES );
 922
 923         if (xKey.is())
 924         {
 925             // update entries in SERVICES section
 926             const Sequence< Reference < XRegistryKey > > serviceKeys = xKey->openKeys();
 927
 928             OUString implName = xImplKey->getKeyName().copy(1);
 929             sal_Int32 firstDot = implName.indexOf('/');
 930
 931             if (firstDot >= 0)
 932                 implName = implName.copy(firstDot + 1);
 933
 934             sal_Int32 offset = xKey->getKeyName().getLength() + 1;
 935
 936             for (const Reference < XRegistryKey >& rServiceKey : serviceKeys)
 937             {
 938                 OUString serviceName = rServiceKey->getKeyName().copy(offset);
 939
 940                 createUniqueSubEntry(
 941                     xDest->getRootKey()->createKey(
 942                         slash_SERVICES + serviceName ),
 943                     implName);
 944             }
 945
 946             xKey = xImplKey->openKey( slash_UNO );
 947             if (xKey.is())
 948             {
 949                 const Sequence< Reference < XRegistryKey > > subKeys2 = xKey->openKeys();
 950
 951                 for (const Reference < XRegistryKey >& rSubKey2 : subKeys2)
 952                 {
 953                     if (rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SERVICES) &&
 954                         rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_REGISTRY_LINKS ) &&
 955                         rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SINGLETONS ))
 956                     {
 957                         prepareUserKeys(xDest, xKey, rSubKey2, implName, true);
 958                     }
 959                 }
 960             }
 961         }
 962
 963         // update LOCATION entry
 964         xKey = xImplKey->createKey( slash_UNO_slash_LOCATION );
 965
 966         if (xKey.is())
 967         {
 968             xKey->setAsciiValue(locationUrl);
 969         }
 970
 971         // update ACTIVATOR entry
 972         xKey = xImplKey->createKey( slash_UNO_slash_ACTIVATOR );
 973
 974         if (xKey.is())
 975         {
 976             xKey->setAsciiValue(implementationLoaderUrl);
 977         }
 978
 979         xKey = xImplKey->openKey( slash_UNO_slash_SERVICES );
 980
 981         if (xKey.is() && (xKey->getValueType() == RegistryValueType_ASCIILIST))
 982         {
 983             // update link entries in REGISTRY_LINKS section
 984             const Sequence<OUString> linkNames = xKey->getAsciiListValue();
 985
 986             for (const OUString& rLinkName : linkNames)
 987             {
 988                 prepareLink(xDest, xImplKey, rLinkName);
 989             }
 990         }
 991
 992         insert_singletons( xDest, xImplKey, xContext );
 993     }
 994 }
 995
 996
 997 void findImplementations(    const Reference < XRegistryKey > & xSource,
 998                                     std::vector<OUString>& implNames)
 999 {
1000     bool isImplKey = false;
1001
1002     try
1003     {
1004         Reference < XRegistryKey > xKey = xSource->openKey(
1005             slash_UNO_slash_SERVICES );
1006
1007         if (xKey.is() && xKey->getKeyNames().hasElements())
1008         {
1009             isImplKey = true;
1010
1011             OUString implName = xSource->getKeyName().copy(1).replace('/', '.');
1012             sal_Int32 firstDot = implName.indexOf('.');
1013
1014             if (firstDot >= 0)
1015                 implName = implName.copy(firstDot + 1);
1016
1017             implNames.push_back(implName);
1018         }
1019     }
1020     catch(InvalidRegistryException&)
1021     {
1022     }
1023
1024     if (isImplKey) return;
1025
1026     try
1027     {
1028         const Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys();
1029
1030         for (const Reference < XRegistryKey >& rSubKey : subKeys)
1031         {
1032             findImplementations(rSubKey, implNames);
1033         }
1034     }
1035     catch(InvalidRegistryException&)
1036     {
1037     }
1038 }
1039
1040
1041 class ImplementationRegistration
1042     : public WeakImplHelper< XImplementationRegistration2, XServiceInfo, XInitialization >
1043 {
1044 public:
1045     explicit ImplementationRegistration( const Reference < XComponentContext > & rSMgr );
1046
1047     // XServiceInfo
1048     OUString                        SAL_CALL getImplementationName() override;
1049     sal_Bool                        SAL_CALL supportsService(const OUString& ServiceName) override;
1050     Sequence< OUString >            SAL_CALL getSupportedServiceNames() override;
1051
1052     // XImplementationRegistration
1053     virtual void SAL_CALL registerImplementation(
1054         const OUString& implementationLoader,
1055         const OUString& location,
1056         const Reference < XSimpleRegistry > & xReg) override;
1057
1058     virtual sal_Bool SAL_CALL revokeImplementation(
1059         const OUString& location,
1060         const Reference < XSimpleRegistry >& xReg) override;
1061
1062     virtual Sequence< OUString > SAL_CALL getImplementations(
1063         const OUString& implementationLoader,
1064         const OUString& location) override;
1065     virtual Sequence< OUString > SAL_CALL checkInstantiation(
1066         const OUString& implementationName) override;
1067
1068     // XImplementationRegistration2
1069     virtual void SAL_CALL registerImplementationWithLocation(
1070         const OUString& implementationLoader,
1071         const OUString& location,
1072         const OUString& registeredLocation,
1073         const Reference < XSimpleRegistry > & xReg) override;
1074
1075     // XInitialization
1076     virtual void SAL_CALL initialize(
1077         const css::uno::Sequence< css::uno::Any >& aArguments ) override;
1078
1079 private: // helper methods
1080     void prepareRegister(
1081         const OUString& implementationLoader,
1082         const OUString& location,
1083         const OUString& registeredLocation,
1084         const Reference < XSimpleRegistry > & xReg);
1085     // throw( CannotRegisterImplementationException, RuntimeException )
1086
1087     static void doRegister( const Reference < XMultiComponentFactory >& xSMgr,
1088                             const Reference < XComponentContext > &xCtx,
1089                             const Reference < XImplementationLoader >& xAct,
1090                             const Reference < XSimpleRegistry >& xDest,
1091                             const OUString& implementationLoaderUrl,
1092                             const OUString& locationUrl,
1093                             const OUString& registeredLocationUrl);
1094         /* throw ( InvalidRegistryException,
1095                    MergeConflictException,
1096                    CannotRegisterImplementationException, RuntimeException ) */
1097
1098     static void doRevoke( const Reference < XSimpleRegistry >& xDest,
1099                           std::u16string_view locationUrl );
1100         // throw( InvalidRegistryException, RuntimeException )
1101     Reference< XSimpleRegistry > getRegistryFromServiceManager() const;
1102
1103     static Reference< XSimpleRegistry > createTemporarySimpleRegistry(
1104         const Reference< XMultiComponentFactory > &rSMgr,
1105         const Reference < XComponentContext > & rCtx );
1106
1107 private: // members
1108     Reference < XMultiComponentFactory >    m_xSMgr;
1109     Reference < XComponentContext >         m_xCtx;
1110 };
1111
1112
1113 // ImplementationRegistration()
1114
1115 ImplementationRegistration::ImplementationRegistration( const Reference < XComponentContext > & xCtx )
1116     : m_xSMgr( xCtx->getServiceManager() )
1117     , m_xCtx( xCtx )
1118 {}
1119
1120 // XServiceInfo
1121 OUString ImplementationRegistration::getImplementationName()
1122 {
1123     return "com.sun.star.comp.stoc.ImplementationRegistration";
1124 }
1125
1126 // XServiceInfo
1127 sal_Bool ImplementationRegistration::supportsService(const OUString& ServiceName)
1128 {
1129     return cppu::supportsService(this, ServiceName);
1130 }
1131
1132 // XServiceInfo
1133 Sequence< OUString > ImplementationRegistration::getSupportedServiceNames()
1134 {
1135     return { "com.sun.star.registry.ImplementationRegistration" };
1136 }
1137
1138 Reference< XSimpleRegistry > ImplementationRegistration::getRegistryFromServiceManager() const
1139 {
1140     Reference < XPropertySet > xPropSet( m_xSMgr, UNO_QUERY );
1141     Reference < XSimpleRegistry > xRegistry;
1142
1143     if( xPropSet.is() ) {
1144
1145         try {  // the implementation does not support XIntrospectionAccess !
1146
1147             Any aAny = xPropSet->getPropertyValue( Registry );
1148
1149             if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE ) {
1150                 aAny >>= xRegistry;
1151             }
1152          }
1153          catch( UnknownPropertyException & ) {
1154              // empty reference is error signal !
1155         }
1156     }
1157
1158     return xRegistry;
1159 }
1160
1161
1162 // XInitialization
1163
1164 void ImplementationRegistration::initialize(
1165     const css::uno::Sequence< css::uno::Any >& aArgs )
1166 {
1167
1168     if( aArgs.getLength() != 4 ) {
1169         throw IllegalArgumentException(
1170             "ImplementationRegistration::initialize() expects 4 parameters, got "  + OUString::number( aArgs.getLength() ),
1171             Reference<XInterface > (), 0 );
1172     }
1173
1174     Reference< XImplementationLoader > rLoader;
1175     OUString loaderServiceName;
1176     OUString locationUrl;
1177     Reference< XSimpleRegistry > rReg;
1178
1179     // 1st argument : An instance of an implementation loader
1180     if( aArgs.getConstArray()[0].getValueType().getTypeClass() == TypeClass_INTERFACE ) {
1181         aArgs.getConstArray()[0] >>= rLoader;
1182     }
1183     if( !rLoader.is()) {
1184         throw IllegalArgumentException(
1185             "ImplementationRegistration::initialize() invalid first parameter,"
1186             "expected " + cppu::UnoType<decltype(rLoader)>::get().getTypeName() +
1187             ", got " + aArgs.getConstArray()[0].getValueTypeName(),
1188             Reference< XInterface > (), 0 );
1189     }
1190
1191     // 2nd argument : The service name of the loader. This name is written into the registry
1192     if( aArgs.getConstArray()[1].getValueType().getTypeClass() == TypeClass_STRING ) {
1193         aArgs.getConstArray()[1] >>= loaderServiceName;
1194     }
1195     if( loaderServiceName.isEmpty() ) {
1196         throw IllegalArgumentException(
1197             "ImplementationRegistration::initialize() invalid second parameter,"
1198             "expected string, got " + aArgs.getConstArray()[1].getValueTypeName(),
1199             Reference< XInterface > (), 0 );
1200     }
1201
1202     // 3rd argument : The file name of the dll, that contains the loader
1203     if( aArgs.getConstArray()[2].getValueType().getTypeClass() == TypeClass_STRING ) {
1204         aArgs.getConstArray()[2] >>= locationUrl;
1205     }
1206     if( locationUrl.isEmpty() ) {
1207         throw IllegalArgumentException(
1208             "ImplementationRegistration::initialize() invalid third parameter,"
1209             "expected string, got " + aArgs.getConstArray()[2].getValueTypeName(),
1210             Reference< XInterface > (), 0 );
1211     }
1212
1213     // 4th argument : The registry, the service should be written to
1214     if( aArgs.getConstArray()[3].getValueType().getTypeClass() == TypeClass_INTERFACE ) {
1215         aArgs.getConstArray()[3] >>= rReg;
1216     }
1217
1218     if( !rReg.is() ) {
1219         rReg = getRegistryFromServiceManager();
1220         if( !rReg.is() ) {
1221             throw IllegalArgumentException(
1222                 "ImplementationRegistration::initialize() invalid fourth parameter,"
1223                 "expected " + cppu::UnoType<decltype(rReg)>::get().getTypeName() +
1224                 ", got " + aArgs.getConstArray()[3].getValueTypeName(),
1225                 Reference< XInterface > (), 0 );
1226         }
1227     }
1228
1229     doRegister(m_xSMgr, m_xCtx, rLoader , rReg, loaderServiceName , locationUrl, locationUrl);
1230 }
1231
1232
1233 // virtual function registerImplementationWithLocation of XImplementationRegistration2
1234
1235 void ImplementationRegistration::registerImplementationWithLocation(
1236     const OUString& implementationLoaderUrl,
1237     const OUString& locationUrl,
1238     const OUString& registeredLocationUrl,
1239     const Reference < XSimpleRegistry > & xReg)
1240 {
1241     prepareRegister(
1242         implementationLoaderUrl, locationUrl, registeredLocationUrl, xReg);
1243 }
1244
1245 // helper function
1246 void ImplementationRegistration::prepareRegister(
1247     const OUString& implementationLoaderUrl,
1248     const OUString& locationUrl,
1249     const OUString& registeredLocationUrl,
1250     const Reference < XSimpleRegistry > & xReg)
1251     // throw( CannotRegisterImplementationException, RuntimeException )
1252 {
1253     OUString activatorName;
1254
1255     if (!implementationLoaderUrl.isEmpty())
1256     {
1257         activatorName = implementationLoaderUrl.getToken(0, ':');
1258     } else
1259     {
1260         // check locationUrl to find out what kind of loader is needed
1261         // set implLoaderUrl
1262     }
1263
1264     if( !m_xSMgr.is() )    {
1265         throw CannotRegisterImplementationException(
1266                 "ImplementationRegistration::registerImplementation() "
1267                 "no componentcontext available to instantiate loader" );
1268     }
1269
1270     try
1271     {
1272         Reference < XImplementationLoader > xAct(
1273             m_xSMgr->createInstanceWithContext(activatorName, m_xCtx) , UNO_QUERY );
1274         if (!xAct.is())
1275         {
1276             throw CannotRegisterImplementationException(
1277                 "ImplementationRegistration::registerImplementation() - The service "
1278                 + activatorName + " cannot be instantiated" );
1279         }
1280
1281         Reference < XSimpleRegistry > xRegistry;
1282
1283         if (xReg.is())
1284         {
1285             // registry supplied by user
1286             xRegistry = xReg;
1287         }
1288         else
1289         {
1290             xRegistry = getRegistryFromServiceManager();
1291         }
1292
1293         if ( xRegistry.is())
1294         {
1295             doRegister(m_xSMgr, m_xCtx, xAct, xRegistry, implementationLoaderUrl,
1296                        locationUrl, registeredLocationUrl);
1297         }
1298
1299     }
1300     catch( CannotRegisterImplementationException & )
1301     {
1302         throw;
1303     }
1304     catch( const InvalidRegistryException & e )
1305     {
1306         throw CannotRegisterImplementationException(
1307             "ImplementationRegistration::registerImplementation() "
1308             "InvalidRegistryException during registration (" + e.Message + ")" );
1309     }
1310     catch( const MergeConflictException & e )
1311     {
1312         throw CannotRegisterImplementationException(
1313             "ImplementationRegistration::registerImplementation() "
1314             "MergeConflictException during registration (" + e.Message + ")" );
1315     }
1316
1317 }
1318
1319
1320 // virtual function registerImplementation of XImplementationRegistration
1321
1322 void ImplementationRegistration::registerImplementation(
1323     const OUString& implementationLoaderUrl,
1324     const OUString& locationUrl,
1325     const Reference < XSimpleRegistry > & xReg)
1326 {
1327     prepareRegister(implementationLoaderUrl, locationUrl, locationUrl, xReg);
1328 }
1329
1330
1331 // virtual function revokeImplementation of XImplementationRegistration
1332
1333 sal_Bool ImplementationRegistration::revokeImplementation(const OUString& location,
1334                                                       const Reference < XSimpleRegistry >& xReg)
1335 {
1336     bool ret = false;
1337
1338     Reference < XSimpleRegistry > xRegistry;
1339
1340     if (xReg.is()) {
1341         xRegistry = xReg;
1342     }
1343     else {
1344         Reference < XPropertySet > xPropSet( m_xSMgr, UNO_QUERY );
1345         if( xPropSet.is() ) {
1346             try {
1347                 Any aAny = xPropSet->getPropertyValue( Registry );
1348
1349                 if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE )
1350                 {
1351                     aAny >>= xRegistry;
1352                 }
1353             }
1354             catch ( UnknownPropertyException & ) {
1355             }
1356         }
1357     }
1358
1359     if (xRegistry.is())
1360     {
1361         try
1362         {
1363             doRevoke(xRegistry, location);
1364             ret = true;
1365         }
1366         catch( InvalidRegistryException & )
1367         {
1368             // no way to transport the error, as no exception is specified and a runtime
1369             // exception is not appropriate.
1370             TOOLS_WARN_EXCEPTION( "stoc", "InvalidRegistryException during revokeImplementation" );
1371         }
1372     }
1373
1374     return ret;
1375 }
1376
1377
1378 // virtual function getImplementations of XImplementationRegistration
1379
1380 Sequence< OUString > ImplementationRegistration::getImplementations(
1381     const OUString & implementationLoaderUrl,
1382     const OUString & locationUrl)
1383 {
1384     OUString activatorName;
1385
1386     if (!implementationLoaderUrl.isEmpty())
1387     {
1388         activatorName = implementationLoaderUrl.getToken(0, ':');
1389     } else
1390     {
1391         // check locationUrl to find out what kind of loader is needed
1392         // set implementationLoaderUrl
1393     }
1394
1395     if( m_xSMgr.is() ) {
1396
1397         Reference < XImplementationLoader > xAct(
1398             m_xSMgr->createInstanceWithContext( activatorName, m_xCtx ), UNO_QUERY );
1399
1400         if (xAct.is())
1401         {
1402
1403             Reference < XSimpleRegistry > xReg =
1404                 createTemporarySimpleRegistry( m_xSMgr, m_xCtx);
1405
1406             if (xReg.is())
1407             {
1408                 try
1409                 {
1410                     xReg->open(OUString() /* in mem */, false, true);
1411                     Reference < XRegistryKey > xImpl;
1412
1413                     { // only necessary for deleting the temporary variable of rootkey
1414                         xImpl = xReg->getRootKey()->createKey( slash_IMPLEMENTATIONS );
1415                     }
1416                     if (xAct->writeRegistryInfo(xImpl, implementationLoaderUrl, locationUrl))
1417                     {
1418                         std::vector<OUString> implNames;
1419
1420                         findImplementations(xImpl, implNames);
1421
1422                         if (!implNames.empty())
1423                         {
1424                             Sequence<OUString> seqImpl(comphelper::containerToSequence(implNames));
1425                             xImpl->closeKey();
1426                             return seqImpl;
1427                         }
1428                     }
1429
1430                     xImpl->closeKey();
1431                 }
1432                 catch(MergeConflictException&)
1433                 {
1434                 }
1435                 catch(InvalidRegistryException&)
1436                 {
1437                 }
1438             }
1439         }
1440     }
1441
1442     return Sequence<OUString>();
1443 }
1444
1445
1446 // virtual function checkInstantiation of XImplementationRegistration
1447
1448 Sequence< OUString > ImplementationRegistration::checkInstantiation(const OUString&)
1449 {
1450     OSL_FAIL( "ImplementationRegistration::checkInstantiation not implemented" );
1451     return Sequence<OUString>();
1452 }
1453
1454
1455 // helper function doRegistration
1456
1457
1458 void ImplementationRegistration::doRevoke(
1459     const Reference < XSimpleRegistry >& xDest,
1460     std::u16string_view locationUrl)
1461     // throw ( InvalidRegistryException, RuntimeException )
1462 {
1463     if( !xDest.is() )
1464         return;
1465
1466     std::vector<OUString> aNames;
1467
1468     Reference < XRegistryKey > xRootKey( xDest->getRootKey() );
1469
1470     Reference < XRegistryKey > xKey =
1471         xRootKey->openKey( slash_IMPLEMENTATIONS );
1472     if (xKey.is() && xKey->isValid())
1473     {
1474         deleteAllImplementations(xDest, xKey, locationUrl, aNames);
1475     }
1476
1477     xKey = xRootKey->openKey( slash_SERVICES );
1478     if (xKey.is())
1479     {
1480         for (auto const& name : aNames)
1481         {
1482             deleteAllServiceEntries(xDest, xKey, name);
1483         }
1484     }
1485
1486     xKey = xRootKey->openKey( "/SINGLETONS" );
1487     if (xKey.is() && xKey->isValid())
1488     {
1489         delete_all_singleton_entries( xKey, aNames );
1490     }
1491
1492     if (xRootKey.is())
1493         xRootKey->closeKey();
1494     if (xKey.is() && xKey->isValid() )
1495         xKey->closeKey();
1496 }
1497
1498 void ImplementationRegistration::doRegister(
1499     const Reference< XMultiComponentFactory > & xSMgr,
1500     const Reference< XComponentContext > &xCtx,
1501     const Reference < XImplementationLoader > & xAct,
1502     const Reference < XSimpleRegistry >& xDest,
1503     const OUString& implementationLoaderUrl,
1504     const OUString& locationUrl,
1505     const OUString& registeredLocationUrl)
1506     /* throw ( InvalidRegistryException,
1507                MergeConflictException,
1508                CannotRegisterImplementationException, RuntimeException ) */
1509 {
1510     Reference < XSimpleRegistry >   xReg =
1511         createTemporarySimpleRegistry( xSMgr, xCtx );
1512     Reference < XRegistryKey >      xSourceKey;
1513
1514     if (!(xAct.is() && xReg.is() && xDest.is()))
1515         return;
1516
1517     try
1518     {
1519         xReg->open(OUString() /* in mem */, false, true);
1520
1521         { // only necessary for deleting the temporary variable of rootkey
1522             xSourceKey = xReg->getRootKey()->createKey( slash_IMPLEMENTATIONS );
1523         }
1524
1525         bool bSuccess =
1526             xAct->writeRegistryInfo(xSourceKey, implementationLoaderUrl, locationUrl);
1527         if ( !bSuccess )
1528         {
1529             throw CannotRegisterImplementationException(
1530                 "ImplementationRegistration::doRegistration() component registration signaled failure" );
1531         }
1532
1533         prepareRegistry(xDest, xSourceKey, implementationLoaderUrl, registeredLocationUrl, xCtx);
1534
1535         xSourceKey->closeKey();
1536
1537         xSourceKey = xReg->getRootKey();
1538         Reference < XRegistryKey > xDestKey = xDest->getRootKey();
1539         stoc_impreg::mergeKeys( xDestKey, xSourceKey );
1540         xDestKey->closeKey();
1541         xSourceKey->closeKey();
1542
1543
1544         // Cleanup Source registry.
1545         if ( xSourceKey->isValid() )
1546             xSourceKey->closeKey();
1547     }
1548     catch(CannotRegisterImplementationException&)
1549     {
1550         if ( xSourceKey->isValid() )
1551             xSourceKey->closeKey();
1552         // and throw again
1553         throw;
1554     }
1555 }
1556
1557
1558 Reference< XSimpleRegistry > ImplementationRegistration::createTemporarySimpleRegistry(
1559     const Reference< XMultiComponentFactory > &rSMgr,
1560     const Reference < XComponentContext > & xCtx)
1561 {
1562
1563     Reference < XSimpleRegistry > xReg(
1564         rSMgr->createInstanceWithContext(
1565             com_sun_star_registry_SimpleRegistry,   xCtx ),
1566         UNO_QUERY);
1567     OSL_ASSERT( xReg.is() );
1568     return xReg;
1569 }
1570
1571 }
1572
1573 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1574 com_sun_star_comp_stoc_ImplementationRegistration_get_implementation(
1575     css::uno::XComponentContext *context,
1576     css::uno::Sequence<css::uno::Any> const &)
1577 {
1578     return cppu::acquire(new ImplementationRegistration(context));
1579 }
1580
1581 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */