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