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