registry/source/regkey.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 "regkey.hxx"
  22
  23 #include <registry/registry.hxx>
  24 #include <rtl/alloc.h>
  25 #include <osl/diagnose.h>
  26 #include "regimpl.hxx"
  27 #include "keyimpl.hxx"
  28
  29
  30
  31 //  acquireKey
  32
  33 void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
  34 {
  35     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  36     if (pKey != 0)
  37     {
  38         ORegistry* pReg = pKey->getRegistry();
  39         (void) pReg->acquireKey(pKey);
  40     }
  41 }
  42
  43
  44
  45 //  releaseKey
  46
  47 void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
  48 {
  49     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  50     if (pKey != 0)
  51     {
  52         ORegistry* pReg = pKey->getRegistry();
  53         (void) pReg->releaseKey(pKey);
  54     }
  55 }
  56
  57
  58
  59 //  isKeyReadOnly
  60
  61 sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
  62 {
  63     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  64     return (pKey != 0) ? pKey->isReadOnly() : sal_False;
  65 }
  66
  67
  68
  69 //  getKeyName
  70
  71 RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
  72 {
  73     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  74     if (pKey)
  75     {
  76         rtl_uString_assign( pKeyName, pKey->getName().pData );
  77         return RegError::NO_ERROR;
  78     } else
  79     {
  80         rtl_uString_new(pKeyName);
  81         return RegError::INVALID_KEY;
  82     }
  83 }
  84
  85
  86
  87 //  createKey
  88
  89 RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
  90                                      rtl_uString* keyName,
  91                                      RegKeyHandle* phNewKey)
  92 {
  93     *phNewKey = 0;
  94
  95     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  96     if (!pKey)
  97         return RegError::INVALID_KEY;
  98
  99     if (pKey->isDeleted())
 100         return RegError::INVALID_KEY;
 101
 102     if (pKey->isReadOnly())
 103         return RegError::REGISTRY_READONLY;
 104
 105     return pKey->createKey(keyName, phNewKey);
 106 }
 107
 108
 109 //  openKey
 110
 111 RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
 112                                    rtl_uString* keyName,
 113                                    RegKeyHandle* phOpenKey)
 114 {
 115     *phOpenKey = 0;
 116
 117     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 118     if (!pKey)
 119         return RegError::INVALID_KEY;
 120
 121     if (pKey->isDeleted())
 122         return RegError::INVALID_KEY;
 123
 124     return pKey->openKey(keyName, phOpenKey);
 125 }
 126
 127
 128 //  openSubKeys
 129
 130 RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
 131                                        rtl_uString* keyName,
 132                                        RegKeyHandle** pphSubKeys,
 133                                        sal_uInt32* pnSubKeys)
 134 {
 135     *pphSubKeys = NULL;
 136     *pnSubKeys = 0;
 137
 138     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 139     if (!pKey)
 140         return RegError::INVALID_KEY;
 141
 142     if (pKey->isDeleted())
 143         return RegError::INVALID_KEY;
 144
 145     return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
 146 }
 147
 148
 149 //  closeSubKeys
 150
 151 RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
 152                                         sal_uInt32 nSubKeys)
 153 {
 154     if (phSubKeys == 0 || nSubKeys == 0)
 155         return RegError::INVALID_KEY;
 156
 157     ORegistry* pReg = static_cast<ORegKey*>(phSubKeys[0])->getRegistry();
 158     for (sal_uInt32 i = 0; i < nSubKeys; i++)
 159     {
 160         (void) pReg->closeKey(phSubKeys[i]);
 161     }
 162     rtl_freeMemory(phSubKeys);
 163
 164     return RegError::NO_ERROR;
 165 }
 166
 167
 168 //  deleteKey
 169
 170 RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
 171                                      rtl_uString* keyName)
 172 {
 173     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 174     if (!pKey)
 175         return RegError::INVALID_KEY;
 176
 177     if (pKey->isDeleted())
 178         return RegError::INVALID_KEY;
 179
 180     if (pKey->isReadOnly())
 181         return RegError::REGISTRY_READONLY;
 182
 183     return pKey->deleteKey(keyName);
 184 }
 185
 186
 187 //  closeKey
 188
 189 RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
 190 {
 191     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 192     if (!pKey)
 193         return RegError::INVALID_KEY;
 194
 195     return pKey->closeKey(hKey);
 196 }
 197
 198
 199 //  setValue
 200
 201 RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
 202                                        rtl_uString* keyName,
 203                                        RegValueType valueType,
 204                                        RegValue pData,
 205                                        sal_uInt32 valueSize)
 206 {
 207     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 208     if (!pKey)
 209         return RegError::INVALID_KEY;
 210
 211     if (pKey->isDeleted())
 212         return RegError::INVALID_KEY;
 213
 214     if (pKey->isReadOnly())
 215         return RegError::REGISTRY_READONLY;
 216
 217     OUString valueName("value");
 218     if (keyName->length)
 219     {
 220         ORegKey* pSubKey = 0;
 221         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 222         if (_ret1 != RegError::NO_ERROR)
 223             return _ret1;
 224
 225         _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
 226         if (_ret1 != RegError::NO_ERROR)
 227         {
 228             RegError _ret2 = pKey->closeKey(pSubKey);
 229             if (_ret2 != RegError::NO_ERROR)
 230                 return _ret2;
 231             else
 232                 return _ret1;
 233         }
 234
 235         return pKey->closeKey(pSubKey);
 236     }
 237
 238     return pKey->setValue(valueName, valueType, pData, valueSize);
 239 }
 240
 241
 242 //  setLongValueList
 243
 244 RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
 245                                                   rtl_uString* keyName,
 246                                                   sal_Int32* pValueList,
 247                                                   sal_uInt32 len)
 248 {
 249     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 250     if (!pKey)
 251         return RegError::INVALID_KEY;
 252
 253     if (pKey->isDeleted())
 254         return RegError::INVALID_KEY;
 255
 256     if (pKey->isReadOnly())
 257         return RegError::REGISTRY_READONLY;
 258
 259     OUString valueName("value");
 260     if (keyName->length)
 261     {
 262         ORegKey* pSubKey = 0;
 263         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 264         if (_ret1 != RegError::NO_ERROR)
 265             return _ret1;
 266
 267         _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
 268         if (_ret1 != RegError::NO_ERROR)
 269         {
 270             RegError _ret2 = pKey->closeKey(pSubKey);
 271             if (_ret2 != RegError::NO_ERROR)
 272                 return _ret2;
 273             else
 274                 return _ret1;
 275         }
 276
 277         return pKey->closeKey(pSubKey);
 278     }
 279
 280     return pKey->setLongListValue(valueName, pValueList, len);
 281 }
 282
 283
 284 //  setStringValueList
 285
 286 RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
 287                                                    rtl_uString* keyName,
 288                                                    sal_Char** pValueList,
 289                                                    sal_uInt32 len)
 290 {
 291     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 292     if (!pKey)
 293         return RegError::INVALID_KEY;
 294
 295     if (pKey->isDeleted())
 296         return RegError::INVALID_KEY;
 297
 298     if (pKey->isReadOnly())
 299         return RegError::REGISTRY_READONLY;
 300
 301     OUString valueName("value");
 302     if (keyName->length)
 303     {
 304         ORegKey* pSubKey = 0;
 305         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 306         if (_ret1 != RegError::NO_ERROR)
 307             return _ret1;
 308
 309         _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
 310         if (_ret1 != RegError::NO_ERROR)
 311         {
 312             RegError _ret2 = pKey->closeKey(pSubKey);
 313             if (_ret2 != RegError::NO_ERROR)
 314                 return _ret2;
 315             else
 316                 return _ret1;
 317         }
 318
 319         return pKey->closeKey(pSubKey);
 320     }
 321
 322     return pKey->setStringListValue(valueName, pValueList, len);
 323 }
 324
 325
 326 //  setUnicodeValueList
 327
 328 RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
 329                                                      rtl_uString* keyName,
 330                                                      sal_Unicode** pValueList,
 331                                                      sal_uInt32 len)
 332 {
 333     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 334     if (!pKey)
 335         return RegError::INVALID_KEY;
 336
 337     if (pKey->isDeleted())
 338         return RegError::INVALID_KEY;
 339
 340     if (pKey->isReadOnly())
 341         return RegError::REGISTRY_READONLY;
 342
 343     OUString valueName("value");
 344     if (keyName->length)
 345     {
 346         ORegKey* pSubKey = 0;
 347         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 348         if (_ret1 != RegError::NO_ERROR)
 349             return _ret1;
 350
 351         _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
 352         if (_ret1 != RegError::NO_ERROR)
 353         {
 354             RegError _ret2 = pKey->closeKey(pSubKey);
 355             if (_ret2 != RegError::NO_ERROR)
 356                 return _ret2;
 357             else
 358                 return _ret1;
 359         }
 360
 361         return pKey->closeKey(pSubKey);
 362     }
 363
 364     return pKey->setUnicodeListValue(valueName, pValueList, len);
 365 }
 366
 367
 368 //  getValueInfo
 369
 370 RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
 371                                         rtl_uString* keyName,
 372                                         RegValueType* pValueType,
 373                                         sal_uInt32* pValueSize)
 374 {
 375     *pValueType = RegValueType::NOT_DEFINED;
 376     *pValueSize = 0;
 377
 378     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 379     if (!pKey)
 380         return RegError::INVALID_KEY;
 381
 382     if (pKey->isDeleted())
 383         return RegError::INVALID_KEY;
 384
 385     RegValueType valueType;
 386     sal_uInt32   valueSize;
 387
 388     OUString valueName("value");
 389     if (keyName->length)
 390     {
 391         ORegKey* pSubKey = 0;
 392         RegError _ret = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 393         if (_ret != RegError::NO_ERROR)
 394             return _ret;
 395
 396         if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
 397         {
 398             (void) pKey->releaseKey(pSubKey);
 399             return RegError::INVALID_VALUE;
 400         }
 401
 402         *pValueType = valueType;
 403         *pValueSize = valueSize;
 404
 405         return pKey->releaseKey(pSubKey);
 406     }
 407
 408
 409     if (pKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
 410     {
 411         return RegError::INVALID_VALUE;
 412     }
 413
 414     *pValueType = valueType;
 415     *pValueSize = valueSize;
 416
 417     return RegError::NO_ERROR;
 418 }
 419
 420
 421 //  getValueInfo
 422
 423 RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
 424                                     rtl_uString* keyName,
 425                                     RegValue pValue)
 426 {
 427     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 428     if (!pKey)
 429         return RegError::INVALID_KEY;
 430
 431     if (pKey->isDeleted())
 432         return RegError::INVALID_KEY;
 433
 434     OUString valueName("value");
 435     if (keyName->length)
 436     {
 437         ORegKey* pSubKey = 0;
 438         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 439         if (_ret1 != RegError::NO_ERROR)
 440             return _ret1;
 441
 442         _ret1 = pSubKey->getValue(valueName, pValue);
 443         if (_ret1 != RegError::NO_ERROR)
 444         {
 445             (void) pKey->releaseKey(pSubKey);
 446             return _ret1;
 447         }
 448
 449         return pKey->releaseKey(pSubKey);
 450     }
 451
 452     return pKey->getValue(valueName, pValue);
 453 }
 454
 455
 456 //  getLongValueList
 457
 458 RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
 459                                             rtl_uString* keyName,
 460                                             sal_Int32** pValueList,
 461                                             sal_uInt32* pLen)
 462 {
 463     assert((pValueList != 0) && (pLen != 0) && "registry::getLongListValue(): invalid parameter");
 464     *pValueList = 0, *pLen = 0;
 465
 466     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 467     if (!pKey)
 468         return RegError::INVALID_KEY;
 469
 470     if (pKey->isDeleted())
 471         return RegError::INVALID_KEY;
 472
 473     OUString valueName("value");
 474     if (keyName->length)
 475     {
 476         ORegKey* pSubKey = 0;
 477         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 478         if (_ret1 != RegError::NO_ERROR)
 479             return _ret1;
 480
 481         _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
 482         if (_ret1 != RegError::NO_ERROR)
 483         {
 484             (void) pKey->releaseKey(pSubKey);
 485             return _ret1;
 486         }
 487
 488         return pKey->releaseKey(pSubKey);
 489     }
 490
 491     return pKey->getLongListValue(valueName, pValueList, pLen);
 492 }
 493
 494
 495 //  getStringValueList
 496
 497 RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
 498                                               rtl_uString* keyName,
 499                                               sal_Char*** pValueList,
 500                                               sal_uInt32* pLen)
 501 {
 502     OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getStringListValue(): invalid parameter");
 503     *pValueList = 0, *pLen = 0;
 504
 505     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 506     if (!pKey)
 507         return RegError::INVALID_KEY;
 508
 509     if (pKey->isDeleted())
 510         return RegError::INVALID_KEY;
 511
 512     OUString valueName("value");
 513     if (keyName->length)
 514     {
 515         ORegKey* pSubKey = 0;
 516         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 517         if (_ret1 != RegError::NO_ERROR)
 518             return _ret1;
 519
 520         _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
 521         if (_ret1 != RegError::NO_ERROR)
 522         {
 523             (void) pKey->releaseKey(pSubKey);
 524             return _ret1;
 525         }
 526
 527         return pKey->releaseKey(pSubKey);
 528     }
 529
 530     return pKey->getStringListValue(valueName, pValueList, pLen);
 531 }
 532
 533 //  getUnicodeListValue
 534 RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
 535                                                rtl_uString* keyName,
 536                                                sal_Unicode*** pValueList,
 537                                                sal_uInt32* pLen)
 538 {
 539     assert((pValueList != 0) && (pLen != 0) && "registry::getUnicodeListValue(): invalid parameter");
 540     *pValueList = 0, *pLen = 0;
 541
 542     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 543     if (!pKey)
 544         return RegError::INVALID_KEY;
 545
 546     if (pKey->isDeleted())
 547         return RegError::INVALID_KEY;
 548
 549     OUString valueName("value");
 550     if (keyName->length)
 551     {
 552         ORegKey* pSubKey = 0;
 553         RegError _ret1 = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pSubKey));
 554         if (_ret1 != RegError::NO_ERROR)
 555             return _ret1;
 556
 557         _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
 558         if (_ret1 != RegError::NO_ERROR)
 559         {
 560             (void) pKey->releaseKey(pSubKey);
 561             return _ret1;
 562         }
 563
 564         return pKey->releaseKey(pSubKey);
 565     }
 566
 567     return pKey->getUnicodeListValue(valueName, pValueList, pLen);
 568 }
 569
 570
 571 //  freeValueList
 572
 573 RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
 574                                               RegValue pValueList,
 575                                               sal_uInt32 len)
 576 {
 577     switch (valueType)
 578     {
 579         case RegValueType::LONGLIST:
 580             {
 581                 rtl_freeMemory(pValueList);
 582             }
 583             break;
 584         case RegValueType::STRINGLIST:
 585             {
 586                 sal_Char** pVList = static_cast<sal_Char**>(pValueList);
 587                 for (sal_uInt32 i=0; i < len; i++)
 588                 {
 589                     rtl_freeMemory(pVList[i]);
 590                 }
 591
 592                 rtl_freeMemory(pVList);
 593             }
 594             break;
 595         case RegValueType::UNICODELIST:
 596             {
 597                 sal_Unicode** pVList = static_cast<sal_Unicode**>(pValueList);
 598                 for (sal_uInt32 i=0; i < len; i++)
 599                 {
 600                     rtl_freeMemory(pVList[i]);
 601                 }
 602
 603                 rtl_freeMemory(pVList);
 604             }
 605             break;
 606         default:
 607             return RegError::INVALID_VALUE;
 608     }
 609
 610     pValueList = NULL;
 611     return RegError::NO_ERROR;
 612 }
 613
 614
 615 //  getName
 616
 617 RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
 618                                               rtl_uString* keyName,
 619                                               SAL_UNUSED_PARAMETER sal_Bool,
 620                                                 rtl_uString** pResolvedName)
 621 {
 622     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 623     if (!pKey)
 624         return RegError::INVALID_KEY;
 625
 626     if (pKey->isDeleted())
 627         return RegError::INVALID_KEY;
 628
 629     OUString resolvedName;
 630     RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName);
 631     if (_ret == RegError::NO_ERROR)
 632         rtl_uString_assign(pResolvedName, resolvedName.pData);
 633     return _ret;
 634 }
 635
 636
 637 //  getKeyNames
 638
 639 RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
 640                                        rtl_uString* keyName,
 641                                          rtl_uString*** pSubKeyNames,
 642                                          sal_uInt32* pnSubKeys)
 643 {
 644     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 645     if (!pKey)
 646         return RegError::INVALID_KEY;
 647
 648     if (pKey->isDeleted())
 649         return RegError::INVALID_KEY;
 650
 651     return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
 652 }
 653
 654
 655 //  freeKeyNames
 656
 657 RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
 658                                           sal_uInt32 nKeys)
 659 {
 660     for (sal_uInt32 i=0; i < nKeys; i++)
 661     {
 662         rtl_uString_release(pKeyNames[i]);
 663     }
 664
 665     rtl_freeMemory(pKeyNames);
 666
 667     return RegError::NO_ERROR;
 668 }
 669
 670
 671 //  C API
 672
 673
 674
 675 //  reg_createKey
 676
 677 RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey,
 678                                          rtl_uString* keyName,
 679                                          RegKeyHandle* phNewKey)
 680 {
 681     if (!hKey)
 682          return RegError::INVALID_KEY;
 683
 684     return createKey(hKey, keyName, phNewKey);
 685 }
 686
 687
 688 //  reg_openKey
 689
 690 RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
 691                                        rtl_uString* keyName,
 692                                        RegKeyHandle* phOpenKey)
 693 {
 694     if (!hKey)
 695         return RegError::INVALID_KEY;
 696
 697     return openKey(hKey, keyName, phOpenKey);
 698 }
 699
 700
 701 //  reg_openSubKeys
 702
 703 RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey,
 704                                            rtl_uString* keyName,
 705                                            RegKeyHandle** pphSubKeys,
 706                                            sal_uInt32* pnSubKeys)
 707 {
 708     if (!hKey)
 709         return RegError::INVALID_KEY;
 710
 711     return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys);
 712 }
 713
 714
 715 //  reg_closeSubKeys
 716
 717 RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys,
 718                                             sal_uInt32 nSubKeys)
 719 {
 720     if (!pphSubKeys)
 721         return RegError::INVALID_KEY;
 722
 723     return closeSubKeys(pphSubKeys, nSubKeys);
 724 }
 725
 726
 727 //  reg_deleteKey
 728
 729 RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey,
 730                                          rtl_uString* keyName)
 731 {
 732     if (!hKey)
 733         return RegError::INVALID_KEY;
 734
 735     return deleteKey(hKey, keyName);
 736 }
 737
 738
 739 //  reg_closeKey
 740
 741 RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
 742 {
 743     if (!hKey)
 744         return RegError::INVALID_KEY;
 745
 746     return closeKey(hKey);
 747 }
 748
 749
 750
 751 //  reg_getKeyName
 752
 753 RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
 754 {
 755     if (hKey)
 756     {
 757         rtl_uString_assign( pKeyName, static_cast<ORegKey*>(hKey)->getName().pData );
 758         return RegError::NO_ERROR;
 759     } else
 760     {
 761         rtl_uString_new( pKeyName );
 762         return RegError::INVALID_KEY;
 763     }
 764 }
 765
 766
 767 //  reg_setValue
 768
 769 RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey,
 770                                         rtl_uString* keyName,
 771                                         RegValueType valueType,
 772                                         RegValue pData,
 773                                         sal_uInt32 valueSize)
 774 {
 775     if (!hKey)
 776         return RegError::INVALID_KEY;
 777
 778     return setValue(hKey, keyName, valueType, pData, valueSize);
 779 }
 780
 781
 782 //  reg_setLongListValue
 783
 784 RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey,
 785                                                       rtl_uString* keyName,
 786                                                       sal_Int32* pValueList,
 787                                                       sal_uInt32 len)
 788 {
 789     if (!hKey)
 790         return RegError::INVALID_KEY;
 791
 792     return setLongListValue(hKey, keyName, pValueList, len);
 793 }
 794
 795
 796 //  reg_setStringListValue
 797
 798 RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey,
 799                                                           rtl_uString* keyName,
 800                                                           sal_Char** pValueList,
 801                                                           sal_uInt32 len)
 802 {
 803     if (!hKey)
 804         return RegError::INVALID_KEY;
 805
 806     return setStringListValue(hKey, keyName, pValueList, len);
 807 }
 808
 809
 810 //  reg_setUnicodeListValue
 811
 812 RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey,
 813                                                             rtl_uString* keyName,
 814                                                             sal_Unicode** pValueList,
 815                                                             sal_uInt32 len)
 816 {
 817     if (!hKey)
 818         return RegError::INVALID_KEY;
 819
 820     return setUnicodeListValue(hKey, keyName, pValueList, len);
 821 }
 822
 823
 824 //  reg_getValueInfo
 825
 826 RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey,
 827                                             rtl_uString* keyName,
 828                                             RegValueType* pValueType,
 829                                             sal_uInt32* pValueSize)
 830 {
 831     if (!hKey)
 832         return RegError::INVALID_KEY;
 833
 834     return getValueInfo(hKey, keyName, pValueType, pValueSize);
 835 }
 836
 837
 838 //  reg_getValueInfo
 839
 840 RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey,
 841                                         rtl_uString* keyName,
 842                                         RegValue pData)
 843 {
 844     if (!hKey)
 845         return RegError::INVALID_KEY;
 846
 847     return getValue(hKey, keyName, pData);
 848 }
 849
 850
 851 //  reg_getLongListValue
 852
 853 RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey,
 854                                                       rtl_uString* keyName,
 855                                                       sal_Int32** pValueList,
 856                                                       sal_uInt32* pLen)
 857 {
 858     if (!hKey)
 859         return RegError::INVALID_KEY;
 860
 861     return getLongListValue(hKey, keyName, pValueList, pLen);
 862 }
 863
 864
 865 //  reg_getStringListValue
 866
 867 RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey,
 868                                                        rtl_uString* keyName,
 869                                                        sal_Char*** pValueList,
 870                                                        sal_uInt32* pLen)
 871 {
 872     if (!hKey)
 873         return RegError::INVALID_KEY;
 874
 875     return getStringListValue(hKey, keyName, pValueList, pLen);
 876 }
 877
 878
 879 //  reg_getUnicodeListValue
 880
 881 RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey,
 882                                                          rtl_uString* keyName,
 883                                                          sal_Unicode*** pValueList,
 884                                                          sal_uInt32* pLen)
 885 {
 886     if (!hKey)
 887         return RegError::INVALID_KEY;
 888
 889     return getUnicodeListValue(hKey, keyName, pValueList, pLen);
 890 }
 891
 892
 893 //  reg_freeValueList
 894
 895 RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType,
 896                                                   RegValue pValueList,
 897                                                   sal_uInt32 len)
 898 {
 899     if (pValueList)
 900         return freeValueList(valueType, pValueList, len);
 901     else
 902         return RegError::INVALID_VALUE;
 903 }
 904
 905
 906 //  reg_getResolvedKeyName
 907
 908 RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey,
 909                                                     rtl_uString* keyName,
 910                                                     sal_Bool firstLinkOnly,
 911                                                       rtl_uString** pResolvedName)
 912 {
 913     if (!hKey)
 914         return RegError::INVALID_KEY;
 915
 916     return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName);
 917 }
 918
 919 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */