registry/source/registry.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <registry/registry.h>
  22 #include <registry/registry.hxx>
  23
  24 #include <osl/process.h>
  25
  26 #include "keyimpl.hxx"
  27 #include "regimpl.hxx"
  28 #include "regkey.hxx"
  29
  30 #if defined(WIN32) || defined(WNT)
  31 #include <io.h>
  32 #endif
  33
  34 #include <string.h>
  35 #if defined(UNX)
  36 #include <stdlib.h>
  37 #include <unistd.h>
  38 #endif
  39
  40 extern "C" {
  41
  42 //*********************************************************************
  43 //  acquire
  44 //
  45 static void REGISTRY_CALLTYPE acquire(RegHandle hReg)
  46 {
  47     ORegistry* pReg = (ORegistry*) hReg;
  48
  49     if (pReg != NULL)
  50         pReg->acquire();
  51 }
  52
  53
  54 //*********************************************************************
  55 //  release
  56 //
  57 static void REGISTRY_CALLTYPE release(RegHandle hReg)
  58 {
  59     ORegistry* pReg = (ORegistry*) hReg;
  60
  61     if (pReg)
  62     {
  63         if (pReg->release() == 0)
  64         {
  65             delete pReg;
  66             hReg = NULL;
  67         }
  68     }
  69 }
  70
  71
  72 //*********************************************************************
  73 //  getName
  74 //
  75 static RegError REGISTRY_CALLTYPE getName(RegHandle hReg, rtl_uString** pName)
  76 {
  77     ORegistry*  pReg;
  78
  79     if (hReg)
  80     {
  81         pReg = (ORegistry*)hReg;
  82         if ( pReg->isOpen() )
  83         {
  84             rtl_uString_assign(pName, pReg->getName().pData);
  85             return REG_NO_ERROR;
  86         } else
  87         {
  88             rtl_uString_new(pName);
  89             return REG_REGISTRY_NOT_OPEN;
  90         }
  91     }
  92
  93     rtl_uString_new(pName);
  94     return REG_INVALID_REGISTRY;
  95 }
  96
  97
  98 //*********************************************************************
  99 //  isReadOnly
 100 //
 101 static sal_Bool REGISTRY_CALLTYPE isReadOnly(RegHandle hReg)
 102 {
 103     if (hReg)
 104         return ((ORegistry*)hReg)->isReadOnly();
 105     else
 106         return sal_False;
 107 }
 108
 109
 110 //*********************************************************************
 111 //  createRegistry
 112 //
 113 static RegError REGISTRY_CALLTYPE createRegistry(rtl_uString* registryName,
 114                                                  RegHandle* phRegistry)
 115 {
 116     RegError ret;
 117
 118     ORegistry* pReg = new ORegistry();
 119     if ((ret = pReg->initRegistry(registryName, REG_CREATE)))
 120     {
 121         *phRegistry = NULL;
 122         return ret;
 123     }
 124
 125     *phRegistry = pReg;
 126
 127     return REG_NO_ERROR;
 128 }
 129
 130 //*********************************************************************
 131 //  openRootKey
 132 //
 133 static RegError REGISTRY_CALLTYPE openRootKey(RegHandle hReg,
 134                                               RegKeyHandle* phRootKey)
 135 {
 136     ORegistry* pReg;
 137
 138     if (hReg)
 139     {
 140         pReg = (ORegistry*)hReg;
 141         if (!pReg->isOpen())
 142             return REG_REGISTRY_NOT_OPEN;
 143     } else
 144     {
 145         phRootKey = NULL;
 146         return REG_INVALID_REGISTRY;
 147     }
 148
 149     *phRootKey = pReg->getRootKey();
 150
 151     return REG_NO_ERROR;
 152 }
 153
 154
 155 //*********************************************************************
 156 //  openRegistry
 157 //
 158 static RegError REGISTRY_CALLTYPE openRegistry(rtl_uString* registryName,
 159                                                RegHandle* phRegistry,
 160                                                RegAccessMode accessMode)
 161 {
 162     RegError _ret;
 163
 164     ORegistry* pReg = new ORegistry();
 165     if ((_ret = pReg->initRegistry(registryName, accessMode)))
 166     {
 167         *phRegistry = NULL;
 168         delete pReg;
 169         return _ret;
 170     }
 171
 172
 173     *phRegistry = pReg;
 174
 175     return REG_NO_ERROR;
 176 }
 177
 178 //*********************************************************************
 179 //  closeRegistry
 180 //
 181 static RegError REGISTRY_CALLTYPE closeRegistry(RegHandle hReg)
 182 {
 183     ORegistry   *pReg;
 184
 185     if (hReg)
 186     {
 187         pReg = (ORegistry*)hReg;
 188         if (!pReg->isOpen())
 189             return REG_REGISTRY_NOT_OPEN;
 190
 191         RegError ret = REG_NO_ERROR;
 192         if (pReg->release() == 0)
 193         {
 194             delete(pReg);
 195             hReg = NULL;
 196         }
 197         else
 198             ret = pReg->closeRegistry();
 199
 200         return ret;
 201     } else
 202     {
 203         return REG_INVALID_REGISTRY;
 204     }
 205 }
 206
 207
 208 //*********************************************************************
 209 //  destroyRegistry
 210 //
 211 static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
 212                                                   rtl_uString* registryName)
 213 {
 214     ORegistry   *pReg;
 215
 216     if (hReg)
 217     {
 218         pReg = (ORegistry*)hReg;
 219         if (!pReg->isOpen())
 220             return REG_INVALID_REGISTRY;
 221
 222         RegError ret = pReg->destroyRegistry(registryName);
 223         if (!ret)
 224         {
 225             if (!registryName->length)
 226             {
 227                 delete(pReg);
 228                 hReg = NULL;
 229             }
 230         }
 231         return ret;
 232     } else
 233     {
 234         return REG_INVALID_REGISTRY;
 235     }
 236 }
 237
 238
 239 //*********************************************************************
 240 //  loadRegKey
 241 //
 242 static RegError REGISTRY_CALLTYPE loadKey(RegHandle hReg,
 243                                               RegKeyHandle hKey,
 244                                            rtl_uString* keyName,
 245                                            rtl_uString* regFileName)
 246 {
 247
 248     ORegistry* pReg = static_cast< ORegistry* >(hReg);
 249     if (!pReg)
 250         return REG_INVALID_REGISTRY;
 251
 252     if (!pReg->isOpen())
 253         return REG_REGISTRY_NOT_OPEN;
 254
 255     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 256     if (!pKey)
 257         return REG_INVALID_KEY;
 258
 259     if (pKey->getRegistry() != pReg)
 260         return REG_INVALID_KEY;
 261     if (pKey->isDeleted())
 262         return REG_INVALID_KEY;
 263     if (pKey->isReadOnly())
 264         return REG_REGISTRY_READONLY;
 265
 266
 267     ORegKey* pNewKey = 0;
 268     RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pNewKey);
 269     if (_ret == REG_NO_ERROR)
 270     {
 271         pKey->releaseKey(pNewKey);
 272         pKey->deleteKey(keyName);
 273     }
 274
 275     _ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey);
 276     if (_ret != REG_NO_ERROR)
 277         return _ret;
 278
 279     _ret = pReg->loadKey(pNewKey, regFileName);
 280     if (_ret != REG_NO_ERROR)
 281     {
 282         pKey->releaseKey(pNewKey);
 283         pKey->deleteKey(keyName);
 284         return _ret;
 285     }
 286
 287     return pKey->closeKey(pNewKey);
 288 }
 289
 290 //*********************************************************************
 291 //  saveKey
 292 //
 293 static RegError REGISTRY_CALLTYPE saveKey(RegHandle hReg,
 294                                               RegKeyHandle hKey,
 295                                            rtl_uString* keyName,
 296                                            rtl_uString* regFileName)
 297 {
 298
 299     ORegistry* pReg = static_cast< ORegistry* >(hReg);
 300     if (!pReg)
 301         return REG_INVALID_REGISTRY;
 302
 303     if (!pReg->isOpen())
 304         return REG_REGISTRY_NOT_OPEN;
 305
 306     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 307     if (!pKey)
 308         return REG_INVALID_KEY;
 309
 310     if (pKey->getRegistry() != pReg)
 311         return REG_INVALID_KEY;
 312     if (pKey->isDeleted())
 313         return REG_INVALID_KEY;
 314
 315     ORegKey* pNewKey = 0;
 316     RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pNewKey);
 317     if (_ret != REG_NO_ERROR)
 318         return _ret;
 319
 320     _ret = pReg->saveKey(pNewKey, regFileName);
 321     if (_ret != REG_NO_ERROR)
 322     {
 323         (void) pKey->releaseKey(pNewKey);
 324         return _ret;
 325     }
 326
 327     return pKey->releaseKey(pNewKey);
 328 }
 329
 330 //*********************************************************************
 331 //  mergeKey
 332 //
 333 static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
 334                                               RegKeyHandle hKey,
 335                                            rtl_uString* keyName,
 336                                            rtl_uString* regFileName,
 337                                            sal_Bool bWarnings,
 338                                            sal_Bool bReport)
 339 {
 340     ORegistry* pReg = static_cast< ORegistry* >(hReg);
 341     if (!pReg)
 342         return REG_INVALID_REGISTRY;
 343     if (!pReg->isOpen())
 344         return REG_REGISTRY_NOT_OPEN;
 345
 346     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 347     if (!pKey)
 348         return REG_INVALID_KEY;
 349     if (pKey->getRegistry() != pReg)
 350         return REG_INVALID_KEY;
 351     if (pKey->isDeleted())
 352         return REG_INVALID_KEY;
 353     if (pKey->isReadOnly())
 354         return REG_REGISTRY_READONLY;
 355
 356     if (keyName->length)
 357     {
 358         ORegKey* pNewKey = 0;
 359         RegError _ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey);
 360         if (_ret != REG_NO_ERROR)
 361             return _ret;
 362
 363         _ret = pReg->loadKey(pNewKey, regFileName, bWarnings, bReport);
 364         if (_ret != REG_NO_ERROR && (_ret != REG_MERGE_CONFLICT || bWarnings))
 365         {
 366             if (pNewKey != pKey)
 367                 (void) pKey->closeKey(pNewKey);
 368             else
 369                 (void) pKey->releaseKey(pNewKey);
 370             return _ret;
 371         }
 372
 373         return (pNewKey != pKey) ? pKey->closeKey(pNewKey) : pKey->releaseKey(pNewKey);
 374     }
 375
 376     return pReg->loadKey(pKey, regFileName, bWarnings, bReport);
 377 }
 378
 379 //*********************************************************************
 380 //  dumpRegistry
 381 //
 382 static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
 383                                                RegKeyHandle hKey)
 384 {
 385     ORegistry* pReg = static_cast< ORegistry* >(hReg);
 386     if (!pReg)
 387         return REG_INVALID_REGISTRY;
 388     if (!pReg->isOpen())
 389         return REG_REGISTRY_NOT_OPEN;
 390
 391     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 392     if (!pKey)
 393         return REG_INVALID_KEY;
 394     if (pKey->getRegistry() != pReg)
 395         return REG_INVALID_KEY;
 396     if (pKey->isDeleted())
 397         return REG_INVALID_KEY;
 398
 399     return pReg->dumpRegistry(hKey);
 400 }
 401
 402 //*********************************************************************
 403 //  initRegistry_Api
 404 //
 405 REG_DLLPUBLIC Registry_Api* REGISTRY_CALLTYPE initRegistry_Api(void)
 406 {
 407     static Registry_Api aApi= {&acquire,
 408                                &release,
 409                                &isReadOnly,
 410                                &openRootKey,
 411                                &getName,
 412                                &createRegistry,
 413                                &openRegistry,
 414                                &closeRegistry,
 415                                &destroyRegistry,
 416                                &loadKey,
 417                                &saveKey,
 418                                &mergeKey,
 419                                &dumpRegistry,
 420                                &acquireKey,
 421                                &releaseKey,
 422                                &isKeyReadOnly,
 423                                &getKeyName,
 424                                &createKey,
 425                                &openKey,
 426                                &openSubKeys,
 427                                &closeSubKeys,
 428                                &deleteKey,
 429                                &closeKey,
 430                                &setValue,
 431                                &setLongListValue,
 432                                &setStringListValue,
 433                                &setUnicodeListValue,
 434                                &getValueInfo,
 435                                &getValue,
 436                                &getLongListValue,
 437                                &getStringListValue,
 438                                &getUnicodeListValue,
 439                                &freeValueList,
 440                                &createLink,
 441                                &deleteLink,
 442                                &getKeyType,
 443                                &getLinkTarget,
 444                                &getResolvedKeyName,
 445                                &getKeyNames,
 446                                &freeKeyNames};
 447
 448     return (&aApi);
 449 }
 450
 451 }
 452
 453 //*********************************************************************
 454 //  reg_loadRegKey
 455 //
 456 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_loadKey(RegKeyHandle hKey,
 457                                        rtl_uString* keyName,
 458                                        rtl_uString* regFileName)
 459 {
 460     ORegKey *pKey;
 461
 462     if (hKey)
 463         pKey = (ORegKey*)hKey;
 464     else
 465         return REG_INVALID_KEY;
 466
 467     return loadKey(pKey->getRegistry(), hKey, keyName, regFileName);
 468 }
 469
 470 //*********************************************************************
 471 //  reg_saveKey
 472 //
 473 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_saveKey(RegKeyHandle hKey,
 474                                        rtl_uString* keyName,
 475                                        rtl_uString* regFileName)
 476 {
 477     ORegKey *pKey;
 478
 479     if (hKey)
 480         pKey = (ORegKey*)hKey;
 481     else
 482         return REG_INVALID_KEY;
 483
 484     return saveKey(pKey->getRegistry(), hKey, keyName, regFileName);
 485 }
 486
 487 //*********************************************************************
 488 //  reg_mergeKey
 489 //
 490 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_mergeKey(RegKeyHandle hKey,
 491                                         rtl_uString* keyName,
 492                                         rtl_uString* regFileName,
 493                                         sal_Bool bWarnings,
 494                                         sal_Bool bReport)
 495 {
 496     ORegKey *pKey;
 497
 498     if (hKey)
 499         pKey = (ORegKey*)hKey;
 500     else
 501         return REG_INVALID_KEY;
 502
 503     return mergeKey(pKey->getRegistry(), hKey, keyName, regFileName, bWarnings, bReport);
 504 }
 505
 506 //*********************************************************************
 507 //  reg_createRegistry
 508 //
 509 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_createRegistry(rtl_uString* registryName,
 510                                               RegHandle* phRegistry)
 511 {
 512     RegError ret;
 513
 514     ORegistry* pReg = new ORegistry();
 515     if ((ret = pReg->initRegistry(registryName, REG_CREATE)))
 516     {
 517         *phRegistry = NULL;
 518         return ret;
 519     }
 520
 521     *phRegistry = pReg;
 522
 523     return REG_NO_ERROR;
 524 }
 525
 526 //*********************************************************************
 527 //  reg_openRootKey
 528 //
 529 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
 530                                           RegKeyHandle* phRootKey)
 531 {
 532     return openRootKey(hRegistry, phRootKey);
 533 }
 534
 535
 536 //*********************************************************************
 537 //  reg_getName
 538 //
 539 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_getName(RegHandle hRegistry, rtl_uString** pName)
 540 {
 541     return getName(hRegistry, pName);
 542 }
 543
 544
 545 //*********************************************************************
 546 //  reg_isReadOnly
 547 //
 548 REG_DLLPUBLIC sal_Bool REGISTRY_CALLTYPE reg_isReadOnly(RegHandle hRegistry)
 549 {
 550     return isReadOnly(hRegistry);
 551 }
 552
 553
 554 //*********************************************************************
 555 //  reg_openRegistry
 556 //
 557 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryName,
 558                                             RegHandle* phRegistry,
 559                                             RegAccessMode accessMode)
 560 {
 561     RegError _ret;
 562
 563     ORegistry* pReg = new ORegistry();
 564     if ((_ret = pReg->initRegistry(registryName, accessMode)))
 565     {
 566         *phRegistry = NULL;
 567         return _ret;
 568     }
 569
 570     *phRegistry = pReg;
 571
 572     return REG_NO_ERROR;
 573 }
 574
 575 //*********************************************************************
 576 //  reg_closeRegistry
 577 //
 578 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry)
 579 {
 580     ORegistry* pReg;
 581
 582     if (hRegistry)
 583     {
 584         pReg = (ORegistry*)hRegistry;
 585         delete(pReg);
 586         return REG_NO_ERROR;
 587     } else
 588     {
 589         return REG_REGISTRY_NOT_OPEN;
 590     }
 591 }
 592
 593
 594 //*********************************************************************
 595 //  reg_destroyRegistry
 596 //
 597 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_destroyRegistry(RegHandle hRegistry,
 598                                                rtl_uString* registryName)
 599 {
 600     return destroyRegistry(hRegistry, registryName);
 601 }
 602
 603
 604 //*********************************************************************
 605 //  reg_dumpRegistry
 606 //
 607 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_dumpRegistry(RegKeyHandle hKey)
 608 {
 609     ORegKey *pKey;
 610
 611     if (hKey)
 612         pKey = (ORegKey*)hKey;
 613     else
 614         return REG_INVALID_KEY;
 615
 616     return dumpRegistry(pKey->getRegistry(), hKey);
 617 }
 618
 619
 620 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */