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