registry/source/regkey.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: regkey.cxx,v $
  10  * $Revision: 1.7.8.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_registry.hxx"
  33
  34 #include "regkey.hxx"
  35 #include        <registry/registry.hxx>
  36 #include        <rtl/alloc.h>
  37 #include        "regimpl.hxx"
  38 #include        "keyimpl.hxx"
  39
  40
  41 //*********************************************************************
  42 //      acquireKey
  43 //
  44 void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
  45 {
  46     ORegKey* pKey = (ORegKey*) hKey;
  47
  48     if (pKey != NULL)
  49         pKey->acquire();
  50 }
  51
  52
  53 //*********************************************************************
  54 //      releaseKey
  55 //
  56 void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
  57 {
  58     ORegKey* pKey = (ORegKey*) hKey;
  59
  60     if (pKey)
  61     {
  62         if (pKey->release() == 0)
  63             delete pKey;
  64     }
  65 }
  66
  67
  68 //*********************************************************************
  69 //      isKeyReadOnly
  70 //
  71 sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
  72 {
  73     if (hKey)
  74     {
  75         return ((ORegKey*)hKey)->isReadOnly();
  76     } else
  77     {
  78         return sal_False;
  79     }
  80 }
  81
  82
  83 //*********************************************************************
  84 //      getKeyName
  85 //
  86 RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
  87 {
  88     if (hKey)
  89     {
  90         rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData );
  91         return REG_NO_ERROR;
  92     } else
  93     {
  94         rtl_uString_new(pKeyName);
  95         return REG_INVALID_KEY;
  96     }
  97 }
  98
  99
 100 //*********************************************************************
 101 //      createKey
 102 //
 103 RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
 104                                      rtl_uString* keyName,
 105                                      RegKeyHandle* phNewKey)
 106 {
 107     ORegKey*    pKey;
 108
 109     if (hKey)
 110     {
 111         pKey = (ORegKey*)hKey;
 112
 113         if (pKey->isDeleted())
 114         {
 115             phNewKey = NULL;
 116             return REG_INVALID_KEY;
 117         }
 118     } else
 119     {
 120         phNewKey = NULL;
 121         return REG_INVALID_KEY;
 122     }
 123
 124     if (pKey->isReadOnly())
 125         return REG_REGISTRY_READONLY;
 126
 127     return pKey->createKey(keyName, phNewKey);
 128 }
 129
 130 //*********************************************************************
 131 //      openKey
 132 //
 133 RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
 134                                    rtl_uString* keyName,
 135                                    RegKeyHandle* phOpenKey)
 136 {
 137     ORegKey*    pKey;
 138
 139     if (hKey)
 140     {
 141         pKey = (ORegKey*)hKey;
 142
 143         if (pKey->isDeleted())
 144         {
 145             phOpenKey = NULL;
 146             return REG_INVALID_KEY;
 147         }
 148     } else
 149     {
 150         phOpenKey = NULL;
 151         return REG_INVALID_KEY;
 152     }
 153
 154     return pKey->openKey(keyName, phOpenKey);
 155 }
 156
 157 //*********************************************************************
 158 //      openSubKeys
 159 //
 160 RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
 161                                        rtl_uString* keyName,
 162                                        RegKeyHandle** pphSubKeys,
 163                                        sal_uInt32* pnSubKeys)
 164 {
 165     ORegKey*    pKey;
 166
 167     if (hKey)
 168     {
 169         pKey = (ORegKey*)hKey;
 170
 171         if (pKey->isDeleted())
 172         {
 173             *pphSubKeys = NULL;
 174             *pnSubKeys = 0;
 175             return REG_INVALID_KEY;
 176         }
 177     } else
 178     {
 179         *pphSubKeys = NULL;
 180         *pnSubKeys = 0;
 181         return REG_INVALID_KEY;
 182     }
 183
 184     return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
 185 }
 186
 187 //*********************************************************************
 188 //      closeSubKeys
 189 //
 190 RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
 191                                         sal_uInt32 nSubKeys)
 192 {
 193     RegError _ret = REG_NO_ERROR;
 194
 195     if (phSubKeys != 0 && nSubKeys != 0)
 196     {
 197         ORegistry* pReg = NULL;
 198
 199         pReg = ((ORegKey*)phSubKeys[0])->getRegistry();
 200
 201         for (sal_uInt32 i=0; (i < nSubKeys) && (_ret == REG_NO_ERROR); i++)
 202         {
 203             _ret = pReg->closeKey(phSubKeys[i]);
 204         }
 205
 206         rtl_freeMemory(phSubKeys);
 207     }
 208     else
 209         _ret = REG_INVALID_KEY;
 210
 211     return _ret;
 212 }
 213
 214
 215 //*********************************************************************
 216 //      deleteKey
 217 //
 218 RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
 219                                      rtl_uString* keyName)
 220 {
 221     ORegKey*    pKey;
 222
 223     if (hKey)
 224     {
 225         pKey = (ORegKey*)hKey;
 226
 227         if (pKey->isDeleted())
 228             return REG_INVALID_KEY;
 229     } else
 230         return REG_INVALID_KEY;
 231
 232     if (pKey->isReadOnly())
 233         return REG_REGISTRY_READONLY;
 234
 235     return pKey->deleteKey(keyName);
 236 }
 237
 238 //*********************************************************************
 239 //      closeKey
 240 //
 241 RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
 242 {
 243     ORegKey*    pKey;
 244     ORegistry*  pReg;
 245
 246     if (hKey)
 247     {
 248         pKey = (ORegKey*)hKey;
 249
 250         pReg = pKey->getRegistry();
 251
 252         if (pReg->closeKey(hKey))
 253             return REG_INVALID_KEY;
 254     } else
 255         return REG_INVALID_KEY;
 256
 257     return REG_NO_ERROR;
 258 }
 259
 260
 261 //*********************************************************************
 262 //      setValue
 263 //
 264 RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
 265                                        rtl_uString* keyName,
 266                                        RegValueType valueType,
 267                                        RegValue pData,
 268                                        sal_uInt32 valueSize)
 269 {
 270     ORegKey*    pKey;
 271
 272     if (hKey)
 273     {
 274         pKey = (ORegKey*)hKey;
 275
 276         if (pKey->isDeleted())
 277             return REG_INVALID_KEY;
 278     } else
 279         return REG_INVALID_KEY;
 280
 281     if (pKey->isReadOnly())
 282         return REG_REGISTRY_READONLY;
 283
 284     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 285     if (keyName->length)
 286     {
 287         RegKeyHandle hSubKey;
 288         ORegKey* pSubKey;
 289         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 290         if (_ret1)
 291             return _ret1;
 292
 293         pSubKey = (ORegKey*)hSubKey;
 294         _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
 295         if (_ret1)
 296         {
 297             RegError _ret2 = pKey->closeKey(hSubKey);
 298             if (_ret2)
 299                 return _ret2;
 300             else
 301                 return _ret1;
 302         }
 303
 304         return pKey->closeKey(hSubKey);
 305     }
 306
 307     return pKey->setValue(valueName, valueType, pData, valueSize);
 308 }
 309
 310 //*********************************************************************
 311 //      setLongValueList
 312 //
 313 RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
 314                                                   rtl_uString* keyName,
 315                                                   sal_Int32* pValueList,
 316                                                   sal_uInt32 len)
 317 {
 318     ORegKey*    pKey;
 319
 320     if (hKey)
 321     {
 322         pKey = (ORegKey*)hKey;
 323
 324         if (pKey->isDeleted())
 325             return REG_INVALID_KEY;
 326     } else
 327         return REG_INVALID_KEY;
 328
 329     if (pKey->isReadOnly())
 330         return REG_REGISTRY_READONLY;
 331
 332     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 333     if (keyName->length)
 334     {
 335         RegKeyHandle hSubKey;
 336         ORegKey* pSubKey;
 337         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 338         if (_ret1)
 339             return _ret1;
 340
 341         pSubKey = (ORegKey*)hSubKey;
 342         _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
 343         if (_ret1)
 344         {
 345             RegError _ret2 = pKey->closeKey(hSubKey);
 346             if (_ret2)
 347                 return _ret2;
 348             else
 349                 return _ret1;
 350         }
 351
 352         return pKey->closeKey(hSubKey);
 353     }
 354
 355     return pKey->setLongListValue(valueName, pValueList, len);
 356 }
 357
 358 //*********************************************************************
 359 //      setStringValueList
 360 //
 361 RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
 362                                                    rtl_uString* keyName,
 363                                                    sal_Char** pValueList,
 364                                                    sal_uInt32 len)
 365 {
 366     ORegKey*    pKey;
 367
 368     if (hKey)
 369     {
 370         pKey = (ORegKey*)hKey;
 371
 372         if (pKey->isDeleted())
 373             return REG_INVALID_KEY;
 374     } else
 375         return REG_INVALID_KEY;
 376
 377     if (pKey->isReadOnly())
 378         return REG_REGISTRY_READONLY;
 379
 380     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 381     if (keyName->length)
 382     {
 383         RegKeyHandle hSubKey;
 384         ORegKey* pSubKey;
 385         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 386         if (_ret1)
 387             return _ret1;
 388
 389         pSubKey = (ORegKey*)hSubKey;
 390         _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
 391         if (_ret1)
 392         {
 393             RegError _ret2 = pKey->closeKey(hSubKey);
 394             if (_ret2)
 395                 return _ret2;
 396             else
 397                 return _ret1;
 398         }
 399
 400         return pKey->closeKey(hSubKey);
 401     }
 402
 403     return pKey->setStringListValue(valueName, pValueList, len);
 404 }
 405
 406 //*********************************************************************
 407 //      setUnicodeValueList
 408 //
 409 RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
 410                                                      rtl_uString* keyName,
 411                                                      sal_Unicode** pValueList,
 412                                                      sal_uInt32 len)
 413 {
 414     ORegKey*    pKey;
 415
 416     if (hKey)
 417     {
 418         pKey = (ORegKey*)hKey;
 419
 420         if (pKey->isDeleted())
 421             return REG_INVALID_KEY;
 422     } else
 423         return REG_INVALID_KEY;
 424
 425     if (pKey->isReadOnly())
 426         return REG_REGISTRY_READONLY;
 427
 428     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 429     if (keyName->length)
 430     {
 431         RegKeyHandle hSubKey;
 432         ORegKey* pSubKey;
 433         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 434         if (_ret1)
 435             return _ret1;
 436
 437         pSubKey = (ORegKey*)hSubKey;
 438         _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
 439         if (_ret1)
 440         {
 441             RegError _ret2 = pKey->closeKey(hSubKey);
 442             if (_ret2)
 443                 return _ret2;
 444             else
 445                 return _ret1;
 446         }
 447
 448         return pKey->closeKey(hSubKey);
 449     }
 450
 451     return pKey->setUnicodeListValue(valueName, pValueList, len);
 452 }
 453
 454 //*********************************************************************
 455 //      getValueInfo
 456 //
 457 RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
 458                                         rtl_uString* keyName,
 459                                         RegValueType* pValueType,
 460                                         sal_uInt32* pValueSize)
 461 {
 462     ORegKey*            pKey;
 463     RegValueType        valueType;
 464     sal_uInt32          valueSize;
 465
 466     *pValueType = RG_VALUETYPE_NOT_DEFINED;
 467     *pValueSize = 0;
 468
 469     if (hKey)
 470     {
 471         pKey = (ORegKey*)hKey;
 472
 473         if (pKey->isDeleted())
 474             return REG_INVALID_KEY;
 475     } else
 476         return REG_INVALID_KEY;
 477
 478     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 479     if (keyName->length)
 480     {
 481         RegKeyHandle hSubKey;
 482         ORegKey* pSubKey;
 483         RegError _ret = pKey->openKey(keyName, &hSubKey);
 484         if (_ret)
 485             return _ret;
 486
 487         pSubKey = (ORegKey*)hSubKey;
 488         if (pSubKey->getValueInfo(valueName, &valueType, &valueSize))
 489         {
 490             _ret = pKey->closeKey(hSubKey);
 491             if (_ret)
 492                 return _ret;
 493             else
 494                 return REG_INVALID_VALUE;
 495         }
 496
 497         *pValueType = valueType;
 498         *pValueSize = valueSize;
 499
 500         return pKey->closeKey(hSubKey);
 501     }
 502
 503
 504     if (pKey->getValueInfo(valueName, &valueType, &valueSize))
 505     {
 506         return REG_INVALID_VALUE;
 507     }
 508
 509     *pValueType = valueType;
 510     *pValueSize = valueSize;
 511
 512     return REG_NO_ERROR;
 513 }
 514
 515 //*********************************************************************
 516 //      getValueInfo
 517 //
 518 RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
 519                                     rtl_uString* keyName,
 520                                     RegValue pValue)
 521 {
 522     ORegKey*    pKey;
 523
 524     if (hKey)
 525     {
 526         pKey = (ORegKey*)hKey;
 527
 528         if (pKey->isDeleted())
 529         {
 530             pValue = NULL;
 531             return REG_INVALID_KEY;
 532         }
 533     } else
 534     {
 535         pValue = NULL;
 536         return REG_INVALID_KEY;
 537     }
 538
 539     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 540     if (keyName->length)
 541     {
 542         RegKeyHandle hSubKey;
 543         ORegKey* pSubKey;
 544         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 545         if (_ret1)
 546         {
 547             pValue = NULL;
 548             return _ret1;
 549         }
 550
 551         pSubKey = (ORegKey*)hSubKey;
 552         _ret1 = pSubKey->getValue(valueName, pValue);
 553         if (_ret1)
 554         {
 555             RegError _ret2 = pKey->closeKey(hSubKey);
 556             if (_ret2)
 557             {
 558                 pValue = NULL;
 559                 return _ret2;
 560             } else
 561             {
 562                 pValue = NULL;
 563                 return _ret1;
 564             }
 565         }
 566
 567         return pKey->closeKey(hSubKey);
 568     }
 569
 570     return pKey->getValue(valueName, pValue);
 571 }
 572
 573 //*********************************************************************
 574 //      getLongValueList
 575 //
 576 RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
 577                                             rtl_uString* keyName,
 578                                             sal_Int32** pValueList,
 579                                             sal_uInt32* pLen)
 580 {
 581     ORegKey*    pKey;
 582
 583     if (hKey)
 584     {
 585         pKey = (ORegKey*)hKey;
 586
 587         if (pKey->isDeleted())
 588         {
 589             pValueList = NULL;
 590             *pLen = 0;
 591             return REG_INVALID_KEY;
 592         }
 593     } else
 594     {
 595         pValueList = NULL;
 596         *pLen = 0;
 597         return REG_INVALID_KEY;
 598     }
 599
 600     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 601     if (keyName->length)
 602     {
 603         RegKeyHandle hSubKey;
 604         ORegKey* pSubKey;
 605         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 606         if (_ret1)
 607         {
 608             pValueList = NULL;
 609             *pLen = 0;
 610             return _ret1;
 611         }
 612
 613         pSubKey = (ORegKey*)hSubKey;
 614
 615         _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
 616         if (_ret1)
 617         {
 618             RegError _ret2 = pKey->closeKey(hSubKey);
 619             if (_ret2)
 620             {
 621                 pValueList = NULL;
 622                 *pLen = 0;
 623                 return _ret2;
 624             } else
 625             {
 626                 pValueList = NULL;
 627                 *pLen = 0;
 628                 return _ret1;
 629             }
 630         }
 631
 632         return pKey->closeKey(hSubKey);
 633     }
 634
 635     return pKey->getLongListValue(valueName, pValueList, pLen);
 636 }
 637
 638 //*********************************************************************
 639 //      getStringValueList
 640 //
 641 RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
 642                                               rtl_uString* keyName,
 643                                               sal_Char*** pValueList,
 644                                               sal_uInt32* pLen)
 645 {
 646     ORegKey*    pKey;
 647
 648     if (hKey)
 649     {
 650         pKey = (ORegKey*)hKey;
 651
 652         if (pKey->isDeleted())
 653         {
 654             pValueList = NULL;
 655             *pLen = 0;
 656             return REG_INVALID_KEY;
 657         }
 658     } else
 659     {
 660         pValueList = NULL;
 661         *pLen = 0;
 662         return REG_INVALID_KEY;
 663     }
 664
 665     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 666     if (keyName->length)
 667     {
 668         RegKeyHandle hSubKey;
 669         ORegKey* pSubKey;
 670         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 671         if (_ret1)
 672         {
 673             pValueList = NULL;
 674             *pLen = 0;
 675             return _ret1;
 676         }
 677
 678         pSubKey = (ORegKey*)hSubKey;
 679
 680         _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
 681         if (_ret1)
 682         {
 683             RegError _ret2 = pKey->closeKey(hSubKey);
 684             if (_ret2)
 685             {
 686                 pValueList = NULL;
 687                 *pLen = 0;
 688                 return _ret2;
 689             } else
 690             {
 691                 pValueList = NULL;
 692                 *pLen = 0;
 693                 return _ret1;
 694             }
 695         }
 696
 697         return pKey->closeKey(hSubKey);
 698     }
 699
 700     return pKey->getStringListValue(valueName, pValueList, pLen);
 701 }
 702
 703 //*********************************************************************
 704 //      getUnicodeListValue
 705 //
 706 RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
 707                                                rtl_uString* keyName,
 708                                                sal_Unicode*** pValueList,
 709                                                sal_uInt32* pLen)
 710 {
 711     ORegKey*    pKey;
 712
 713     if (hKey)
 714     {
 715         pKey = (ORegKey*)hKey;
 716
 717         if (pKey->isDeleted())
 718         {
 719             pValueList = NULL;
 720             *pLen = 0;
 721             return REG_INVALID_KEY;
 722         }
 723     } else
 724     {
 725         pValueList = NULL;
 726         *pLen = 0;
 727         return REG_INVALID_KEY;
 728     }
 729
 730     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
 731     if (keyName->length)
 732     {
 733         RegKeyHandle hSubKey;
 734         ORegKey* pSubKey;
 735         RegError _ret1 = pKey->openKey(keyName, &hSubKey);
 736         if (_ret1)
 737         {
 738             pValueList = NULL;
 739             *pLen = 0;
 740             return _ret1;
 741         }
 742
 743         pSubKey = (ORegKey*)hSubKey;
 744
 745         _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
 746         if (_ret1)
 747         {
 748             RegError _ret2 = pKey->closeKey(hSubKey);
 749             if (_ret2)
 750             {
 751                 pValueList = NULL;
 752                 *pLen = 0;
 753                 return _ret2;
 754             } else
 755             {
 756                 pValueList = NULL;
 757                 *pLen = 0;
 758                 return _ret1;
 759             }
 760         }
 761
 762         return pKey->closeKey(hSubKey);
 763     }
 764
 765     return pKey->getUnicodeListValue(valueName, pValueList, pLen);
 766 }
 767
 768 //*********************************************************************
 769 //      freeValueList
 770 //
 771 RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
 772                                               RegValue pValueList,
 773                                               sal_uInt32 len)
 774 {
 775     switch (valueType)
 776     {
 777         case 5:
 778             {
 779                 rtl_freeMemory(pValueList);
 780             }
 781             break;
 782         case 6:
 783             {
 784                 sal_Char** pVList = (sal_Char**)pValueList;
 785                 for (sal_uInt32 i=0; i < len; i++)
 786                 {
 787                     rtl_freeMemory(pVList[i]);
 788                 }
 789
 790                 rtl_freeMemory(pVList);
 791             }
 792             break;
 793         case 7:
 794             {
 795                 sal_Unicode** pVList = (sal_Unicode**)pValueList;
 796                 for (sal_uInt32 i=0; i < len; i++)
 797                 {
 798                     rtl_freeMemory(pVList[i]);
 799                 }
 800
 801                 rtl_freeMemory(pVList);
 802             }
 803             break;
 804         default:
 805             return REG_INVALID_VALUE;
 806     }
 807
 808     pValueList = NULL;
 809     return REG_NO_ERROR;
 810 }
 811
 812
 813 //*********************************************************************
 814 //      createLink
 815 //
 816 RegError REGISTRY_CALLTYPE createLink(RegKeyHandle, rtl_uString*, rtl_uString*)
 817 {
 818     return REG_INVALID_LINK; // links are no longer supported
 819 }
 820
 821 //*********************************************************************
 822 //      deleteLink
 823 //
 824 RegError REGISTRY_CALLTYPE deleteLink(RegKeyHandle, rtl_uString*)
 825 {
 826     return REG_INVALID_LINK; // links are no longer supported
 827 }
 828
 829 //*********************************************************************
 830 //      getKeyType
 831 //
 832 RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
 833                                       rtl_uString* keyName,
 834                                          RegKeyType* pKeyType)
 835 {
 836     ORegKey*    pKey;
 837
 838     if (hKey)
 839     {
 840         pKey = (ORegKey*)hKey;
 841
 842         if (pKey->isDeleted())
 843             return REG_INVALID_KEY;
 844     } else
 845         return REG_INVALID_KEY;
 846
 847     return pKey->getKeyType(keyName, pKeyType);
 848 }
 849
 850 //*********************************************************************
 851 //      getLinkTarget
 852 //
 853 RegError REGISTRY_CALLTYPE getLinkTarget(
 854     RegKeyHandle, rtl_uString*, rtl_uString**)
 855 {
 856     return REG_INVALID_LINK; // links are no longer supported
 857 }
 858
 859 //*********************************************************************
 860 //      getName
 861 //
 862 RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
 863                                               rtl_uString* keyName,
 864                                               sal_Bool,
 865                                                 rtl_uString** pResolvedName)
 866 {
 867     ORegKey     *pKey;
 868     RegError    _ret = REG_NO_ERROR;
 869
 870     if (hKey)
 871     {
 872         pKey = (ORegKey*)hKey;
 873
 874         if (pKey->isDeleted())
 875             return REG_INVALID_KEY;
 876     } else
 877         return REG_INVALID_KEY;
 878
 879     OUString resolvedName;
 880     _ret = pKey->getResolvedKeyName(keyName, resolvedName);
 881     if (!_ret)
 882         rtl_uString_assign(pResolvedName, resolvedName.pData);
 883     return _ret;
 884 }
 885
 886
 887 //*********************************************************************
 888 //      getKeyNames
 889 //
 890 RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
 891                                        rtl_uString* keyName,
 892                                          rtl_uString*** pSubKeyNames,
 893                                          sal_uInt32* pnSubKeys)
 894 {
 895     ORegKey*    pKey;
 896
 897     if (hKey)
 898     {
 899         pKey = (ORegKey*)hKey;
 900
 901         if (pKey->isDeleted())
 902             return REG_INVALID_KEY;
 903     } else
 904         return REG_INVALID_KEY;
 905
 906     return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
 907 }
 908
 909 //*********************************************************************
 910 //      freeKeyNames
 911 //
 912 RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
 913                                           sal_uInt32 nKeys)
 914 {
 915     for (sal_uInt32 i=0; i < nKeys; i++)
 916     {
 917         rtl_uString_release(pKeyNames[i]);
 918     }
 919
 920     rtl_freeMemory(pKeyNames);
 921
 922     return REG_NO_ERROR;
 923 }
 924
 925 //*********************************************************************
 926 //  C API
 927 //
 928
 929 //*********************************************************************
 930 //      reg_createKey
 931 //
 932 RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey,
 933                                          rtl_uString* keyName,
 934                                          RegKeyHandle* phNewKey)
 935 {
 936     if (!hKey)
 937          return REG_INVALID_KEY;
 938
 939     return createKey(hKey, keyName, phNewKey);
 940 }
 941
 942 //*********************************************************************
 943 //      reg_openKey
 944 //
 945 RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
 946                                        rtl_uString* keyName,
 947                                        RegKeyHandle* phOpenKey)
 948 {
 949     if (!hKey)
 950         return REG_INVALID_KEY;
 951
 952     return openKey(hKey, keyName, phOpenKey);
 953 }
 954
 955 //*********************************************************************
 956 //      reg_openSubKeys
 957 //
 958 RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey,
 959                                            rtl_uString* keyName,
 960                                            RegKeyHandle** pphSubKeys,
 961                                            sal_uInt32* pnSubKeys)
 962 {
 963     if (!hKey)
 964         return REG_INVALID_KEY;
 965
 966     return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys);
 967 }
 968
 969 //*********************************************************************
 970 //      reg_closeSubKeys
 971 //
 972 RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys,
 973                                             sal_uInt32 nSubKeys)
 974 {
 975     if (!pphSubKeys)
 976         return REG_INVALID_KEY;
 977
 978     return closeSubKeys(pphSubKeys, nSubKeys);
 979 }
 980
 981 //*********************************************************************
 982 //      reg_deleteKey
 983 //
 984 RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey,
 985                                          rtl_uString* keyName)
 986 {
 987     if (!hKey)
 988         return REG_INVALID_KEY;
 989
 990     return deleteKey(hKey, keyName);
 991 }
 992
 993 //*********************************************************************
 994 //      reg_closeKey
 995 //
 996 RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
 997 {
 998     if (!hKey)
 999         return REG_INVALID_KEY;
1000
1001     return closeKey(hKey);
1002 }
1003
1004
1005 //*********************************************************************
1006 //      reg_getKeyName
1007 //
1008 RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
1009 {
1010     if (hKey)
1011     {
1012         rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData );
1013         return REG_NO_ERROR;
1014     } else
1015     {
1016         rtl_uString_new( pKeyName );
1017         return REG_INVALID_KEY;
1018     }
1019 }
1020
1021 //*********************************************************************
1022 //      reg_setValue
1023 //
1024 RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey,
1025                                         rtl_uString* keyName,
1026                                         RegValueType valueType,
1027                                         RegValue pData,
1028                                         sal_uInt32 valueSize)
1029 {
1030     if (!hKey)
1031         return REG_INVALID_KEY;
1032
1033     return setValue(hKey, keyName, valueType, pData, valueSize);
1034 }
1035
1036 //*********************************************************************
1037 //      reg_setLongListValue
1038 //
1039 RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey,
1040                                                       rtl_uString* keyName,
1041                                                       sal_Int32* pValueList,
1042                                                       sal_uInt32 len)
1043 {
1044     if (!hKey)
1045         return REG_INVALID_KEY;
1046
1047     return setLongListValue(hKey, keyName, pValueList, len);
1048 }
1049
1050 //*********************************************************************
1051 //      reg_setStringListValue
1052 //
1053 RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey,
1054                                                           rtl_uString* keyName,
1055                                                           sal_Char** pValueList,
1056                                                           sal_uInt32 len)
1057 {
1058     if (!hKey)
1059         return REG_INVALID_KEY;
1060
1061     return setStringListValue(hKey, keyName, pValueList, len);
1062 }
1063
1064 //*********************************************************************
1065 //      reg_setUnicodeListValue
1066 //
1067 RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey,
1068                                                             rtl_uString* keyName,
1069                                                             sal_Unicode** pValueList,
1070                                                             sal_uInt32 len)
1071 {
1072     if (!hKey)
1073         return REG_INVALID_KEY;
1074
1075     return setUnicodeListValue(hKey, keyName, pValueList, len);
1076 }
1077
1078 //*********************************************************************
1079 //      reg_getValueInfo
1080 //
1081 RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey,
1082                                             rtl_uString* keyName,
1083                                             RegValueType* pValueType,
1084                                             sal_uInt32* pValueSize)
1085 {
1086     if (!hKey)
1087         return REG_INVALID_KEY;
1088
1089     return getValueInfo(hKey, keyName, pValueType, pValueSize);
1090 }
1091
1092 //*********************************************************************
1093 //      reg_getValueInfo
1094 //
1095 RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey,
1096                                         rtl_uString* keyName,
1097                                         RegValue pData)
1098 {
1099     if (!hKey)
1100         return REG_INVALID_KEY;
1101
1102     return getValue(hKey, keyName, pData);
1103 }
1104
1105 //*********************************************************************
1106 //      reg_getLongListValue
1107 //
1108 RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey,
1109                                                       rtl_uString* keyName,
1110                                                       sal_Int32** pValueList,
1111                                                       sal_uInt32* pLen)
1112 {
1113     if (!hKey)
1114         return REG_INVALID_KEY;
1115
1116     return getLongListValue(hKey, keyName, pValueList, pLen);
1117 }
1118
1119 //*********************************************************************
1120 //      reg_getStringListValue
1121 //
1122 RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey,
1123                                                        rtl_uString* keyName,
1124                                                        sal_Char*** pValueList,
1125                                                        sal_uInt32* pLen)
1126 {
1127     if (!hKey)
1128         return REG_INVALID_KEY;
1129
1130     return getStringListValue(hKey, keyName, pValueList, pLen);
1131 }
1132
1133 //*********************************************************************
1134 //      reg_getUnicodeListValue
1135 //
1136 RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey,
1137                                                          rtl_uString* keyName,
1138                                                          sal_Unicode*** pValueList,
1139                                                          sal_uInt32* pLen)
1140 {
1141     if (!hKey)
1142         return REG_INVALID_KEY;
1143
1144     return getUnicodeListValue(hKey, keyName, pValueList, pLen);
1145 }
1146
1147 //*********************************************************************
1148 //      reg_freeValueList
1149 //
1150 RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType,
1151                                                   RegValue pValueList,
1152                                                   sal_uInt32 len)
1153 {
1154     if (pValueList)
1155         return freeValueList(valueType, pValueList, len);
1156     else
1157         return REG_INVALID_VALUE;
1158 }
1159
1160 //*********************************************************************
1161 //      reg_createLink
1162 //
1163 RegError REGISTRY_CALLTYPE reg_createLink(RegKeyHandle hKey,
1164                                                rtl_uString* linkName,
1165                                           rtl_uString* linkTarget)
1166 {
1167     if (!hKey)
1168         return REG_INVALID_KEY;
1169
1170     return createLink(hKey, linkName, linkTarget);
1171 }
1172
1173 //*********************************************************************
1174 //      reg_deleteLink
1175 //
1176 RegError REGISTRY_CALLTYPE reg_deleteLink(RegKeyHandle hKey,
1177                                             rtl_uString* linkName)
1178 {
1179     if (!hKey)
1180         return REG_INVALID_KEY;
1181
1182     return deleteLink(hKey, linkName);
1183 }
1184
1185 //*********************************************************************
1186 //      reg_getKeyType
1187 //
1188 RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey,
1189                                           rtl_uString* keyName,
1190                                              RegKeyType* pKeyType)
1191 {
1192     if (!hKey)
1193         return REG_INVALID_KEY;
1194
1195     return getKeyType(hKey, keyName, pKeyType);
1196 }
1197
1198 //*********************************************************************
1199 //      reg_getLinkTarget
1200 //
1201 RegError REGISTRY_CALLTYPE reg_getLinkTarget(RegKeyHandle hKey,
1202                                              rtl_uString* linkName,
1203                                                rtl_uString** pLinkTarget)
1204 {
1205     if (!hKey)
1206         return REG_INVALID_KEY;
1207
1208     return getLinkTarget(hKey, linkName, pLinkTarget);
1209 }
1210
1211
1212 //*********************************************************************
1213 //      reg_getResolvedKeyName
1214 //
1215 RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey,
1216                                                     rtl_uString* keyName,
1217                                                     sal_Bool firstLinkOnly,
1218                                                       rtl_uString** pResolvedName)
1219 {
1220     ORegKey *pKey;
1221
1222     if (hKey)
1223         pKey = (ORegKey*)hKey;
1224     else
1225         return REG_INVALID_KEY;
1226
1227     return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName);
1228 }
1229
1230