/************************************************************** * * 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 "regkey.hxx" #include #include #include "regimpl.hxx" #include "keyimpl.hxx" using rtl::OUString; //********************************************************************* // acquireKey // void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (pKey != 0) { ORegistry* pReg = pKey->getRegistry(); (void) pReg->acquireKey(pKey); } } //********************************************************************* // releaseKey // void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (pKey != 0) { ORegistry* pReg = pKey->getRegistry(); (void) pReg->releaseKey(pKey); } } //********************************************************************* // isKeyReadOnly // sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey) { ORegKey* pKey = static_cast< ORegKey* >(hKey); return (pKey != 0) ? pKey->isReadOnly() : sal_False; } //********************************************************************* // getKeyName // RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (pKey) { rtl_uString_assign( pKeyName, pKey->getName().pData ); return REG_NO_ERROR; } else { rtl_uString_new(pKeyName); return REG_INVALID_KEY; } } //********************************************************************* // createKey // RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey, rtl_uString* keyName, RegKeyHandle* phNewKey) { *phNewKey = 0; ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; if (pKey->isReadOnly()) return REG_REGISTRY_READONLY; return pKey->createKey(keyName, phNewKey); } //********************************************************************* // openKey // RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey, rtl_uString* keyName, RegKeyHandle* phOpenKey) { *phOpenKey = 0; ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; return pKey->openKey(keyName, phOpenKey); } //********************************************************************* // openSubKeys // RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey, rtl_uString* keyName, RegKeyHandle** pphSubKeys, sal_uInt32* pnSubKeys) { *pphSubKeys = NULL; *pnSubKeys = 0; ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys); } //********************************************************************* // closeSubKeys // RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys, sal_uInt32 nSubKeys) { if (phSubKeys == 0 || nSubKeys == 0) return REG_INVALID_KEY; ORegistry* pReg = ((ORegKey*)(phSubKeys[0]))->getRegistry(); for (sal_uInt32 i = 0; i < nSubKeys; i++) { (void) pReg->closeKey(phSubKeys[i]); } rtl_freeMemory(phSubKeys); return REG_NO_ERROR; } //********************************************************************* // deleteKey // RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey, rtl_uString* keyName) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; if (pKey->isReadOnly()) return REG_REGISTRY_READONLY; return pKey->deleteKey(keyName); } //********************************************************************* // closeKey // RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; return pKey->closeKey(hKey); } //********************************************************************* // setValue // RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey, rtl_uString* keyName, RegValueType valueType, RegValue pData, sal_uInt32 valueSize) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; if (pKey->isReadOnly()) return REG_REGISTRY_READONLY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize); if (_ret1 != REG_NO_ERROR) { RegError _ret2 = pKey->closeKey(pSubKey); if (_ret2) return _ret2; else return _ret1; } return pKey->closeKey(pSubKey); } return pKey->setValue(valueName, valueType, pData, valueSize); } //********************************************************************* // setLongValueList // RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Int32* pValueList, sal_uInt32 len) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; if (pKey->isReadOnly()) return REG_REGISTRY_READONLY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->setLongListValue(valueName, pValueList, len); if (_ret1 != REG_NO_ERROR) { RegError _ret2 = pKey->closeKey(pSubKey); if (_ret2 != REG_NO_ERROR) return _ret2; else return _ret1; } return pKey->closeKey(pSubKey); } return pKey->setLongListValue(valueName, pValueList, len); } //********************************************************************* // setStringValueList // RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Char** pValueList, sal_uInt32 len) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; if (pKey->isReadOnly()) return REG_REGISTRY_READONLY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->setStringListValue(valueName, pValueList, len); if (_ret1 != REG_NO_ERROR) { RegError _ret2 = pKey->closeKey(pSubKey); if (_ret2 != REG_NO_ERROR) return _ret2; else return _ret1; } return pKey->closeKey(pSubKey); } return pKey->setStringListValue(valueName, pValueList, len); } //********************************************************************* // setUnicodeValueList // RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Unicode** pValueList, sal_uInt32 len) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; if (pKey->isReadOnly()) return REG_REGISTRY_READONLY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len); if (_ret1 != REG_NO_ERROR) { RegError _ret2 = pKey->closeKey(pSubKey); if (_ret2 != REG_NO_ERROR) return _ret2; else return _ret1; } return pKey->closeKey(pSubKey); } return pKey->setUnicodeListValue(valueName, pValueList, len); } //********************************************************************* // getValueInfo // RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey, rtl_uString* keyName, RegValueType* pValueType, sal_uInt32* pValueSize) { *pValueType = RG_VALUETYPE_NOT_DEFINED; *pValueSize = 0; ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; RegValueType valueType; sal_uInt32 valueSize; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret != REG_NO_ERROR) return _ret; if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR) { (void) pKey->releaseKey(pSubKey); return REG_INVALID_VALUE; } *pValueType = valueType; *pValueSize = valueSize; return pKey->releaseKey(pSubKey); } if (pKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR) { return REG_INVALID_VALUE; } *pValueType = valueType; *pValueSize = valueSize; return REG_NO_ERROR; } //********************************************************************* // getValueInfo // RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey, rtl_uString* keyName, RegValue pValue) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->getValue(valueName, pValue); if (_ret1 != REG_NO_ERROR) { (void) pKey->releaseKey(pSubKey); return _ret1; } return pKey->releaseKey(pSubKey); } return pKey->getValue(valueName, pValue); } //********************************************************************* // getLongValueList // RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Int32** pValueList, sal_uInt32* pLen) { OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getLongListValue(): invalid parameter"); *pValueList = 0, *pLen = 0; ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen); if (_ret1 != REG_NO_ERROR) { (void) pKey->releaseKey(pSubKey); return _ret1; } return pKey->releaseKey(pSubKey); } return pKey->getLongListValue(valueName, pValueList, pLen); } //********************************************************************* // getStringValueList // RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Char*** pValueList, sal_uInt32* pLen) { OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getStringListValue(): invalid parameter"); *pValueList = 0, *pLen = 0; ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen); if (_ret1 != REG_NO_ERROR) { (void) pKey->releaseKey(pSubKey); return _ret1; } return pKey->releaseKey(pSubKey); } return pKey->getStringListValue(valueName, pValueList, pLen); } //********************************************************************* // getUnicodeListValue // RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Unicode*** pValueList, sal_uInt32* pLen) { OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getUnicodeListValue(): invalid parameter"); *pValueList = 0, *pLen = 0; ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); if (keyName->length) { ORegKey* pSubKey = 0; RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); if (_ret1 != REG_NO_ERROR) return _ret1; _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen); if (_ret1 != REG_NO_ERROR) { (void) pKey->releaseKey(pSubKey); return _ret1; } return pKey->releaseKey(pSubKey); } return pKey->getUnicodeListValue(valueName, pValueList, pLen); } //********************************************************************* // freeValueList // RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType, RegValue pValueList, sal_uInt32 len) { switch (valueType) { case 5: { rtl_freeMemory(pValueList); } break; case 6: { sal_Char** pVList = (sal_Char**)pValueList; for (sal_uInt32 i=0; i < len; i++) { rtl_freeMemory(pVList[i]); } rtl_freeMemory(pVList); } break; case 7: { sal_Unicode** pVList = (sal_Unicode**)pValueList; for (sal_uInt32 i=0; i < len; i++) { rtl_freeMemory(pVList[i]); } rtl_freeMemory(pVList); } break; default: return REG_INVALID_VALUE; } pValueList = NULL; return REG_NO_ERROR; } //********************************************************************* // createLink // RegError REGISTRY_CALLTYPE createLink(RegKeyHandle, rtl_uString*, rtl_uString*) { return REG_INVALID_LINK; // links are no longer supported } //********************************************************************* // deleteLink // RegError REGISTRY_CALLTYPE deleteLink(RegKeyHandle, rtl_uString*) { return REG_INVALID_LINK; // links are no longer supported } //********************************************************************* // getKeyType // RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey, rtl_uString* keyName, RegKeyType* pKeyType) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; return pKey->getKeyType(keyName, pKeyType); } //********************************************************************* // getLinkTarget // RegError REGISTRY_CALLTYPE getLinkTarget( RegKeyHandle, rtl_uString*, rtl_uString**) { return REG_INVALID_LINK; // links are no longer supported } //********************************************************************* // getName // RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey, rtl_uString* keyName, sal_Bool, rtl_uString** pResolvedName) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; OUString resolvedName; RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName); if (_ret == REG_NO_ERROR) rtl_uString_assign(pResolvedName, resolvedName.pData); return _ret; } //********************************************************************* // getKeyNames // RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey, rtl_uString* keyName, rtl_uString*** pSubKeyNames, sal_uInt32* pnSubKeys) { ORegKey* pKey = static_cast< ORegKey* >(hKey); if (!pKey) return REG_INVALID_KEY; if (pKey->isDeleted()) return REG_INVALID_KEY; return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys); } //********************************************************************* // freeKeyNames // RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames, sal_uInt32 nKeys) { for (sal_uInt32 i=0; i < nKeys; i++) { rtl_uString_release(pKeyNames[i]); } rtl_freeMemory(pKeyNames); return REG_NO_ERROR; } //********************************************************************* // C API // //********************************************************************* // reg_createKey // RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey, rtl_uString* keyName, RegKeyHandle* phNewKey) { if (!hKey) return REG_INVALID_KEY; return createKey(hKey, keyName, phNewKey); } //********************************************************************* // reg_openKey // RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey, rtl_uString* keyName, RegKeyHandle* phOpenKey) { if (!hKey) return REG_INVALID_KEY; return openKey(hKey, keyName, phOpenKey); } //********************************************************************* // reg_openSubKeys // RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey, rtl_uString* keyName, RegKeyHandle** pphSubKeys, sal_uInt32* pnSubKeys) { if (!hKey) return REG_INVALID_KEY; return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys); } //********************************************************************* // reg_closeSubKeys // RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys, sal_uInt32 nSubKeys) { if (!pphSubKeys) return REG_INVALID_KEY; return closeSubKeys(pphSubKeys, nSubKeys); } //********************************************************************* // reg_deleteKey // RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey, rtl_uString* keyName) { if (!hKey) return REG_INVALID_KEY; return deleteKey(hKey, keyName); } //********************************************************************* // reg_closeKey // RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey) { if (!hKey) return REG_INVALID_KEY; return closeKey(hKey); } //********************************************************************* // reg_getKeyName // RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName) { if (hKey) { rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData ); return REG_NO_ERROR; } else { rtl_uString_new( pKeyName ); return REG_INVALID_KEY; } } //********************************************************************* // reg_setValue // RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey, rtl_uString* keyName, RegValueType valueType, RegValue pData, sal_uInt32 valueSize) { if (!hKey) return REG_INVALID_KEY; return setValue(hKey, keyName, valueType, pData, valueSize); } //********************************************************************* // reg_setLongListValue // RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Int32* pValueList, sal_uInt32 len) { if (!hKey) return REG_INVALID_KEY; return setLongListValue(hKey, keyName, pValueList, len); } //********************************************************************* // reg_setStringListValue // RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Char** pValueList, sal_uInt32 len) { if (!hKey) return REG_INVALID_KEY; return setStringListValue(hKey, keyName, pValueList, len); } //********************************************************************* // reg_setUnicodeListValue // RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Unicode** pValueList, sal_uInt32 len) { if (!hKey) return REG_INVALID_KEY; return setUnicodeListValue(hKey, keyName, pValueList, len); } //********************************************************************* // reg_getValueInfo // RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey, rtl_uString* keyName, RegValueType* pValueType, sal_uInt32* pValueSize) { if (!hKey) return REG_INVALID_KEY; return getValueInfo(hKey, keyName, pValueType, pValueSize); } //********************************************************************* // reg_getValueInfo // RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey, rtl_uString* keyName, RegValue pData) { if (!hKey) return REG_INVALID_KEY; return getValue(hKey, keyName, pData); } //********************************************************************* // reg_getLongListValue // RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Int32** pValueList, sal_uInt32* pLen) { if (!hKey) return REG_INVALID_KEY; return getLongListValue(hKey, keyName, pValueList, pLen); } //********************************************************************* // reg_getStringListValue // RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Char*** pValueList, sal_uInt32* pLen) { if (!hKey) return REG_INVALID_KEY; return getStringListValue(hKey, keyName, pValueList, pLen); } //********************************************************************* // reg_getUnicodeListValue // RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey, rtl_uString* keyName, sal_Unicode*** pValueList, sal_uInt32* pLen) { if (!hKey) return REG_INVALID_KEY; return getUnicodeListValue(hKey, keyName, pValueList, pLen); } //********************************************************************* // reg_freeValueList // RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType, RegValue pValueList, sal_uInt32 len) { if (pValueList) return freeValueList(valueType, pValueList, len); else return REG_INVALID_VALUE; } //********************************************************************* // reg_createLink // RegError REGISTRY_CALLTYPE reg_createLink(RegKeyHandle hKey, rtl_uString* linkName, rtl_uString* linkTarget) { if (!hKey) return REG_INVALID_KEY; return createLink(hKey, linkName, linkTarget); } //********************************************************************* // reg_deleteLink // RegError REGISTRY_CALLTYPE reg_deleteLink(RegKeyHandle hKey, rtl_uString* linkName) { if (!hKey) return REG_INVALID_KEY; return deleteLink(hKey, linkName); } //********************************************************************* // reg_getKeyType // RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey, rtl_uString* keyName, RegKeyType* pKeyType) { if (!hKey) return REG_INVALID_KEY; return getKeyType(hKey, keyName, pKeyType); } //********************************************************************* // reg_getLinkTarget // RegError REGISTRY_CALLTYPE reg_getLinkTarget(RegKeyHandle hKey, rtl_uString* linkName, rtl_uString** pLinkTarget) { if (!hKey) return REG_INVALID_KEY; return getLinkTarget(hKey, linkName, pLinkTarget); } //********************************************************************* // reg_getResolvedKeyName // RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey, rtl_uString* keyName, sal_Bool firstLinkOnly, rtl_uString** pResolvedName) { if (!hKey) return REG_INVALID_KEY; return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName); }