| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_registry.hxx" |
| |
| #include "keyimpl.hxx" |
| |
| #include "reflcnst.hxx" |
| #include "rtl/alloc.h" |
| #include "rtl/memory.h" |
| #include "rtl/ustrbuf.hxx" |
| |
| using rtl::OUString; |
| using rtl::OUStringBuffer; |
| using namespace store; |
| |
| namespace { static char const VALUE_PREFIX[] = "$VL_"; } |
| |
| //********************************************************************* |
| // ORegKey() |
| // |
| ORegKey::ORegKey(const OUString& keyName, ORegistry* pReg) |
| : m_refCount(1) |
| , m_name(keyName) |
| , m_bDeleted(0) |
| , m_bModified(0) |
| , m_pRegistry(pReg) |
| { |
| } |
| |
| //********************************************************************* |
| // ~ORegKey() |
| // |
| ORegKey::~ORegKey() |
| { |
| OSL_POSTCOND(m_refCount == 0, "registry::ORegKey::dtor(): refcount not zero."); |
| } |
| |
| //********************************************************************* |
| // acquireKey |
| // |
| RegError ORegKey::acquireKey(RegKeyHandle hKey) |
| { |
| return m_pRegistry->acquireKey(hKey); |
| } |
| |
| //********************************************************************* |
| // releaseKey |
| // |
| RegError ORegKey::releaseKey(RegKeyHandle hKey) |
| { |
| return m_pRegistry->releaseKey(hKey); |
| } |
| |
| //********************************************************************* |
| // createKey |
| // |
| RegError ORegKey::createKey(const OUString& keyName, RegKeyHandle* phNewKey) |
| { |
| return m_pRegistry->createKey(this, keyName, phNewKey); |
| } |
| |
| |
| //********************************************************************* |
| // openKey |
| // |
| RegError ORegKey::openKey(const OUString& keyName, RegKeyHandle* phOpenKey) |
| { |
| return m_pRegistry->openKey(this, keyName, phOpenKey); |
| } |
| |
| |
| //********************************************************************* |
| // openSubKeys |
| // |
| RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubKeys, sal_uInt32* pnSubKeys) |
| { |
| RegError _ret = REG_NO_ERROR; |
| |
| *phOpenSubKeys = 0; |
| *pnSubKeys = 0; |
| |
| ORegKey* pKey = this; |
| if ( keyName.getLength() ) |
| { |
| _ret = openKey(keyName, (RegKeyHandle*)&pKey); |
| if (_ret != REG_NO_ERROR) |
| return _ret; |
| } |
| |
| sal_uInt32 nSubKeys = pKey->countSubKeys(); |
| *pnSubKeys = nSubKeys; |
| |
| ORegKey** pSubKeys; |
| pSubKeys = (ORegKey**)rtl_allocateZeroMemory(nSubKeys * sizeof(ORegKey*)); |
| |
| OStoreDirectory::iterator iter; |
| OStoreDirectory rStoreDir(pKey->getStoreDir()); |
| storeError _err = rStoreDir.first(iter); |
| |
| nSubKeys = 0; |
| while ( _err == store_E_None ) |
| { |
| if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR ) |
| { |
| OUString const sSubKeyName = iter.m_pszName; |
| |
| ORegKey* pOpenSubKey = 0; |
| _ret = pKey->openKey(sSubKeyName, (RegKeyHandle*)&pOpenSubKey); |
| if (_ret != REG_NO_ERROR) |
| { |
| *phOpenSubKeys = NULL; |
| *pnSubKeys = 0; |
| rtl_freeMemory(pSubKeys); // @@@ leaking 'pSubKeys[0...nSubkeys-1]' |
| return _ret; // @@@ leaking 'pKey' |
| } |
| |
| pSubKeys[nSubKeys] = pOpenSubKey; |
| |
| nSubKeys++; |
| } |
| |
| _err = rStoreDir.next(iter); |
| } |
| |
| *phOpenSubKeys = (RegKeyHandle*)pSubKeys; |
| if (keyName.getLength()) |
| { |
| (void) releaseKey(pKey); |
| } |
| return REG_NO_ERROR; |
| } |
| |
| |
| //********************************************************************* |
| // getKeyNames |
| // |
| RegError ORegKey::getKeyNames(const OUString& keyName, |
| rtl_uString*** pSubKeyNames, |
| sal_uInt32* pnSubKeys) |
| { |
| RegError _ret = REG_NO_ERROR; |
| |
| *pSubKeyNames = 0; |
| *pnSubKeys = 0; |
| |
| ORegKey* pKey = this; |
| if (keyName.getLength()) |
| { |
| _ret = openKey(keyName, (RegKeyHandle*)&pKey); |
| if (_ret != REG_NO_ERROR) |
| return _ret; |
| } |
| |
| sal_uInt32 nSubKeys = pKey->countSubKeys(); |
| *pnSubKeys = nSubKeys; |
| |
| rtl_uString** pSubKeys = 0; |
| pSubKeys = (rtl_uString**)rtl_allocateZeroMemory(nSubKeys * sizeof(rtl_uString*)); |
| |
| OStoreDirectory::iterator iter; |
| OStoreDirectory rStoreDir(pKey->getStoreDir()); |
| storeError _err = rStoreDir.first(iter); |
| |
| nSubKeys = 0; |
| |
| while ( _err == store_E_None ) |
| { |
| if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR) |
| { |
| OUString const sSubKeyName = iter.m_pszName; |
| |
| OUString sFullKeyName(pKey->getName()); |
| if (sFullKeyName.getLength() > 1) |
| sFullKeyName += m_pRegistry->ROOT; |
| sFullKeyName += sSubKeyName; |
| |
| rtl_uString_newFromString(&pSubKeys[nSubKeys], sFullKeyName.pData); |
| |
| nSubKeys++; |
| } |
| |
| _err = rStoreDir.next(iter); |
| } |
| |
| *pSubKeyNames = pSubKeys; |
| if (keyName.getLength()) |
| { |
| releaseKey(pKey); |
| } |
| return REG_NO_ERROR; |
| } |
| |
| |
| //********************************************************************* |
| // closeKey |
| // |
| RegError ORegKey::closeKey(RegKeyHandle hKey) |
| { |
| return (m_pRegistry->closeKey(hKey)); |
| } |
| |
| |
| //********************************************************************* |
| // deleteKey |
| // |
| RegError ORegKey::deleteKey(const OUString& keyName) |
| { |
| return (m_pRegistry->deleteKey(this, keyName)); |
| } |
| |
| |
| //********************************************************************* |
| // getValueType |
| // |
| RegError ORegKey::getValueInfo(const OUString& valueName, RegValueType* pValueType, sal_uInt32* pValueSize) const |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| storeAccessMode accessMode = VALUE_MODE_OPEN; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| accessMode = VALUE_MODE_OPENREAD; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if ( rValue.create(m_pRegistry->getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) ) |
| { |
| *pValueType = RG_VALUETYPE_NOT_DEFINED; |
| *pValueSize = 0; |
| return REG_VALUE_NOT_EXISTS; |
| } |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE); |
| |
| sal_uInt32 readBytes; |
| if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) ) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != VALUE_HEADERSIZE) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt32 size; |
| sal_uInt8 type = *((sal_uInt8*)pBuffer); |
| readUINT32(pBuffer+VALUE_TYPEOFFSET, size); |
| |
| *pValueType = (RegValueType)type; |
| // if (*pValueType == RG_VALUETYPE_UNICODE) |
| // { |
| // *pValueSize = (size / 2) * sizeof(sal_Unicode); |
| // } else |
| // { |
| if (*pValueType > 4) |
| { |
| rtl_freeMemory(pBuffer); |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(4); |
| rValue.readAt(VALUE_HEADEROFFSET, pBuffer, 4, readBytes); |
| |
| readUINT32(pBuffer, size); |
| } |
| |
| *pValueSize = size; |
| // } |
| |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| |
| //********************************************************************* |
| // setValue |
| // |
| RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegValue value, sal_uInt32 vSize) |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| return REG_REGISTRY_READONLY; |
| } |
| |
| if (vType > 4) |
| { |
| return REG_INVALID_VALUE; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if ( rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT , sImplValueName, VALUE_MODE_CREATE) ) |
| { |
| return REG_SET_VALUE_FAILED; |
| } |
| |
| sal_uInt32 size = vSize; |
| |
| sal_uInt8 type = (sal_uInt8)vType; |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size); |
| rtl_copyMemory(pBuffer, &type, 1); |
| |
| writeUINT32(pBuffer+VALUE_TYPEOFFSET, size); |
| |
| switch (vType) |
| { |
| case RG_VALUETYPE_NOT_DEFINED: |
| rtl_copyMemory(pBuffer+VALUE_HEADEROFFSET, value, size); |
| break; |
| case RG_VALUETYPE_LONG: |
| writeINT32(pBuffer+VALUE_HEADEROFFSET, *((sal_Int32*)value)); |
| break; |
| case RG_VALUETYPE_STRING: |
| writeUtf8(pBuffer+VALUE_HEADEROFFSET, (const sal_Char*)value); |
| break; |
| case RG_VALUETYPE_UNICODE: |
| writeString(pBuffer+VALUE_HEADEROFFSET, (const sal_Unicode*)value); |
| break; |
| case RG_VALUETYPE_BINARY: |
| rtl_copyMemory(pBuffer+VALUE_HEADEROFFSET, value, size); |
| break; |
| default: |
| OSL_ASSERT(false); |
| break; |
| } |
| |
| sal_uInt32 writenBytes; |
| if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) ) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| if (writenBytes != (VALUE_HEADERSIZE+size)) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| setModified(); |
| |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // setLongListValue |
| // |
| RegError ORegKey::setLongListValue(const OUString& valueName, sal_Int32* pValueList, sal_uInt32 len) |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| return REG_REGISTRY_READONLY; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, VALUE_MODE_CREATE) ) |
| { |
| return REG_SET_VALUE_FAILED; |
| } |
| |
| sal_uInt32 size = 4; // 4 Bytes (sal_uInt32) fuer die Laenge |
| |
| size += len * 4; |
| |
| sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_LONGLIST; |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size); |
| rtl_copyMemory(pBuffer, &type, 1); |
| |
| writeUINT32(pBuffer+VALUE_TYPEOFFSET, size); |
| writeUINT32(pBuffer+VALUE_HEADEROFFSET, len); |
| |
| sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays |
| |
| for (sal_uInt32 i=0; i < len; i++) |
| { |
| writeINT32(pBuffer+VALUE_HEADEROFFSET+offset, pValueList[i]); |
| offset += 4; |
| } |
| |
| sal_uInt32 writenBytes; |
| if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) ) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| if (writenBytes != (VALUE_HEADEROFFSET+size)) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| setModified(); |
| |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // setStringListValue |
| // |
| RegError ORegKey::setStringListValue(const OUString& valueName, sal_Char** pValueList, sal_uInt32 len) |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| return REG_REGISTRY_READONLY; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, VALUE_MODE_CREATE) ) |
| { |
| return REG_SET_VALUE_FAILED; |
| } |
| |
| sal_uInt32 size = 4; // 4 Bytes (sal_uInt32) fuer die Laenge |
| |
| sal_uInt32 i; |
| for (i=0; i < len; i++) |
| { |
| size += 4 + strlen(pValueList[i]) + 1; |
| } |
| |
| sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_STRINGLIST; |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size); |
| rtl_copyMemory(pBuffer, &type, 1); |
| |
| writeUINT32(pBuffer+VALUE_TYPEOFFSET, size); |
| writeUINT32(pBuffer+VALUE_HEADEROFFSET, len); |
| |
| sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays; |
| sal_uInt32 sLen = 0; |
| |
| for (i=0; i < len; i++) |
| { |
| sLen = strlen(pValueList[i]) + 1; |
| writeUINT32(pBuffer+VALUE_HEADEROFFSET+offset, sLen); |
| |
| offset += 4; |
| writeUtf8(pBuffer+VALUE_HEADEROFFSET+offset, pValueList[i]); |
| offset += sLen; |
| } |
| |
| sal_uInt32 writenBytes; |
| if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) ) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| if (writenBytes != (VALUE_HEADERSIZE+size)) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| setModified(); |
| |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // setUnicodeListValue |
| // |
| RegError ORegKey::setUnicodeListValue(const OUString& valueName, sal_Unicode** pValueList, sal_uInt32 len) |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| return REG_REGISTRY_READONLY; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, VALUE_MODE_CREATE) ) |
| { |
| return REG_SET_VALUE_FAILED; |
| } |
| |
| sal_uInt32 size = 4; // 4 Bytes (sal_uInt32) fuer die Laenge |
| |
| sal_uInt32 i; |
| for (i=0; i < len; i++) |
| { |
| size += 4 + ((rtl_ustr_getLength(pValueList[i]) +1) * 2); |
| } |
| |
| sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_UNICODELIST; |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size); |
| rtl_copyMemory(pBuffer, &type, 1); |
| |
| writeUINT32(pBuffer+VALUE_TYPEOFFSET, size); |
| writeUINT32(pBuffer+VALUE_HEADEROFFSET, len); |
| |
| sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays; |
| sal_uInt32 sLen = 0; |
| |
| for (i=0; i < len; i++) |
| { |
| sLen = (rtl_ustr_getLength(pValueList[i]) + 1) * 2; |
| writeUINT32(pBuffer+VALUE_HEADEROFFSET+offset, sLen); |
| |
| offset += 4; |
| writeString(pBuffer+VALUE_HEADEROFFSET+offset, pValueList[i]); |
| offset += sLen; |
| } |
| |
| sal_uInt32 writenBytes; |
| if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) ) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| if (writenBytes != (VALUE_HEADERSIZE+size)) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_SET_VALUE_FAILED; |
| } |
| setModified(); |
| |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // getValue |
| // |
| RegError ORegKey::getValue(const OUString& valueName, RegValue value) const |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| RegValueType valueType; |
| sal_uInt32 valueSize; |
| storeAccessMode accessMode = VALUE_MODE_OPEN; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| accessMode = VALUE_MODE_OPENREAD; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) ) |
| { |
| return REG_VALUE_NOT_EXISTS; |
| } |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE); |
| |
| sal_uInt32 readBytes; |
| if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) ) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != VALUE_HEADERSIZE) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt8 type = *((sal_uInt8*)pBuffer); |
| valueType = (RegValueType)type; |
| readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize); |
| |
| rtl_freeMemory(pBuffer); |
| |
| if (valueType > 4) |
| { |
| return REG_INVALID_VALUE; |
| } |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize); |
| |
| if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) ) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != valueSize) |
| { |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| switch (valueType) |
| { |
| case RG_VALUETYPE_NOT_DEFINED: |
| rtl_copyMemory(value, pBuffer, valueSize); |
| break; |
| case RG_VALUETYPE_LONG: |
| readINT32(pBuffer, *((sal_Int32*)value)); |
| break; |
| case RG_VALUETYPE_STRING: |
| readUtf8(pBuffer, (sal_Char*)value, valueSize); |
| break; |
| case RG_VALUETYPE_UNICODE: |
| readString(pBuffer, (sal_Unicode*)value, valueSize); |
| break; |
| case RG_VALUETYPE_BINARY: |
| rtl_copyMemory(value, pBuffer, valueSize); |
| break; |
| case RG_VALUETYPE_LONGLIST: |
| case RG_VALUETYPE_STRINGLIST: |
| case RG_VALUETYPE_UNICODELIST: |
| rtl_copyMemory(value, pBuffer, valueSize); |
| break; |
| } |
| |
| |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // getLongListValue |
| // |
| RegError ORegKey::getLongListValue(const OUString& valueName, sal_Int32** pValueList, sal_uInt32* pLen) const |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| RegValueType valueType; |
| sal_uInt32 valueSize; |
| storeAccessMode accessMode = VALUE_MODE_OPEN; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| accessMode = VALUE_MODE_OPENREAD; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| return REG_VALUE_NOT_EXISTS; |
| } |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE); |
| |
| sal_uInt32 readBytes; |
| if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != VALUE_HEADERSIZE) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt8 type = *((sal_uInt8*)pBuffer); |
| valueType = (RegValueType)type; |
| |
| if (valueType != RG_VALUETYPE_LONGLIST) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize); |
| |
| rtl_freeMemory(pBuffer); |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize); |
| |
| if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != valueSize) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt32 len = 0; |
| readUINT32(pBuffer, len); |
| |
| *pLen = len; |
| sal_Int32* pVList = (sal_Int32*)rtl_allocateZeroMemory(len * sizeof(sal_Int32)); |
| |
| sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays; |
| |
| for (sal_uInt32 i=0; i < len; i++) |
| { |
| readINT32(pBuffer+offset, pVList[i]); |
| offset += 4; |
| } |
| |
| *pValueList = pVList; |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // getStringListValue |
| // |
| RegError ORegKey::getStringListValue(const OUString& valueName, sal_Char*** pValueList, sal_uInt32* pLen) const |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| RegValueType valueType; |
| sal_uInt32 valueSize; |
| storeAccessMode accessMode = VALUE_MODE_OPEN; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| accessMode = VALUE_MODE_OPENREAD; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if ( rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| return REG_VALUE_NOT_EXISTS; |
| } |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE); |
| |
| sal_uInt32 readBytes; |
| if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != VALUE_HEADERSIZE) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt8 type = *((sal_uInt8*)pBuffer); |
| valueType = (RegValueType)type; |
| |
| if (valueType != RG_VALUETYPE_STRINGLIST) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize); |
| |
| rtl_freeMemory(pBuffer); |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize); |
| |
| if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != valueSize) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt32 len = 0; |
| readUINT32(pBuffer, len); |
| |
| *pLen = len; |
| sal_Char** pVList = (sal_Char**)rtl_allocateZeroMemory(len * sizeof(sal_Char*)); |
| |
| sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays; |
| sal_uInt32 sLen = 0; |
| |
| sal_Char *pValue; |
| for (sal_uInt32 i=0; i < len; i++) |
| { |
| readUINT32(pBuffer+offset, sLen); |
| |
| offset += 4; |
| |
| pValue = (sal_Char*)rtl_allocateMemory(sLen); |
| readUtf8(pBuffer+offset, pValue, sLen); |
| pVList[i] = pValue; |
| |
| offset += sLen; |
| } |
| |
| *pValueList = pVList; |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // getUnicodeListValue |
| // |
| RegError ORegKey::getUnicodeListValue(const OUString& valueName, sal_Unicode*** pValueList, sal_uInt32* pLen) const |
| { |
| OStoreStream rValue; |
| sal_uInt8* pBuffer; |
| RegValueType valueType; |
| sal_uInt32 valueSize; |
| storeAccessMode accessMode = VALUE_MODE_OPEN; |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| accessMode = VALUE_MODE_OPENREAD; |
| } |
| |
| OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) ); |
| sImplValueName += valueName; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if ( rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| return REG_VALUE_NOT_EXISTS; |
| } |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE); |
| |
| sal_uInt32 readBytes; |
| if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != VALUE_HEADERSIZE) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt8 type = *((sal_uInt8*)pBuffer); |
| valueType = (RegValueType)type; |
| |
| if (valueType != RG_VALUETYPE_UNICODELIST) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize); |
| |
| rtl_freeMemory(pBuffer); |
| |
| pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize); |
| |
| if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) ) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| if (readBytes != valueSize) |
| { |
| pValueList = NULL; |
| *pLen = 0; |
| rtl_freeMemory(pBuffer); |
| return REG_INVALID_VALUE; |
| } |
| |
| sal_uInt32 len = 0; |
| readUINT32(pBuffer, len); |
| |
| *pLen = len; |
| sal_Unicode** pVList = (sal_Unicode**)rtl_allocateZeroMemory(len * sizeof(sal_Unicode*)); |
| |
| sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays; |
| sal_uInt32 sLen = 0; |
| |
| sal_Unicode *pValue; |
| for (sal_uInt32 i=0; i < len; i++) |
| { |
| readUINT32(pBuffer+offset, sLen); |
| |
| offset += 4; |
| |
| pValue = (sal_Unicode*)rtl_allocateMemory((sLen / 2) * sizeof(sal_Unicode)); |
| readString(pBuffer+offset, pValue, sLen); |
| pVList[i] = pValue; |
| |
| offset += sLen; |
| } |
| |
| *pValueList = pVList; |
| rtl_freeMemory(pBuffer); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // getKeyType() |
| // |
| RegError ORegKey::getKeyType(const OUString& name, RegKeyType* pKeyType) const |
| { |
| *pKeyType = RG_KEYTYPE; |
| |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| if ( name.getLength() ) |
| { |
| ORegKey* pThis = const_cast< ORegKey* >(this); |
| |
| RegKeyHandle hKey = 0; |
| RegError _ret = pThis->openKey(name, &hKey); |
| if (_ret != REG_NO_ERROR) |
| return _ret; |
| (void) pThis->releaseKey(hKey); |
| } |
| |
| return REG_NO_ERROR; |
| } |
| |
| RegError ORegKey::getResolvedKeyName(const OUString& keyName, |
| OUString& resolvedName) |
| { |
| if (keyName.getLength() == 0) |
| return REG_INVALID_KEYNAME; |
| |
| resolvedName = getFullPath(keyName); |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // countSubKeys() |
| // |
| sal_uInt32 ORegKey::countSubKeys() |
| { |
| REG_GUARD(m_pRegistry->m_mutex); |
| |
| OStoreDirectory::iterator iter; |
| OStoreDirectory rStoreDir = getStoreDir(); |
| storeError _err = rStoreDir.first(iter); |
| sal_uInt32 count = 0; |
| |
| while ( _err == store_E_None ) |
| { |
| if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR ) |
| { |
| count++; |
| } |
| |
| _err = rStoreDir.next(iter); |
| } |
| |
| return count; |
| } |
| |
| OStoreDirectory ORegKey::getStoreDir() |
| { |
| OStoreDirectory rStoreDir; |
| OUString fullPath; |
| OUString relativName; |
| storeAccessMode accessMode = KEY_MODE_OPEN; |
| |
| if ( m_name.equals(m_pRegistry->ROOT) ) |
| { |
| fullPath = OUString(); |
| relativName = OUString(); |
| } else |
| { |
| fullPath = m_name.copy(0, m_name.lastIndexOf('/') + 1); |
| relativName = m_name.copy(m_name.lastIndexOf('/') + 1); |
| } |
| |
| if (m_pRegistry->isReadOnly()) |
| { |
| accessMode = KEY_MODE_OPENREAD; |
| } |
| |
| rStoreDir.create(getStoreFile(), fullPath, relativName, accessMode); |
| |
| return rStoreDir; |
| } |
| |
| OUString ORegKey::getFullPath(OUString const & path) const { |
| OSL_ASSERT(m_name.getLength() != 0 && path.getLength() != 0); |
| OUStringBuffer b(m_name); |
| if (b.charAt(b.getLength() - 1) == '/') { |
| if (path[0] == '/') { |
| b.append(path.getStr() + 1, path.getLength() - 1); |
| } else { |
| b.append(path); |
| } |
| } else { |
| if (path[0] != '/') { |
| b.append(sal_Unicode('/')); |
| } |
| b.append(path); |
| } |
| return b.makeStringAndClear(); |
| } |
