registry/source/keyimpl.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 <string.h>
  22 #include <string_view>
  23
  24 #include "keyimpl.hxx"
  25
  26 #include "reflcnst.hxx"
  27 #include <rtl/alloc.h>
  28 #include <rtl/ustrbuf.hxx>
  29 #include <osl/diagnose.h>
  30 #include <sal/log.hxx>
  31 #include <memory>
  32
  33 using namespace store;
  34
  35 namespace { char const VALUE_PREFIX[] = "$VL_"; }
  36
  37
  38 //  ORegKey()
  39
  40 ORegKey::ORegKey(const OUString& keyName, ORegistry* pReg)
  41     : m_refCount(1)
  42     , m_name(keyName)
  43     , m_bDeleted(false)
  44     , m_bModified(false)
  45     , m_pRegistry(pReg)
  46 {
  47 }
  48
  49
  50 //  ~ORegKey()
  51
  52 ORegKey::~ORegKey()
  53 {
  54     SAL_WARN_IF(m_refCount != 0, "registry", "registry::ORegKey::dtor(): refcount not zero.");
  55 }
  56
  57
  58 //  releaseKey
  59
  60 RegError ORegKey::releaseKey(RegKeyHandle hKey)
  61 {
  62     return m_pRegistry->releaseKey(hKey);
  63 }
  64
  65
  66 //  createKey
  67
  68 RegError ORegKey::createKey(const OUString& keyName, RegKeyHandle* phNewKey)
  69 {
  70     return m_pRegistry->createKey(this, keyName, phNewKey);
  71 }
  72
  73
  74 //  openKey
  75
  76 RegError ORegKey::openKey(const OUString& keyName, RegKeyHandle* phOpenKey)
  77 {
  78     return m_pRegistry->openKey(this, keyName, phOpenKey);
  79 }
  80
  81
  82 //  openSubKeys
  83
  84 RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubKeys, sal_uInt32* pnSubKeys)
  85 {
  86     RegError _ret = RegError::NO_ERROR;
  87
  88     *phOpenSubKeys = nullptr;
  89     *pnSubKeys = 0;
  90
  91     ORegKey* pKey = this;
  92     if ( !keyName.isEmpty() )
  93     {
  94         _ret = openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pKey));
  95         if (_ret != RegError::NO_ERROR)
  96             return _ret;
  97     }
  98
  99     sal_uInt32 nSubKeys = pKey->countSubKeys();
 100     *pnSubKeys = nSubKeys;
 101
 102     ORegKey** pSubKeys;
 103     pSubKeys = static_cast<ORegKey**>(rtl_allocateZeroMemory(nSubKeys * sizeof(ORegKey*)));
 104
 105     OStoreDirectory::iterator   iter;
 106     OStoreDirectory             rStoreDir(pKey->getStoreDir());
 107     storeError                  _err = rStoreDir.first(iter);
 108
 109     nSubKeys = 0;
 110     while ( _err == store_E_None )
 111     {
 112         if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
 113         {
 114             OUString const sSubKeyName(iter.m_pszName, iter.m_nLength);
 115
 116             ORegKey* pOpenSubKey = nullptr;
 117             _ret = pKey->openKey(sSubKeyName, reinterpret_cast<RegKeyHandle*>(&pOpenSubKey));
 118             if (_ret != RegError::NO_ERROR)
 119             {
 120                 *phOpenSubKeys = nullptr;
 121                 *pnSubKeys = 0;
 122                 std::free(pSubKeys); // @@@ leaking 'pSubKeys[0...nSubkeys-1]'
 123                 return _ret;              // @@@ leaking 'pKey'
 124             }
 125
 126             pSubKeys[nSubKeys] = pOpenSubKey;
 127
 128             nSubKeys++;
 129         }
 130
 131         _err = rStoreDir.next(iter);
 132     }
 133
 134     *phOpenSubKeys = reinterpret_cast<RegKeyHandle*>(pSubKeys);
 135     if (!keyName.isEmpty())
 136     {
 137         (void) releaseKey(pKey);
 138     }
 139     return RegError::NO_ERROR;
 140 }
 141
 142
 143 //  getKeyNames
 144
 145 RegError ORegKey::getKeyNames(const OUString& keyName,
 146                               rtl_uString*** pSubKeyNames,
 147                               sal_uInt32* pnSubKeys)
 148 {
 149     *pSubKeyNames = nullptr;
 150     *pnSubKeys = 0;
 151
 152     ORegKey* pKey = this;
 153     if (!keyName.isEmpty())
 154     {
 155         RegError _ret = openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pKey));
 156         if (_ret != RegError::NO_ERROR)
 157             return _ret;
 158     }
 159
 160     sal_uInt32 nSubKeys = pKey->countSubKeys();
 161     *pnSubKeys = nSubKeys;
 162
 163     rtl_uString** pSubKeys
 164         = static_cast<rtl_uString**>(rtl_allocateZeroMemory(nSubKeys * sizeof(rtl_uString*)));
 165
 166     OStoreDirectory::iterator   iter;
 167     OStoreDirectory             rStoreDir(pKey->getStoreDir());
 168     storeError                  _err = rStoreDir.first(iter);
 169
 170     nSubKeys = 0;
 171
 172     while ( _err == store_E_None )
 173     {
 174         if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR)
 175         {
 176             OUString const sSubKeyName(iter.m_pszName, iter.m_nLength);
 177
 178             OUString sFullKeyName(pKey->getName());
 179             if (sFullKeyName.getLength() > 1)
 180                 sFullKeyName += ORegistry::ROOT;
 181             sFullKeyName += sSubKeyName;
 182
 183             rtl_uString_newFromString(&pSubKeys[nSubKeys], sFullKeyName.pData);
 184
 185             nSubKeys++;
 186         }
 187
 188         _err = rStoreDir.next(iter);
 189     }
 190
 191     *pSubKeyNames = pSubKeys;
 192     if (!keyName.isEmpty())
 193     {
 194         releaseKey(pKey);
 195     }
 196     return RegError::NO_ERROR;
 197 }
 198
 199
 200 //  closeKey
 201
 202 RegError ORegKey::closeKey(RegKeyHandle hKey)
 203 {
 204     return m_pRegistry->closeKey(hKey);
 205 }
 206
 207
 208 //  deleteKey
 209
 210 RegError ORegKey::deleteKey(const OUString& keyName)
 211 {
 212     return m_pRegistry->deleteKey(this, keyName);
 213 }
 214
 215
 216 //  getValueType
 217
 218 RegError ORegKey::getValueInfo(const OUString& valueName, RegValueType* pValueType, sal_uInt32* pValueSize) const
 219 {
 220     OStoreStream    rValue;
 221     std::unique_ptr<sal_uInt8[]> pBuffer;
 222     storeAccessMode accessMode = storeAccessMode::ReadWrite;
 223
 224     if (m_pRegistry->isReadOnly())
 225     {
 226         accessMode = storeAccessMode::ReadOnly;
 227     }
 228
 229     OUString sImplValueName = VALUE_PREFIX + valueName;
 230
 231     REG_GUARD(m_pRegistry->m_mutex);
 232
 233     if ( rValue.create(m_pRegistry->getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
 234     {
 235         *pValueType = RegValueType::NOT_DEFINED;
 236         *pValueSize = 0;
 237         return RegError::VALUE_NOT_EXISTS;
 238     }
 239
 240     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
 241
 242     sal_uInt32  readBytes;
 243     if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
 244     {
 245         return RegError::INVALID_VALUE;
 246     }
 247     if (readBytes != VALUE_HEADERSIZE)
 248     {
 249         return RegError::INVALID_VALUE;
 250     }
 251
 252     sal_uInt32  size;
 253     sal_uInt8   type = pBuffer[0];
 254     readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
 255
 256     *pValueType = static_cast<RegValueType>(type);
 257     if (*pValueType > RegValueType::BINARY)
 258     {
 259         pBuffer.reset(new sal_uInt8[4]);
 260         rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), 4, readBytes);
 261
 262         readUINT32(pBuffer.get(), size);
 263     }
 264
 265     *pValueSize = size;
 266
 267     return RegError::NO_ERROR;
 268 }
 269
 270
 271 //  setValue
 272
 273 RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegValue value, sal_uInt32 vSize)
 274 {
 275     OStoreStream    rValue;
 276     std::unique_ptr<sal_uInt8[]> pBuffer;
 277
 278     if (m_pRegistry->isReadOnly())
 279     {
 280         return RegError::REGISTRY_READONLY;
 281     }
 282
 283     if (vType > RegValueType::BINARY)
 284     {
 285         return RegError::INVALID_VALUE;
 286     }
 287
 288     OUString sImplValueName = VALUE_PREFIX + valueName;
 289
 290     REG_GUARD(m_pRegistry->m_mutex);
 291
 292     if ( rValue.create(getStoreFile(), m_name + ORegistry::ROOT , sImplValueName, storeAccessMode::Create) )
 293     {
 294         return RegError::SET_VALUE_FAILED;
 295     }
 296
 297     sal_uInt32 size = vSize;
 298
 299     sal_uInt8 type = static_cast<sal_uInt8>(vType);
 300     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
 301     memcpy(pBuffer.get(), &type, 1);
 302
 303     writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
 304
 305     switch (vType)
 306     {
 307         case RegValueType::NOT_DEFINED:
 308             memcpy(pBuffer.get()+VALUE_HEADEROFFSET, value, size);
 309             break;
 310         case RegValueType::LONG:
 311             writeINT32(pBuffer.get()+VALUE_HEADEROFFSET, *static_cast<sal_Int32*>(value));
 312             break;
 313         case RegValueType::STRING:
 314             writeUtf8(pBuffer.get()+VALUE_HEADEROFFSET, static_cast<const char*>(value));
 315             break;
 316         case RegValueType::UNICODE:
 317             writeString(pBuffer.get()+VALUE_HEADEROFFSET, static_cast<const sal_Unicode*>(value));
 318             break;
 319         case RegValueType::BINARY:
 320             memcpy(pBuffer.get()+VALUE_HEADEROFFSET, value, size);
 321             break;
 322         default:
 323             OSL_ASSERT(false);
 324             break;
 325     }
 326
 327     sal_uInt32  writenBytes;
 328     if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
 329     {
 330         return RegError::SET_VALUE_FAILED;
 331     }
 332     if (writenBytes != (VALUE_HEADERSIZE+size))
 333     {
 334         return RegError::SET_VALUE_FAILED;
 335     }
 336     setModified();
 337
 338     return RegError::NO_ERROR;
 339 }
 340
 341
 342 //  setLongListValue
 343
 344 RegError ORegKey::setLongListValue(const OUString& valueName, sal_Int32 const * pValueList, sal_uInt32 len)
 345 {
 346     OStoreStream    rValue;
 347     std::unique_ptr<sal_uInt8[]> pBuffer;
 348
 349     if (m_pRegistry->isReadOnly())
 350     {
 351         return RegError::REGISTRY_READONLY;
 352     }
 353
 354     OUString sImplValueName = VALUE_PREFIX + valueName;
 355
 356     REG_GUARD(m_pRegistry->m_mutex);
 357
 358     if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, storeAccessMode::Create) )
 359     {
 360         return RegError::SET_VALUE_FAILED;
 361     }
 362
 363     sal_uInt32 size = 4; // 4 bytes (sal_uInt32) for the length
 364
 365     size += len * 4;
 366
 367     sal_uInt8 type = sal_uInt8(RegValueType::LONGLIST);
 368     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
 369     memcpy(pBuffer.get(), &type, 1);
 370
 371     writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
 372     writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET, len);
 373
 374     sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
 375
 376     for (sal_uInt32 i=0; i < len; i++)
 377     {
 378         writeINT32(pBuffer.get()+VALUE_HEADEROFFSET+offset, pValueList[i]);
 379         offset += 4;
 380     }
 381
 382     sal_uInt32  writenBytes;
 383     if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
 384     {
 385         return RegError::SET_VALUE_FAILED;
 386     }
 387     if (writenBytes != (VALUE_HEADEROFFSET+size))
 388     {
 389         return RegError::SET_VALUE_FAILED;
 390     }
 391     setModified();
 392
 393     return RegError::NO_ERROR;
 394 }
 395
 396
 397 //  setStringListValue
 398
 399 RegError ORegKey::setStringListValue(const OUString& valueName, char** pValueList, sal_uInt32 len)
 400 {
 401     OStoreStream    rValue;
 402     std::unique_ptr<sal_uInt8[]> pBuffer;
 403
 404     if (m_pRegistry->isReadOnly())
 405     {
 406         return RegError::REGISTRY_READONLY;
 407     }
 408
 409     OUString sImplValueName = VALUE_PREFIX + valueName;
 410
 411     REG_GUARD(m_pRegistry->m_mutex);
 412
 413     if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, storeAccessMode::Create) )
 414     {
 415         return RegError::SET_VALUE_FAILED;
 416     }
 417
 418     sal_uInt32 size = 4; // 4 bytes (sal_uInt32) for the length
 419
 420     sal_uInt32 i;
 421     for (i=0; i < len; i++)
 422     {
 423         size +=  4 + strlen(pValueList[i]) + 1;
 424     }
 425
 426     sal_uInt8 type = sal_uInt8(RegValueType::STRINGLIST);
 427     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
 428     memcpy(pBuffer.get(), &type, 1);
 429
 430     writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
 431     writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET, len);
 432
 433     sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
 434     sal_uInt32 sLen = 0;
 435
 436     for (i=0; i < len; i++)
 437     {
 438         sLen = strlen(pValueList[i]) + 1;
 439         writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET+offset, sLen);
 440
 441         offset += 4;
 442         writeUtf8(pBuffer.get()+VALUE_HEADEROFFSET+offset, pValueList[i]);
 443         offset += sLen;
 444     }
 445
 446     sal_uInt32  writenBytes;
 447     if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
 448     {
 449         return RegError::SET_VALUE_FAILED;
 450     }
 451     if (writenBytes != (VALUE_HEADERSIZE+size))
 452     {
 453         return RegError::SET_VALUE_FAILED;
 454     }
 455     setModified();
 456
 457     return RegError::NO_ERROR;
 458 }
 459
 460
 461 //  setUnicodeListValue
 462
 463 RegError ORegKey::setUnicodeListValue(const OUString& valueName, sal_Unicode** pValueList, sal_uInt32 len)
 464 {
 465     OStoreStream    rValue;
 466     std::unique_ptr<sal_uInt8[]> pBuffer;
 467
 468     if (m_pRegistry->isReadOnly())
 469     {
 470         return RegError::REGISTRY_READONLY;
 471     }
 472
 473     OUString sImplValueName = VALUE_PREFIX + valueName;
 474
 475     REG_GUARD(m_pRegistry->m_mutex);
 476
 477     if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, storeAccessMode::Create) )
 478     {
 479         return RegError::SET_VALUE_FAILED;
 480     }
 481
 482     sal_uInt32 size = 4; // 4 bytes (sal_uInt32) for the length
 483
 484     sal_uInt32 i;
 485     for (i=0; i < len; i++)
 486     {
 487         size +=  4 + ((rtl_ustr_getLength(pValueList[i]) +1) * 2);
 488     }
 489
 490     sal_uInt8 type = sal_uInt8(RegValueType::UNICODELIST);
 491     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
 492     memcpy(pBuffer.get(), &type, 1);
 493
 494     writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
 495     writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET, len);
 496
 497     sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
 498     sal_uInt32 sLen = 0;
 499
 500     for (i=0; i < len; i++)
 501     {
 502         sLen = (rtl_ustr_getLength(pValueList[i]) + 1) * 2;
 503         writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET+offset, sLen);
 504
 505         offset += 4;
 506         writeString(pBuffer.get()+VALUE_HEADEROFFSET+offset, pValueList[i]);
 507         offset += sLen;
 508     }
 509
 510     sal_uInt32  writenBytes;
 511     if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
 512     {
 513         return RegError::SET_VALUE_FAILED;
 514     }
 515     if (writenBytes != (VALUE_HEADERSIZE+size))
 516     {
 517         return RegError::SET_VALUE_FAILED;
 518     }
 519     setModified();
 520
 521     return RegError::NO_ERROR;
 522 }
 523
 524
 525 //  getValue
 526
 527 RegError ORegKey::getValue(const OUString& valueName, RegValue value) const
 528 {
 529     OStoreStream    rValue;
 530     std::unique_ptr<sal_uInt8[]> pBuffer;
 531     RegValueType    valueType;
 532     sal_uInt32      valueSize;
 533     storeAccessMode accessMode = storeAccessMode::ReadWrite;
 534
 535     if (m_pRegistry->isReadOnly())
 536     {
 537         accessMode = storeAccessMode::ReadOnly;
 538     }
 539
 540     OUString sImplValueName = VALUE_PREFIX + valueName;
 541
 542     REG_GUARD(m_pRegistry->m_mutex);
 543
 544     if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
 545     {
 546         return RegError::VALUE_NOT_EXISTS;
 547     }
 548
 549     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
 550
 551     sal_uInt32  readBytes;
 552     if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
 553     {
 554         return RegError::INVALID_VALUE;
 555     }
 556     if (readBytes != VALUE_HEADERSIZE)
 557     {
 558         return RegError::INVALID_VALUE;
 559     }
 560
 561     sal_uInt8   type = pBuffer[0];
 562     valueType = static_cast<RegValueType>(type);
 563     readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
 564
 565     if (valueType > RegValueType::BINARY)
 566     {
 567         return RegError::INVALID_VALUE;
 568     }
 569
 570     pBuffer.reset(new sal_uInt8[valueSize]);
 571
 572     if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
 573     {
 574         return RegError::INVALID_VALUE;
 575     }
 576     if (readBytes != valueSize)
 577     {
 578         return RegError::INVALID_VALUE;
 579     }
 580
 581     switch (valueType)
 582     {
 583         case RegValueType::NOT_DEFINED:
 584             memcpy(value, pBuffer.get(), valueSize);
 585             break;
 586         case RegValueType::LONG:
 587             readINT32(pBuffer.get(), *static_cast<sal_Int32*>(value));
 588             break;
 589         case RegValueType::STRING:
 590             readUtf8(pBuffer.get(), static_cast<char*>(value), valueSize);
 591             break;
 592         case RegValueType::UNICODE:
 593             readString(pBuffer.get(), static_cast<sal_Unicode*>(value), valueSize);
 594             break;
 595         case RegValueType::BINARY:
 596             memcpy(value, pBuffer.get(), valueSize);
 597             break;
 598         // coverity[dead_error_begin] - following conditions exist to avoid compiler warning
 599         case RegValueType::LONGLIST:
 600         case RegValueType::STRINGLIST:
 601         case RegValueType::UNICODELIST:
 602             memcpy(value, pBuffer.get(), valueSize);
 603             break;
 604     }
 605
 606     return RegError::NO_ERROR;
 607 }
 608
 609
 610 //  getLongListValue
 611
 612 RegError ORegKey::getLongListValue(const OUString& valueName, sal_Int32** pValueList, sal_uInt32* pLen) const
 613 {
 614     OStoreStream    rValue;
 615     std::unique_ptr<sal_uInt8[]> pBuffer;
 616     RegValueType    valueType;
 617     sal_uInt32      valueSize;
 618     storeAccessMode accessMode = storeAccessMode::ReadWrite;
 619
 620     if (m_pRegistry->isReadOnly())
 621     {
 622         accessMode = storeAccessMode::ReadOnly;
 623     }
 624
 625     OUString sImplValueName = VALUE_PREFIX + valueName;
 626
 627     REG_GUARD(m_pRegistry->m_mutex);
 628
 629     if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
 630     {
 631         pValueList = nullptr;
 632         *pLen = 0;
 633         return RegError::VALUE_NOT_EXISTS;
 634     }
 635
 636     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
 637
 638     sal_uInt32  readBytes;
 639     if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
 640     {
 641         pValueList = nullptr;
 642         *pLen = 0;
 643         return RegError::INVALID_VALUE;
 644     }
 645     if (readBytes != VALUE_HEADERSIZE)
 646     {
 647         pValueList = nullptr;
 648         *pLen = 0;
 649         return RegError::INVALID_VALUE;
 650     }
 651
 652     sal_uInt8   type = pBuffer[0];
 653     valueType = static_cast<RegValueType>(type);
 654
 655     if (valueType != RegValueType::LONGLIST)
 656     {
 657         pValueList = nullptr;
 658         *pLen = 0;
 659         return RegError::INVALID_VALUE;
 660     }
 661
 662     readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
 663
 664     /* check for 'reasonable' value */
 665     /* surely 10 millions entry in a registry list should be enough */
 666     if(valueSize > 40000000)
 667     {
 668         pValueList = nullptr;
 669         *pLen = 0;
 670         return RegError::INVALID_VALUE;
 671     }
 672     pBuffer.reset(new sal_uInt8[valueSize]);
 673
 674     if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
 675     {
 676         pValueList = nullptr;
 677         *pLen = 0;
 678         return RegError::INVALID_VALUE;
 679     }
 680     if (readBytes != valueSize)
 681     {
 682         pValueList = nullptr;
 683         *pLen = 0;
 684         return RegError::INVALID_VALUE;
 685     }
 686
 687     sal_uInt32 len = 0;
 688     readUINT32(pBuffer.get(), len);
 689
 690     /* make sure the declared size of the array is consistent with the amount of data we have read */
 691     if(len > (valueSize - 4) / 4)
 692     {
 693         pValueList = nullptr;
 694         *pLen = 0;
 695         return RegError::INVALID_VALUE;
 696     }
 697     *pLen = len;
 698     sal_Int32* pVList = static_cast<sal_Int32*>(rtl_allocateZeroMemory(len * sizeof(sal_Int32)));
 699
 700     sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
 701
 702     for (sal_uInt32 i = 0; i < len; i++)
 703     {
 704         readINT32(pBuffer.get()+offset, pVList[i]);
 705         offset += 4;
 706     }
 707
 708     *pValueList = pVList;
 709     return RegError::NO_ERROR;
 710 }
 711
 712
 713 //  getStringListValue
 714
 715 RegError ORegKey::getStringListValue(const OUString& valueName, char*** pValueList, sal_uInt32* pLen) const
 716 {
 717     OStoreStream    rValue;
 718     std::unique_ptr<sal_uInt8[]> pBuffer;
 719     RegValueType    valueType;
 720     sal_uInt32      valueSize;
 721     storeAccessMode accessMode = storeAccessMode::ReadWrite;
 722
 723     if (m_pRegistry->isReadOnly())
 724     {
 725         accessMode = storeAccessMode::ReadOnly;
 726     }
 727
 728     OUString sImplValueName = VALUE_PREFIX + valueName;
 729
 730     REG_GUARD(m_pRegistry->m_mutex);
 731
 732     if ( rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
 733     {
 734         pValueList = nullptr;
 735         *pLen = 0;
 736         return RegError::VALUE_NOT_EXISTS;
 737     }
 738
 739     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
 740
 741     sal_uInt32  readBytes;
 742     if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
 743     {
 744         pValueList = nullptr;
 745         *pLen = 0;
 746         return RegError::INVALID_VALUE;
 747     }
 748     if (readBytes != VALUE_HEADERSIZE)
 749     {
 750         pValueList = nullptr;
 751         *pLen = 0;
 752         return RegError::INVALID_VALUE;
 753     }
 754
 755     sal_uInt8   type = pBuffer[0];
 756     valueType = static_cast<RegValueType>(type);
 757
 758     if (valueType != RegValueType::STRINGLIST)
 759     {
 760         pValueList = nullptr;
 761         *pLen = 0;
 762         return RegError::INVALID_VALUE;
 763     }
 764
 765     readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
 766
 767     pBuffer.reset(new sal_uInt8[valueSize]);
 768
 769     if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
 770     {
 771         pValueList = nullptr;
 772         *pLen = 0;
 773         return RegError::INVALID_VALUE;
 774     }
 775     if (readBytes != valueSize)
 776     {
 777         pValueList = nullptr;
 778         *pLen = 0;
 779         return RegError::INVALID_VALUE;
 780     }
 781
 782     sal_uInt32 len = 0;
 783     readUINT32(pBuffer.get(), len);
 784
 785     *pLen = len;
 786     char** pVList = static_cast<char**>(rtl_allocateZeroMemory(len * sizeof(char*)));
 787
 788     sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
 789     sal_uInt32 sLen = 0;
 790
 791     char *pValue;
 792     for (sal_uInt32 i=0; i < len; i++)
 793     {
 794         readUINT32(pBuffer.get()+offset, sLen);
 795
 796         offset += 4;
 797
 798         pValue = static_cast<char*>(std::malloc(sLen));
 799         readUtf8(pBuffer.get()+offset, pValue, sLen);
 800         pVList[i] = pValue;
 801
 802         offset += sLen;
 803     }
 804
 805     *pValueList = pVList;
 806     return RegError::NO_ERROR;
 807 }
 808
 809
 810 //  getUnicodeListValue
 811
 812 RegError ORegKey::getUnicodeListValue(const OUString& valueName, sal_Unicode*** pValueList, sal_uInt32* pLen) const
 813 {
 814     OStoreStream    rValue;
 815     std::unique_ptr<sal_uInt8[]> pBuffer;
 816     RegValueType    valueType;
 817     sal_uInt32      valueSize;
 818     storeAccessMode accessMode = storeAccessMode::ReadWrite;
 819
 820     if (m_pRegistry->isReadOnly())
 821     {
 822         accessMode = storeAccessMode::ReadOnly;
 823     }
 824
 825     OUString sImplValueName = VALUE_PREFIX + valueName;
 826
 827     REG_GUARD(m_pRegistry->m_mutex);
 828
 829     if ( rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
 830     {
 831         pValueList = nullptr;
 832         *pLen = 0;
 833         return RegError::VALUE_NOT_EXISTS;
 834     }
 835
 836     pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
 837
 838     sal_uInt32  readBytes;
 839     if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
 840     {
 841         pValueList = nullptr;
 842         *pLen = 0;
 843         return RegError::INVALID_VALUE;
 844     }
 845     if (readBytes != VALUE_HEADERSIZE)
 846     {
 847         pValueList = nullptr;
 848         *pLen = 0;
 849         return RegError::INVALID_VALUE;
 850     }
 851
 852     sal_uInt8   type = pBuffer[0];
 853     valueType = static_cast<RegValueType>(type);
 854
 855     if (valueType != RegValueType::UNICODELIST)
 856     {
 857         pValueList = nullptr;
 858         *pLen = 0;
 859         return RegError::INVALID_VALUE;
 860     }
 861
 862     readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
 863
 864     pBuffer.reset(new sal_uInt8[valueSize]);
 865
 866     if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
 867     {
 868         pValueList = nullptr;
 869         *pLen = 0;
 870         return RegError::INVALID_VALUE;
 871     }
 872     if (readBytes != valueSize)
 873     {
 874         pValueList = nullptr;
 875         *pLen = 0;
 876         return RegError::INVALID_VALUE;
 877     }
 878
 879     sal_uInt32 len = 0;
 880     readUINT32(pBuffer.get(), len);
 881
 882     *pLen = len;
 883     sal_Unicode** pVList = static_cast<sal_Unicode**>(rtl_allocateZeroMemory(len * sizeof(sal_Unicode*)));
 884
 885     sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
 886     sal_uInt32 sLen = 0;
 887
 888     sal_Unicode *pValue;
 889     for (sal_uInt32 i=0; i < len; i++)
 890     {
 891         readUINT32(pBuffer.get()+offset, sLen);
 892
 893         offset += 4;
 894
 895         pValue = static_cast<sal_Unicode*>(std::malloc((sLen / 2) * sizeof(sal_Unicode)));
 896         readString(pBuffer.get()+offset, pValue, sLen);
 897         pVList[i] = pValue;
 898
 899         offset += sLen;
 900     }
 901
 902     *pValueList = pVList;
 903     return RegError::NO_ERROR;
 904 }
 905
 906
 907 RegError ORegKey::getResolvedKeyName(const OUString& keyName,
 908                                      OUString& resolvedName) const
 909 {
 910     if (keyName.isEmpty())
 911         return RegError::INVALID_KEYNAME;
 912
 913     resolvedName = getFullPath(keyName);
 914     return RegError::NO_ERROR;
 915 }
 916
 917
 918 //  countSubKeys()
 919
 920 sal_uInt32 ORegKey::countSubKeys()
 921 {
 922     REG_GUARD(m_pRegistry->m_mutex);
 923
 924     OStoreDirectory::iterator   iter;
 925     OStoreDirectory             rStoreDir = getStoreDir();
 926     storeError                  _err = rStoreDir.first(iter);
 927     sal_uInt32                  count = 0;
 928
 929     while ( _err == store_E_None )
 930     {
 931         if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
 932         {
 933             count++;
 934         }
 935
 936         _err = rStoreDir.next(iter);
 937     }
 938
 939     return count;
 940 }
 941
 942 OStoreDirectory ORegKey::getStoreDir() const
 943 {
 944     OStoreDirectory rStoreDir;
 945     OUString        fullPath;
 946     OUString        relativName;
 947     storeAccessMode accessMode = storeAccessMode::ReadWrite;
 948
 949     if ( m_name == ORegistry::ROOT )
 950     {
 951         fullPath.clear();
 952         relativName.clear();
 953     } else
 954     {
 955         fullPath = m_name.copy(0, m_name.lastIndexOf('/') + 1);
 956         relativName = m_name.copy(m_name.lastIndexOf('/') + 1);
 957     }
 958
 959     if (m_pRegistry->isReadOnly())
 960     {
 961         accessMode = storeAccessMode::ReadOnly;
 962     }
 963
 964     rStoreDir.create(getStoreFile(), fullPath, relativName, accessMode);
 965
 966     return rStoreDir;
 967 }
 968
 969 OUString ORegKey::getFullPath(OUString const & path) const {
 970     OSL_ASSERT(!m_name.isEmpty() && !path.isEmpty());
 971     OUStringBuffer b(32);
 972     b.append(m_name);
 973     if (!b.isEmpty() && b[b.getLength() - 1] == '/') {
 974         if (path[0] == '/') {
 975             b.append(std::u16string_view(path).substr(1));
 976         } else {
 977             b.append(path);
 978         }
 979     } else {
 980         if (path[0] != '/') {
 981             b.append('/');
 982         }
 983         b.append(path);
 984     }
 985     return b.makeStringAndClear();
 986 }
 987
 988 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */