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 <osl/diagnose.h>
  24 #include "regimpl.hxx"
  25 #include "keyimpl.hxx"
  26
  27 void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
  28 {
  29     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  30     if (pKey != nullptr)
  31     {
  32         ORegistry* pReg = pKey->getRegistry();
  33         (void) pReg->acquireKey(pKey);
  34     }
  35 }
  36
  37 void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
  38 {
  39     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  40     if (pKey != nullptr)
  41     {
  42         ORegistry* pReg = pKey->getRegistry();
  43         (void) pReg->releaseKey(pKey);
  44     }
  45 }
  46
  47 sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
  48 {
  49     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  50     return pKey != nullptr && pKey->isReadOnly();
  51 }
  52
  53 RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
  54 {
  55     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  56     if (pKey)
  57     {
  58         rtl_uString_assign( pKeyName, pKey->getName().pData );
  59         return RegError::NO_ERROR;
  60     } else
  61     {
  62         rtl_uString_new(pKeyName);
  63         return RegError::INVALID_KEY;
  64     }
  65 }
  66
  67 RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
  68                                      rtl_uString* keyName,
  69                                      RegKeyHandle* phNewKey)
  70 {
  71     *phNewKey = nullptr;
  72
  73     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  74     if (!pKey)
  75         return RegError::INVALID_KEY;
  76
  77     if (pKey->isDeleted())
  78         return RegError::INVALID_KEY;
  79
  80     if (pKey->isReadOnly())
  81         return RegError::REGISTRY_READONLY;
  82
  83     return pKey->createKey(OUString::unacquired(&keyName), phNewKey);
  84 }
  85
  86 RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
  87                                    rtl_uString* keyName,
  88                                    RegKeyHandle* phOpenKey)
  89 {
  90     *phOpenKey = nullptr;
  91
  92     ORegKey* pKey = static_cast< ORegKey* >(hKey);
  93     if (!pKey)
  94         return RegError::INVALID_KEY;
  95
  96     if (pKey->isDeleted())
  97         return RegError::INVALID_KEY;
  98
  99     return pKey->openKey(OUString::unacquired(&keyName), phOpenKey);
 100 }
 101
 102 RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
 103                                        rtl_uString* keyName,
 104                                        RegKeyHandle** pphSubKeys,
 105                                        sal_uInt32* pnSubKeys)
 106 {
 107     *pphSubKeys = nullptr;
 108     *pnSubKeys = 0;
 109
 110     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 111     if (!pKey)
 112         return RegError::INVALID_KEY;
 113
 114     if (pKey->isDeleted())
 115         return RegError::INVALID_KEY;
 116
 117     return pKey->openSubKeys(OUString::unacquired(&keyName), pphSubKeys, pnSubKeys);
 118 }
 119
 120 RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
 121                                         sal_uInt32 nSubKeys)
 122 {
 123     if (phSubKeys == nullptr || nSubKeys == 0)
 124         return RegError::INVALID_KEY;
 125
 126     ORegistry* pReg = static_cast<ORegKey*>(phSubKeys[0])->getRegistry();
 127     for (sal_uInt32 i = 0; i < nSubKeys; i++)
 128     {
 129         (void) pReg->closeKey(phSubKeys[i]);
 130     }
 131     std::free(phSubKeys);
 132
 133     return RegError::NO_ERROR;
 134 }
 135
 136 RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
 137                                      rtl_uString* keyName)
 138 {
 139     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 140     if (!pKey)
 141         return RegError::INVALID_KEY;
 142
 143     if (pKey->isDeleted())
 144         return RegError::INVALID_KEY;
 145
 146     if (pKey->isReadOnly())
 147         return RegError::REGISTRY_READONLY;
 148
 149     return pKey->deleteKey(OUString::unacquired(&keyName));
 150 }
 151
 152 RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
 153 {
 154     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 155     if (!pKey)
 156         return RegError::INVALID_KEY;
 157
 158     return pKey->closeKey(hKey);
 159 }
 160
 161 RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
 162                                        rtl_uString* keyName,
 163                                        RegValueType valueType,
 164                                        RegValue pData,
 165                                        sal_uInt32 valueSize)
 166 {
 167     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 168     if (!pKey)
 169         return RegError::INVALID_KEY;
 170
 171     if (pKey->isDeleted())
 172         return RegError::INVALID_KEY;
 173
 174     if (pKey->isReadOnly())
 175         return RegError::REGISTRY_READONLY;
 176
 177     OUString valueName(u"value"_ustr);
 178     if (keyName->length)
 179     {
 180         ORegKey* pSubKey = nullptr;
 181         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 182         if (_ret1 != RegError::NO_ERROR)
 183             return _ret1;
 184
 185         _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
 186         if (_ret1 != RegError::NO_ERROR)
 187         {
 188             RegError _ret2 = pKey->closeKey(pSubKey);
 189             if (_ret2 != RegError::NO_ERROR)
 190                 return _ret2;
 191             else
 192                 return _ret1;
 193         }
 194
 195         return pKey->closeKey(pSubKey);
 196     }
 197
 198     return pKey->setValue(valueName, valueType, pData, valueSize);
 199 }
 200
 201 RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
 202                                                   rtl_uString* keyName,
 203                                                   sal_Int32 const * pValueList,
 204                                                   sal_uInt32 len)
 205 {
 206     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 207     if (!pKey)
 208         return RegError::INVALID_KEY;
 209
 210     if (pKey->isDeleted())
 211         return RegError::INVALID_KEY;
 212
 213     if (pKey->isReadOnly())
 214         return RegError::REGISTRY_READONLY;
 215
 216     OUString valueName(u"value"_ustr);
 217     if (keyName->length)
 218     {
 219         ORegKey* pSubKey = nullptr;
 220         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 221         if (_ret1 != RegError::NO_ERROR)
 222             return _ret1;
 223
 224         _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
 225         if (_ret1 != RegError::NO_ERROR)
 226         {
 227             RegError _ret2 = pKey->closeKey(pSubKey);
 228             if (_ret2 != RegError::NO_ERROR)
 229                 return _ret2;
 230             else
 231                 return _ret1;
 232         }
 233
 234         return pKey->closeKey(pSubKey);
 235     }
 236
 237     return pKey->setLongListValue(valueName, pValueList, len);
 238 }
 239
 240 RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
 241                                                    rtl_uString* keyName,
 242                                                    char** pValueList,
 243                                                    sal_uInt32 len)
 244 {
 245     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 246     if (!pKey)
 247         return RegError::INVALID_KEY;
 248
 249     if (pKey->isDeleted())
 250         return RegError::INVALID_KEY;
 251
 252     if (pKey->isReadOnly())
 253         return RegError::REGISTRY_READONLY;
 254
 255     OUString valueName(u"value"_ustr);
 256     if (keyName->length)
 257     {
 258         ORegKey* pSubKey = nullptr;
 259         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 260         if (_ret1 != RegError::NO_ERROR)
 261             return _ret1;
 262
 263         _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
 264         if (_ret1 != RegError::NO_ERROR)
 265         {
 266             RegError _ret2 = pKey->closeKey(pSubKey);
 267             if (_ret2 != RegError::NO_ERROR)
 268                 return _ret2;
 269             else
 270                 return _ret1;
 271         }
 272
 273         return pKey->closeKey(pSubKey);
 274     }
 275
 276     return pKey->setStringListValue(valueName, pValueList, len);
 277 }
 278
 279 RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
 280                                                      rtl_uString* keyName,
 281                                                      sal_Unicode** pValueList,
 282                                                      sal_uInt32 len)
 283 {
 284     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 285     if (!pKey)
 286         return RegError::INVALID_KEY;
 287
 288     if (pKey->isDeleted())
 289         return RegError::INVALID_KEY;
 290
 291     if (pKey->isReadOnly())
 292         return RegError::REGISTRY_READONLY;
 293
 294     OUString valueName(u"value"_ustr);
 295     if (keyName->length)
 296     {
 297         ORegKey* pSubKey = nullptr;
 298         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 299         if (_ret1 != RegError::NO_ERROR)
 300             return _ret1;
 301
 302         _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
 303         if (_ret1 != RegError::NO_ERROR)
 304         {
 305             RegError _ret2 = pKey->closeKey(pSubKey);
 306             if (_ret2 != RegError::NO_ERROR)
 307                 return _ret2;
 308             else
 309                 return _ret1;
 310         }
 311
 312         return pKey->closeKey(pSubKey);
 313     }
 314
 315     return pKey->setUnicodeListValue(valueName, pValueList, len);
 316 }
 317
 318 RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
 319                                         rtl_uString* keyName,
 320                                         RegValueType* pValueType,
 321                                         sal_uInt32* pValueSize)
 322 {
 323     *pValueType = RegValueType::NOT_DEFINED;
 324     *pValueSize = 0;
 325
 326     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 327     if (!pKey)
 328         return RegError::INVALID_KEY;
 329
 330     if (pKey->isDeleted())
 331         return RegError::INVALID_KEY;
 332
 333     RegValueType valueType;
 334     sal_uInt32   valueSize;
 335
 336     OUString valueName(u"value"_ustr);
 337     if (keyName->length)
 338     {
 339         ORegKey* pSubKey = nullptr;
 340         RegError _ret = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 341         if (_ret != RegError::NO_ERROR)
 342             return _ret;
 343
 344         if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
 345         {
 346             (void) pKey->releaseKey(pSubKey);
 347             return RegError::INVALID_VALUE;
 348         }
 349
 350         *pValueType = valueType;
 351         *pValueSize = valueSize;
 352
 353         return pKey->releaseKey(pSubKey);
 354     }
 355
 356
 357     if (pKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
 358     {
 359         return RegError::INVALID_VALUE;
 360     }
 361
 362     *pValueType = valueType;
 363     *pValueSize = valueSize;
 364
 365     return RegError::NO_ERROR;
 366 }
 367
 368 RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
 369                                     rtl_uString* keyName,
 370                                     RegValue pValue)
 371 {
 372     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 373     if (!pKey)
 374         return RegError::INVALID_KEY;
 375
 376     if (pKey->isDeleted())
 377         return RegError::INVALID_KEY;
 378
 379     OUString valueName(u"value"_ustr);
 380     if (keyName->length)
 381     {
 382         ORegKey* pSubKey = nullptr;
 383         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 384         if (_ret1 != RegError::NO_ERROR)
 385             return _ret1;
 386
 387         _ret1 = pSubKey->getValue(valueName, pValue);
 388         if (_ret1 != RegError::NO_ERROR)
 389         {
 390             (void) pKey->releaseKey(pSubKey);
 391             return _ret1;
 392         }
 393
 394         return pKey->releaseKey(pSubKey);
 395     }
 396
 397     return pKey->getValue(valueName, pValue);
 398 }
 399
 400 RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
 401                                             rtl_uString* keyName,
 402                                             sal_Int32** pValueList,
 403                                             sal_uInt32* pLen)
 404 {
 405     assert((pValueList != nullptr) && (pLen != nullptr) && "registry::getLongListValue(): invalid parameter");
 406     *pValueList = nullptr;
 407     *pLen = 0;
 408
 409     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 410     if (!pKey)
 411         return RegError::INVALID_KEY;
 412
 413     if (pKey->isDeleted())
 414         return RegError::INVALID_KEY;
 415
 416     OUString valueName(u"value"_ustr);
 417     if (keyName->length)
 418     {
 419         ORegKey* pSubKey = nullptr;
 420         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 421         if (_ret1 != RegError::NO_ERROR)
 422             return _ret1;
 423
 424         _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
 425         if (_ret1 != RegError::NO_ERROR)
 426         {
 427             (void) pKey->releaseKey(pSubKey);
 428             return _ret1;
 429         }
 430
 431         return pKey->releaseKey(pSubKey);
 432     }
 433
 434     return pKey->getLongListValue(valueName, pValueList, pLen);
 435 }
 436
 437 RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
 438                                               rtl_uString* keyName,
 439                                               char*** pValueList,
 440                                               sal_uInt32* pLen)
 441 {
 442     assert(pValueList != nullptr && pLen != nullptr && "registry::getStringListValue(): invalid parameter");
 443     *pValueList = nullptr;
 444     *pLen = 0;
 445
 446     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 447     if (!pKey)
 448         return RegError::INVALID_KEY;
 449
 450     if (pKey->isDeleted())
 451         return RegError::INVALID_KEY;
 452
 453     OUString valueName(u"value"_ustr);
 454     if (keyName->length)
 455     {
 456         ORegKey* pSubKey = nullptr;
 457         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 458         if (_ret1 != RegError::NO_ERROR)
 459             return _ret1;
 460
 461         _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
 462         if (_ret1 != RegError::NO_ERROR)
 463         {
 464             (void) pKey->releaseKey(pSubKey);
 465             return _ret1;
 466         }
 467
 468         return pKey->releaseKey(pSubKey);
 469     }
 470
 471     return pKey->getStringListValue(valueName, pValueList, pLen);
 472 }
 473
 474 RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
 475                                                rtl_uString* keyName,
 476                                                sal_Unicode*** pValueList,
 477                                                sal_uInt32* pLen)
 478 {
 479     assert((pValueList != nullptr) && (pLen != nullptr) && "registry::getUnicodeListValue(): invalid parameter");
 480     *pValueList = nullptr;
 481     *pLen = 0;
 482
 483     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 484     if (!pKey)
 485         return RegError::INVALID_KEY;
 486
 487     if (pKey->isDeleted())
 488         return RegError::INVALID_KEY;
 489
 490     OUString valueName(u"value"_ustr);
 491     if (keyName->length)
 492     {
 493         ORegKey* pSubKey = nullptr;
 494         RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
 495         if (_ret1 != RegError::NO_ERROR)
 496             return _ret1;
 497
 498         _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
 499         if (_ret1 != RegError::NO_ERROR)
 500         {
 501             (void) pKey->releaseKey(pSubKey);
 502             return _ret1;
 503         }
 504
 505         return pKey->releaseKey(pSubKey);
 506     }
 507
 508     return pKey->getUnicodeListValue(valueName, pValueList, pLen);
 509 }
 510
 511 RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
 512                                               RegValue pValueList,
 513                                               sal_uInt32 len)
 514 {
 515     switch (valueType)
 516     {
 517         case RegValueType::LONGLIST:
 518             {
 519                 std::free(pValueList);
 520             }
 521             break;
 522         case RegValueType::STRINGLIST:
 523             {
 524                 char** pVList = static_cast<char**>(pValueList);
 525                 for (sal_uInt32 i=0; i < len; i++)
 526                 {
 527                     std::free(pVList[i]);
 528                 }
 529
 530                 std::free(pVList);
 531             }
 532             break;
 533         case RegValueType::UNICODELIST:
 534             {
 535                 sal_Unicode** pVList = static_cast<sal_Unicode**>(pValueList);
 536                 for (sal_uInt32 i=0; i < len; i++)
 537                 {
 538                     std::free(pVList[i]);
 539                 }
 540
 541                 std::free(pVList);
 542             }
 543             break;
 544         default:
 545             return RegError::INVALID_VALUE;
 546     }
 547
 548     pValueList = nullptr;
 549     return RegError::NO_ERROR;
 550 }
 551
 552 RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
 553                                               rtl_uString* keyName,
 554                                               SAL_UNUSED_PARAMETER sal_Bool,
 555                                                 rtl_uString** pResolvedName)
 556 {
 557     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 558     if (!pKey)
 559         return RegError::INVALID_KEY;
 560
 561     if (pKey->isDeleted())
 562         return RegError::INVALID_KEY;
 563
 564     OUString resolvedName;
 565     RegError _ret = pKey->getResolvedKeyName(OUString::unacquired(&keyName), resolvedName);
 566     if (_ret == RegError::NO_ERROR)
 567         rtl_uString_assign(pResolvedName, resolvedName.pData);
 568     return _ret;
 569 }
 570
 571 RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
 572                                        rtl_uString* keyName,
 573                                          rtl_uString*** pSubKeyNames,
 574                                          sal_uInt32* pnSubKeys)
 575 {
 576     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 577     if (!pKey)
 578         return RegError::INVALID_KEY;
 579
 580     if (pKey->isDeleted())
 581         return RegError::INVALID_KEY;
 582
 583     return pKey->getKeyNames(OUString::unacquired(&keyName), pSubKeyNames, pnSubKeys);
 584 }
 585
 586 RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
 587                                           sal_uInt32 nKeys)
 588 {
 589     for (sal_uInt32 i=0; i < nKeys; i++)
 590     {
 591         rtl_uString_release(pKeyNames[i]);
 592     }
 593
 594     std::free(pKeyNames);
 595
 596     return RegError::NO_ERROR;
 597 }
 598
 599 RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
 600                                        rtl_uString* keyName,
 601                                        RegKeyHandle* phOpenKey)
 602 {
 603     if (!hKey)
 604         return RegError::INVALID_KEY;
 605
 606     return openKey(hKey, keyName, phOpenKey);
 607 }
 608
 609 RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
 610 {
 611     if (!hKey)
 612         return RegError::INVALID_KEY;
 613
 614     return closeKey(hKey);
 615 }
 616
 617
 618 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */