diff options
Diffstat (limited to '')
| -rw-r--r-- | registry/source/reflread.cxx | 1760 |
1 files changed, 1760 insertions, 0 deletions
diff --git a/registry/source/reflread.cxx b/registry/source/reflread.cxx new file mode 100644 index 000000000..57884e110 --- /dev/null +++ b/registry/source/reflread.cxx @@ -0,0 +1,1760 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <sal/config.h> + +#include <cstring> +#include <memory> +#include <new> +#include <vector> + +#include <sal/types.h> +#include <osl/endian.h> +#include <osl/diagnose.h> +#include "reflread.hxx" +#include <sal/log.hxx> + +#include <registry/typereg_reader.hxx> +#include <registry/version.h> + +#include "reflcnst.hxx" + +#include <cstddef> + +const char NULL_STRING[1] = { 0 }; +const sal_Unicode NULL_WSTRING[1] = { 0 }; + +const sal_uInt32 magic = 0x12345678; +const sal_uInt16 minorVersion = 0x0000; +const sal_uInt16 majorVersion = 0x0001; + +/************************************************************************** + + class BlopObject + + holds any data in a flat memory buffer + +**************************************************************************/ + +namespace { + +class BlopObject +{ +public: + struct BoundsError {}; + + const sal_uInt8* m_pBuffer; + sal_uInt32 m_bufferLen; + + BlopObject(const sal_uInt8* buffer, sal_uInt32 len); + // throws std::bad_alloc + + sal_uInt8 readBYTE(sal_uInt32 index) const + { + if (index >= m_bufferLen) { + throw BoundsError(); + } + return m_pBuffer[index]; + } + + sal_Int16 readINT16(sal_uInt32 index) const + { + if (m_bufferLen < 2 || index >= m_bufferLen - 1) { + throw BoundsError(); + } + return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0)); + } + + sal_uInt16 readUINT16(sal_uInt32 index) const + { + if (m_bufferLen < 2 || index >= m_bufferLen - 1) { + throw BoundsError(); + } + return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0)); + } + + sal_Int32 readINT32(sal_uInt32 index) const + { + if (m_bufferLen < 4 || index >= m_bufferLen - 3) { + throw BoundsError(); + } + return ( + (m_pBuffer[index] << 24) | + (m_pBuffer[index+1] << 16) | + (m_pBuffer[index+2] << 8) | + (m_pBuffer[index+3] << 0) + ); + } + + sal_uInt32 readUINT32(sal_uInt32 index) const + { + if (m_bufferLen < 4 || index >= m_bufferLen - 3) { + throw BoundsError(); + } + return ( + (m_pBuffer[index] << 24) | + (m_pBuffer[index+1] << 16) | + (m_pBuffer[index+2] << 8) | + (m_pBuffer[index+3] << 0) + ); + } + + sal_Int64 readINT64(sal_uInt32 index) const + { + if (m_bufferLen < 8 || index >= m_bufferLen - 7) { + throw BoundsError(); + } + return ( + (static_cast<sal_Int64>(m_pBuffer[index]) << 56) | + (static_cast<sal_Int64>(m_pBuffer[index+1]) << 48) | + (static_cast<sal_Int64>(m_pBuffer[index+2]) << 40) | + (static_cast<sal_Int64>(m_pBuffer[index+3]) << 32) | + (static_cast<sal_Int64>(m_pBuffer[index+4]) << 24) | + (static_cast<sal_Int64>(m_pBuffer[index+5]) << 16) | + (static_cast<sal_Int64>(m_pBuffer[index+6]) << 8) | + (static_cast<sal_Int64>(m_pBuffer[index+7]) << 0) + ); + } + + sal_uInt64 readUINT64(sal_uInt32 index) const + { + if (m_bufferLen < 8 || index >= m_bufferLen - 7) { + throw BoundsError(); + } + return ( + (static_cast<sal_uInt64>(m_pBuffer[index]) << 56) | + (static_cast<sal_uInt64>(m_pBuffer[index+1]) << 48) | + (static_cast<sal_uInt64>(m_pBuffer[index+2]) << 40) | + (static_cast<sal_uInt64>(m_pBuffer[index+3]) << 32) | + (static_cast<sal_uInt64>(m_pBuffer[index+4]) << 24) | + (static_cast<sal_uInt64>(m_pBuffer[index+5]) << 16) | + (static_cast<sal_uInt64>(m_pBuffer[index+6]) << 8) | + (static_cast<sal_uInt64>(m_pBuffer[index+7]) << 0) + ); + } +}; + +} + +BlopObject::BlopObject(const sal_uInt8* buffer, sal_uInt32 len) + : m_bufferLen(len) +{ + m_pBuffer = buffer; +} + +/************************************************************************** + + class StringCache + +**************************************************************************/ + +namespace { + +class StringCache +{ +public: + std::vector<std::unique_ptr<sal_Unicode[]>> m_stringTable; + sal_uInt16 m_stringsCopied; + + explicit StringCache(sal_uInt16 size); // throws std::bad_alloc + + const sal_Unicode* getString(sal_uInt16 index) const; + sal_uInt16 createString(const sal_uInt8* buffer); // throws std::bad_alloc +}; + +} + +StringCache::StringCache(sal_uInt16 size) + : m_stringTable(size) + , m_stringsCopied(0) +{ +} + +const sal_Unicode* StringCache::getString(sal_uInt16 index) const +{ + if ((index > 0) && (index <= m_stringsCopied)) + return m_stringTable[index - 1].get(); + else + return nullptr; +} + +sal_uInt16 StringCache::createString(const sal_uInt8* buffer) +{ + if (m_stringsCopied < m_stringTable.size()) + { + sal_uInt32 len = UINT16StringLen(buffer); + + m_stringTable[m_stringsCopied].reset( new sal_Unicode[len + 1] ); + + readString(buffer, m_stringTable[m_stringsCopied].get(), (len + 1) * sizeof(sal_Unicode)); + + return ++m_stringsCopied; + } + else + return 0; +} + +/************************************************************************** + + class ConstantPool + +**************************************************************************/ + +namespace { + +class ConstantPool : public BlopObject +{ +public: + + sal_uInt16 m_numOfEntries; + std::unique_ptr<sal_Int32[]> m_pIndex; // index values may be < 0 for cached string constants + + std::unique_ptr<StringCache> m_pStringCache; + + ConstantPool(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries) + : BlopObject(buffer, len) + , m_numOfEntries(numEntries) + { + } + + sal_uInt32 parseIndex(); // throws std::bad_alloc + + CPInfoTag readTag(sal_uInt16 index) const; + + const char* readUTF8NameConstant(sal_uInt16 index) const; + bool readBOOLConstant(sal_uInt16 index) const; + sal_Int8 readBYTEConstant(sal_uInt16 index) const; + sal_Int16 readINT16Constant(sal_uInt16 index) const; + sal_uInt16 readUINT16Constant(sal_uInt16 index) const; + sal_Int32 readINT32Constant(sal_uInt16 index) const; + sal_uInt32 readUINT32Constant(sal_uInt16 index) const; + sal_Int64 readINT64Constant(sal_uInt16 index) const; + sal_uInt64 readUINT64Constant(sal_uInt16 index) const; + float readFloatConstant(sal_uInt16 index) const; + double readDoubleConstant(sal_uInt16 index) const; + const sal_Unicode* readStringConstant(sal_uInt16 index) const; + // throws std::bad_alloc +}; + +} + +sal_uInt32 ConstantPool::parseIndex() +{ + m_pIndex.reset(); + m_pStringCache.reset(); + + sal_uInt32 offset = 0; + sal_uInt16 numOfStrings = 0; + + if (m_numOfEntries) + { + m_pIndex.reset( new sal_Int32[m_numOfEntries] ); + + for (int i = 0; i < m_numOfEntries; i++) + { + m_pIndex[i] = offset; + + offset += readUINT32(offset); + + if ( static_cast<CPInfoTag>(readUINT16(m_pIndex[i] + CP_OFFSET_ENTRY_TAG)) == + CP_TAG_CONST_STRING ) + { + numOfStrings++; + } + + } + } + + if (numOfStrings) + { + m_pStringCache.reset( new StringCache(numOfStrings) ); + } + + m_bufferLen = offset; + + return offset; +} + +CPInfoTag ConstantPool::readTag(sal_uInt16 index) const +{ + CPInfoTag tag = CP_TAG_INVALID; + + if (m_pIndex && (index > 0) && (index <= m_numOfEntries)) + { + tag = static_cast<CPInfoTag>(readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG)); + } + + return tag; +} + +const char* ConstantPool::readUTF8NameConstant(sal_uInt16 index) const +{ + const char* aName = NULL_STRING; + + if (m_pIndex && (index > 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_UTF8_NAME) + { + sal_uInt32 n = m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA; + if (n < m_bufferLen + && std::memchr(m_pBuffer + n, 0, m_bufferLen - n) != nullptr) + { + aName = reinterpret_cast<const char*>(m_pBuffer + n); + } + } + } + + return aName; +} + +bool ConstantPool::readBOOLConstant(sal_uInt16 index) const +{ + bool aBool = false; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_BOOL) + { + aBool = readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA) != 0; + } + } + + return aBool; +} + +sal_Int8 ConstantPool::readBYTEConstant(sal_uInt16 index) const +{ + sal_Int8 aByte = 0; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_BYTE) + { + aByte = static_cast< sal_Int8 >( + readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA)); + } + } + + return aByte; +} + +sal_Int16 ConstantPool::readINT16Constant(sal_uInt16 index) const +{ + sal_Int16 aINT16 = 0; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT16) + { + aINT16 = readINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); + } + } + + return aINT16; +} + +sal_uInt16 ConstantPool::readUINT16Constant(sal_uInt16 index) const +{ + sal_uInt16 asal_uInt16 = 0; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT16) + { + asal_uInt16 = readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); + } + } + + return asal_uInt16; +} + +sal_Int32 ConstantPool::readINT32Constant(sal_uInt16 index) const +{ + sal_Int32 aINT32 = 0; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT32) + { + aINT32 = readINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); + } + } + + return aINT32; +} + +sal_uInt32 ConstantPool::readUINT32Constant(sal_uInt16 index) const +{ + sal_uInt32 aUINT32 = 0; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT32) + { + aUINT32 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); + } + } + + return aUINT32; +} + +sal_Int64 ConstantPool::readINT64Constant(sal_uInt16 index) const +{ + sal_Int64 aINT64 = 0; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT64) + { + aINT64 = readINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); + } + } + + return aINT64; +} + +sal_uInt64 ConstantPool::readUINT64Constant(sal_uInt16 index) const +{ + sal_uInt64 aUINT64 = 0; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT64) + { + aUINT64 = readUINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); + } + } + + return aUINT64; +} + +float ConstantPool::readFloatConstant(sal_uInt16 index) const +{ + union + { + float v; + sal_uInt32 b; + } x = { 0.0f }; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_FLOAT) + { +#ifdef REGTYPE_IEEE_NATIVE + x.b = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); +#else +# error no IEEE +#endif + } + } + + return x.v; +} + +double ConstantPool::readDoubleConstant(sal_uInt16 index) const +{ + union + { + double v; + struct + { + sal_uInt32 b1; + sal_uInt32 b2; + } b; + } x = { 0.0 }; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries)) + { + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_DOUBLE) + { + +#ifdef REGTYPE_IEEE_NATIVE +# ifdef OSL_BIGENDIAN + x.b.b1 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); + x.b.b2 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA + sizeof(sal_uInt32)); +# else + x.b.b1 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA + sizeof(sal_uInt32)); + x.b.b2 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA); +# endif +#else +# error no IEEE +#endif + } + } + + return x.v; +} + +const sal_Unicode* ConstantPool::readStringConstant(sal_uInt16 index) const +{ + const sal_Unicode* aString = NULL_WSTRING; + + if (m_pIndex && (index> 0) && (index <= m_numOfEntries) && m_pStringCache) + { + if (m_pIndex[index - 1] >= 0) + { + // create cached string now + + if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_STRING) + { + sal_uInt32 n = m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA; + if (n >= m_bufferLen + || (std::memchr(m_pBuffer + n, 0, m_bufferLen - n) + == nullptr)) + { + throw BoundsError(); + } + m_pIndex[index - 1] = -1 * m_pStringCache->createString(m_pBuffer + n); + } + } + + aString = m_pStringCache->getString(static_cast<sal_uInt16>(m_pIndex[index - 1] * -1)); + } + + return aString; +} + +/************************************************************************** + + class FieldList + +**************************************************************************/ + +namespace { + +class FieldList : public BlopObject +{ +public: + + sal_uInt16 m_numOfEntries; + size_t m_FIELD_ENTRY_SIZE; + ConstantPool* m_pCP; + + FieldList(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries, ConstantPool* pCP) + : BlopObject(buffer, len) + , m_numOfEntries(numEntries) + , m_pCP(pCP) + { + if ( m_numOfEntries > 0 ) + { + sal_uInt16 numOfFieldEntries = readUINT16(0); + m_FIELD_ENTRY_SIZE = numOfFieldEntries * sizeof(sal_uInt16); + } else + { + m_FIELD_ENTRY_SIZE = 0; + } + } + + sal_uInt32 parseIndex() const { return ((m_numOfEntries ? sizeof(sal_uInt16) : 0) + (m_numOfEntries * m_FIELD_ENTRY_SIZE));} + + const char* getFieldName(sal_uInt16 index) const; + const char* getFieldType(sal_uInt16 index) const; + RTFieldAccess getFieldAccess(sal_uInt16 index) const; + RTValueType getFieldConstValue(sal_uInt16 index, RTConstValueUnion* value) const; + // throws std::bad_alloc + const char* getFieldDoku(sal_uInt16 index) const; + const char* getFieldFileName(sal_uInt16 index) const; +}; + +} + +const char* FieldList::getFieldName(sal_uInt16 index) const +{ + const char* aName = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_NAME)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aName; +} + +const char* FieldList::getFieldType(sal_uInt16 index) const +{ + const char* aName = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_TYPE)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aName; +} + +RTFieldAccess FieldList::getFieldAccess(sal_uInt16 index) const +{ + RTFieldAccess aAccess = RTFieldAccess::INVALID; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aAccess = static_cast<RTFieldAccess>(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_ACCESS)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aAccess; +} + +RTValueType FieldList::getFieldConstValue(sal_uInt16 index, RTConstValueUnion* value) const +{ + RTValueType ret = RT_TYPE_NONE; + try { + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + sal_uInt16 cpIndex = readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_VALUE); + switch (m_pCP->readTag(cpIndex)) + { + case CP_TAG_CONST_BOOL: + value->aBool = m_pCP->readBOOLConstant(cpIndex); + ret = RT_TYPE_BOOL; + break; + case CP_TAG_CONST_BYTE: + value->aByte = m_pCP->readBYTEConstant(cpIndex); + ret = RT_TYPE_BYTE; + break; + case CP_TAG_CONST_INT16: + value->aShort = m_pCP->readINT16Constant(cpIndex); + ret = RT_TYPE_INT16; + break; + case CP_TAG_CONST_UINT16: + value->aUShort = m_pCP->readUINT16Constant(cpIndex); + ret = RT_TYPE_UINT16; + break; + case CP_TAG_CONST_INT32: + value->aLong = m_pCP->readINT32Constant(cpIndex); + ret = RT_TYPE_INT32; + break; + case CP_TAG_CONST_UINT32: + value->aULong = m_pCP->readUINT32Constant(cpIndex); + ret = RT_TYPE_UINT32; + break; + case CP_TAG_CONST_INT64: + value->aHyper = m_pCP->readINT64Constant(cpIndex); + ret = RT_TYPE_INT64; + break; + case CP_TAG_CONST_UINT64: + value->aUHyper = m_pCP->readUINT64Constant(cpIndex); + ret = RT_TYPE_UINT64; + break; + case CP_TAG_CONST_FLOAT: + value->aFloat = m_pCP->readFloatConstant(cpIndex); + ret = RT_TYPE_FLOAT; + break; + case CP_TAG_CONST_DOUBLE: + value->aDouble = m_pCP->readDoubleConstant(cpIndex); + ret = RT_TYPE_DOUBLE; + break; + case CP_TAG_CONST_STRING: + value->aString = m_pCP->readStringConstant(cpIndex); + ret = RT_TYPE_STRING; + break; + default: + break; + } + } + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + return ret; +} + +const char* FieldList::getFieldDoku(sal_uInt16 index) const +{ + const char* aDoku = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aDoku = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_DOKU)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aDoku; +} + +const char* FieldList::getFieldFileName(sal_uInt16 index) const +{ + const char* aFileName = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aFileName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_FILENAME)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aFileName; +} + +/************************************************************************** + + class ReferenceList + +**************************************************************************/ + +namespace { + +class ReferenceList : public BlopObject +{ +public: + + sal_uInt16 m_numOfEntries; + size_t m_REFERENCE_ENTRY_SIZE; + ConstantPool* m_pCP; + + ReferenceList(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries, ConstantPool* pCP) + : BlopObject(buffer, len) + , m_numOfEntries(numEntries) + , m_pCP(pCP) + { + if ( m_numOfEntries > 0 ) + { + sal_uInt16 numOfReferenceEntries = readUINT16(0); + m_REFERENCE_ENTRY_SIZE = numOfReferenceEntries * sizeof(sal_uInt16); + } else + { + m_REFERENCE_ENTRY_SIZE = 0; + } + } + + const char* getReferenceName(sal_uInt16 index) const; + RTReferenceType getReferenceType(sal_uInt16 index) const; + const char* getReferenceDoku(sal_uInt16 index) const; + RTFieldAccess getReferenceAccess(sal_uInt16 index) const; +}; + +} + +const char* ReferenceList::getReferenceName(sal_uInt16 index) const +{ + const char* aName = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_NAME)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aName; +} + +RTReferenceType ReferenceList::getReferenceType(sal_uInt16 index) const +{ + RTReferenceType refType = RTReferenceType::INVALID; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + refType = static_cast<RTReferenceType>(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_TYPE)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return refType; +} + +const char* ReferenceList::getReferenceDoku(sal_uInt16 index) const +{ + const char* aDoku = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aDoku = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_DOKU)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aDoku; +} + +RTFieldAccess ReferenceList::getReferenceAccess(sal_uInt16 index) const +{ + RTFieldAccess aAccess = RTFieldAccess::INVALID; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aAccess = static_cast<RTFieldAccess>(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_ACCESS)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aAccess; +} + +/************************************************************************** + + class MethodList + +**************************************************************************/ + +namespace { + +class MethodList : public BlopObject +{ +public: + + sal_uInt16 m_numOfEntries; + size_t m_PARAM_ENTRY_SIZE; + std::unique_ptr<sal_uInt32[]> m_pIndex; + ConstantPool* m_pCP; + + MethodList(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries, ConstantPool* pCP) + : BlopObject(buffer, len) + , m_numOfEntries(numEntries) + , m_pCP(pCP) + { + if ( m_numOfEntries > 0 ) + { + readUINT16(0) /* numOfMethodEntries */; + sal_uInt16 numOfParamEntries = readUINT16(sizeof(sal_uInt16)); + m_PARAM_ENTRY_SIZE = numOfParamEntries * sizeof(sal_uInt16); + } else + { + m_PARAM_ENTRY_SIZE = 0; + } + } + + sal_uInt32 parseIndex(); // throws std::bad_alloc + + const char* getMethodName(sal_uInt16 index) const; + sal_uInt16 getMethodParamCount(sal_uInt16 index) const; + const char* getMethodParamType(sal_uInt16 index, sal_uInt16 paramIndex) const; + const char* getMethodParamName(sal_uInt16 index, sal_uInt16 paramIndex) const; + RTParamMode getMethodParamMode(sal_uInt16 index, sal_uInt16 paramIndex) const; + sal_uInt16 getMethodExcCount(sal_uInt16 index) const; + const char* getMethodExcType(sal_uInt16 index, sal_uInt16 excIndex) const; + const char* getMethodReturnType(sal_uInt16 index) const; + RTMethodMode getMethodMode(sal_uInt16 index) const; + const char* getMethodDoku(sal_uInt16 index) const; + +private: + sal_uInt16 calcMethodParamIndex( const sal_uInt16 index ) const; +}; + +} + +sal_uInt16 MethodList::calcMethodParamIndex( const sal_uInt16 index ) const +{ + return (METHOD_OFFSET_PARAM_COUNT + sizeof(sal_uInt16) + (index * m_PARAM_ENTRY_SIZE)); +} + +sal_uInt32 MethodList::parseIndex() +{ + m_pIndex.reset(); + + sal_uInt32 offset = 0; + + if (m_numOfEntries) + { + offset = 2 * sizeof(sal_uInt16); + m_pIndex.reset( new sal_uInt32[m_numOfEntries] ); + + for (int i = 0; i < m_numOfEntries; i++) + { + m_pIndex[i] = offset; + + offset += readUINT16(offset); + } + } + + return offset; +} + +const char* MethodList::getMethodName(sal_uInt16 index) const +{ + const char* aName = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_NAME)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aName; +} + +sal_uInt16 MethodList::getMethodParamCount(sal_uInt16 index) const +{ + sal_uInt16 aCount = 0; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aCount = readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aCount; +} + +const char* MethodList::getMethodParamType(sal_uInt16 index, sal_uInt16 paramIndex) const +{ + const char* aName = nullptr; + try { + if ((m_numOfEntries > 0) && + (index <= m_numOfEntries) && + (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT))) + { + aName = m_pCP->readUTF8NameConstant( + readUINT16( + m_pIndex[index] + + calcMethodParamIndex(paramIndex) + + PARAM_OFFSET_TYPE)); + } + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + return aName; +} + +const char* MethodList::getMethodParamName(sal_uInt16 index, sal_uInt16 paramIndex) const +{ + const char* aName = nullptr; + try { + if ((m_numOfEntries > 0) && + (index <= m_numOfEntries) && + (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT))) + { + aName = m_pCP->readUTF8NameConstant( + readUINT16( + m_pIndex[index] + + calcMethodParamIndex(paramIndex) + + PARAM_OFFSET_NAME)); + } + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + return aName; +} + +RTParamMode MethodList::getMethodParamMode(sal_uInt16 index, sal_uInt16 paramIndex) const +{ + RTParamMode aMode = RT_PARAM_INVALID; + try { + if ((m_numOfEntries > 0) && + (index <= m_numOfEntries) && + (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT))) + { + aMode = static_cast<RTParamMode>(readUINT16( + m_pIndex[index] + + calcMethodParamIndex(paramIndex) + + PARAM_OFFSET_MODE)); + } + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + return aMode; +} + +#if defined(__COVERITY__) +extern "C" void __coverity_tainted_data_sanitize__(void *); +#endif + +sal_uInt16 MethodList::getMethodExcCount(sal_uInt16 index) const +{ + sal_uInt16 aCount = 0; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aCount = readUINT16(m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT))); +#if defined(__COVERITY__) + __coverity_tainted_data_sanitize__(&aCount); +#endif + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aCount; +} + +const char* MethodList::getMethodExcType(sal_uInt16 index, sal_uInt16 excIndex) const +{ + const char* aName = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + sal_uInt32 excOffset = m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)); + if (excIndex <= readUINT16(excOffset)) + { + aName = m_pCP->readUTF8NameConstant( + readUINT16( + excOffset + + sizeof(sal_uInt16) + + (excIndex * sizeof(sal_uInt16)))); + } + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aName; +} + +const char* MethodList::getMethodReturnType(sal_uInt16 index) const +{ + const char* aName = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_RETURN)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aName; +} + +RTMethodMode MethodList::getMethodMode(sal_uInt16 index) const +{ + RTMethodMode aMode = RTMethodMode::INVALID; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aMode = static_cast<RTMethodMode>(readUINT16(m_pIndex[index] + METHOD_OFFSET_MODE)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aMode; +} + +const char* MethodList::getMethodDoku(sal_uInt16 index) const +{ + const char* aDoku = nullptr; + + if ((m_numOfEntries > 0) && (index <= m_numOfEntries)) + { + try { + aDoku = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_DOKU)); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + + return aDoku; +} + +/************************************************************************** + + class TypeRegistryEntry + +**************************************************************************/ + +namespace { + +class TypeRegistryEntry: public BlopObject { +public: + std::unique_ptr<ConstantPool> m_pCP; + std::unique_ptr<FieldList> m_pFields; + std::unique_ptr<MethodList> m_pMethods; + std::unique_ptr<ReferenceList> m_pReferences; + sal_uInt32 m_refCount; + sal_uInt16 m_nSuperTypes; + sal_uInt32 m_offset_SUPERTYPES; + + TypeRegistryEntry( + const sal_uInt8* buffer, sal_uInt32 len); + // throws std::bad_alloc + + typereg_Version getVersion() const; +}; + +} + +TypeRegistryEntry::TypeRegistryEntry( + const sal_uInt8* buffer, sal_uInt32 len): + BlopObject(buffer, len), m_refCount(1), m_nSuperTypes(0), + m_offset_SUPERTYPES(0) +{ + std::size_t const entrySize = sizeof(sal_uInt16); + sal_uInt16 nHeaderEntries = readUINT16(OFFSET_N_ENTRIES); + sal_uInt32 offset_N_SUPERTYPES = OFFSET_N_ENTRIES + entrySize + (nHeaderEntries * entrySize); // cannot overflow + m_offset_SUPERTYPES = offset_N_SUPERTYPES + entrySize; // cannot overflow + m_nSuperTypes = readUINT16(offset_N_SUPERTYPES); + + sal_uInt32 offset_CP_SIZE = m_offset_SUPERTYPES + (m_nSuperTypes * entrySize); // cannot overflow + sal_uInt32 offset_CP = offset_CP_SIZE + entrySize; // cannot overflow + + if (offset_CP > m_bufferLen) { + throw BoundsError(); + } + m_pCP.reset( + new ConstantPool( + m_pBuffer + offset_CP, m_bufferLen - offset_CP, + readUINT16(offset_CP_SIZE))); + + sal_uInt32 offset = offset_CP + m_pCP->parseIndex(); //TODO: overflow + + assert(m_bufferLen >= entrySize); + if (offset > m_bufferLen - entrySize) { + throw BoundsError(); + } + m_pFields.reset( + new FieldList( + m_pBuffer + offset + entrySize, m_bufferLen - (offset + entrySize), + readUINT16(offset), m_pCP.get())); + + offset += sizeof(sal_uInt16) + m_pFields->parseIndex(); //TODO: overflow + + assert(m_bufferLen >= entrySize); + if (offset > m_bufferLen - entrySize) { + throw BoundsError(); + } + m_pMethods.reset( + new MethodList( + m_pBuffer + offset + entrySize, m_bufferLen - (offset + entrySize), + readUINT16(offset), m_pCP.get())); + + offset += sizeof(sal_uInt16) + m_pMethods->parseIndex(); //TODO: overflow + + assert(m_bufferLen >= entrySize); + if (offset > m_bufferLen - entrySize) { + throw BoundsError(); + } + m_pReferences.reset( + new ReferenceList( + m_pBuffer + offset + entrySize, m_bufferLen - (offset + entrySize), + readUINT16(offset), m_pCP.get())); +} + +typereg_Version TypeRegistryEntry::getVersion() const { + // Assumes two's complement arithmetic with modulo-semantics: + return static_cast< typereg_Version >(readUINT32(OFFSET_MAGIC) - magic); +} + +/************************************************************************** + + C-API + +**************************************************************************/ + +bool TYPEREG_CALLTYPE typereg_reader_create( + void const * buffer, sal_uInt32 length, + void ** result) +{ + if (length < OFFSET_CP || length > SAL_MAX_UINT32) { + *result = nullptr; + return true; + } + std::unique_ptr< TypeRegistryEntry > entry; + try { + try { + entry.reset( + new TypeRegistryEntry( + static_cast< sal_uInt8 const * >(buffer), length)); + } catch (std::bad_alloc &) { + return false; + } + if (entry->readUINT32(OFFSET_SIZE) != length) { + *result = nullptr; + return true; + } + typereg_Version version = entry->getVersion(); + if (version < TYPEREG_VERSION_0 || version > TYPEREG_VERSION_1) { + *result = nullptr; + return true; + } + *result = entry.release(); + return true; + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + return false; + } +} + +static TypeReaderImpl TYPEREG_CALLTYPE createEntry(const sal_uInt8* buffer, sal_uInt32 len) +{ + void * handle; + typereg_reader_create(buffer, len, &handle); + return handle; +} + +void TYPEREG_CALLTYPE typereg_reader_acquire(void * hEntry) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry != nullptr) + pEntry->m_refCount++; +} + +void TYPEREG_CALLTYPE typereg_reader_release(void * hEntry) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry != nullptr) + { + if (--pEntry->m_refCount == 0) + delete pEntry; + } +} + +typereg_Version TYPEREG_CALLTYPE typereg_reader_getVersion(void const * handle) { + if (handle != nullptr) { + try { + return static_cast< TypeRegistryEntry const * >(handle)->getVersion(); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + return TYPEREG_VERSION_0; +} + +RTTypeClass TYPEREG_CALLTYPE typereg_reader_getTypeClass(void * hEntry) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + if (pEntry != nullptr) { + try { + return static_cast<RTTypeClass>(pEntry->readUINT16(OFFSET_TYPE_CLASS) & ~RT_TYPE_PUBLISHED); + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + return RT_TYPE_INVALID; +} + +bool TYPEREG_CALLTYPE typereg_reader_isPublished(void * hEntry) +{ + TypeRegistryEntry * entry = static_cast< TypeRegistryEntry * >(hEntry); + if (entry != nullptr) { + try { + return (entry->readUINT16(OFFSET_TYPE_CLASS) & RT_TYPE_PUBLISHED) != 0; + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + return false; +} + +void TYPEREG_CALLTYPE typereg_reader_getTypeName(void * hEntry, rtl_uString** pTypeName) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + if (pEntry != nullptr) { + try { + const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_THIS_TYPE)); + rtl_string2UString( + pTypeName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); + return; + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + rtl_uString_new(pTypeName); +} + + +static void TYPEREG_CALLTYPE getSuperTypeName(TypeReaderImpl hEntry, rtl_uString** pSuperTypeName) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + if (pEntry != nullptr && pEntry->m_nSuperTypes != 0) { + try { + const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(pEntry->m_offset_SUPERTYPES )); //+ (index * sizeof(sal_uInt16)))); + rtl_string2UString( + pSuperTypeName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); + return; + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + rtl_uString_new(pSuperTypeName); +} + +void TYPEREG_CALLTYPE typereg_reader_getDocumentation(void * hEntry, rtl_uString** pDoku) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + if (pEntry != nullptr) { + try { + const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_DOKU)); + rtl_string2UString( + pDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); + return; + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + rtl_uString_new(pDoku); +} + +void TYPEREG_CALLTYPE typereg_reader_getFileName(void * hEntry, rtl_uString** pFileName) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + if (pEntry != nullptr) { + try { + const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_FILENAME)); + rtl_string2UString( + pFileName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); + return; + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + rtl_uString_new(pFileName); +} + + +sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getFieldCount(void * hEntry) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return 0; + + return pEntry->m_pFields->m_numOfEntries; +} + +static sal_uInt32 TYPEREG_CALLTYPE getFieldCount(TypeReaderImpl hEntry) +{ + return typereg_reader_getFieldCount(hEntry); +} + +void TYPEREG_CALLTYPE typereg_reader_getFieldName(void * hEntry, rtl_uString** pFieldName, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pFieldName); + return; + } + const char* pTmp = pEntry->m_pFields->getFieldName(index); + rtl_string2UString( + pFieldName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +void TYPEREG_CALLTYPE typereg_reader_getFieldTypeName(void * hEntry, rtl_uString** pFieldType, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pFieldType); + return; + } + + const char* pTmp = pEntry->m_pFields->getFieldType(index); + rtl_string2UString( + pFieldType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getFieldFlags(void * hEntry, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return RTFieldAccess::INVALID; + + return pEntry->m_pFields->getFieldAccess(index); +} + +bool TYPEREG_CALLTYPE typereg_reader_getFieldValue( + void * hEntry, sal_uInt16 index, RTValueType * type, + RTConstValueUnion * value) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) { + *type = RT_TYPE_NONE; + return true; + } + + try { + *type = pEntry->m_pFields->getFieldConstValue(index, value); + } catch (std::bad_alloc &) { + return false; + } + return true; +} + +static RTValueType TYPEREG_CALLTYPE getFieldConstValue(TypeReaderImpl hEntry, sal_uInt16 index, RTConstValueUnion* value) +{ + RTValueType t = RT_TYPE_NONE; + typereg_reader_getFieldValue(hEntry, index, &t, value); + return t; +} + +void TYPEREG_CALLTYPE typereg_reader_getFieldDocumentation(void * hEntry, rtl_uString** pDoku, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pDoku); + return; + } + + const char* pTmp = pEntry->m_pFields->getFieldDoku(index); + rtl_string2UString( + pDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +void TYPEREG_CALLTYPE typereg_reader_getFieldFileName(void * hEntry, rtl_uString** pFieldFileName, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pFieldFileName); + return; + } + + const char* pTmp = pEntry->m_pFields->getFieldFileName(index); + rtl_string2UString( + pFieldFileName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + + +sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodCount(void * hEntry) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return 0; + + return pEntry->m_pMethods->m_numOfEntries; +} + +void TYPEREG_CALLTYPE typereg_reader_getMethodName(void * hEntry, rtl_uString** pMethodName, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pMethodName); + return; + } + + const char* pTmp = pEntry->m_pMethods->getMethodName(index); + rtl_string2UString( + pMethodName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodParameterCount( + void * hEntry, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return 0; + + return pEntry->m_pMethods->getMethodParamCount(index); +} + +void TYPEREG_CALLTYPE typereg_reader_getMethodParameterTypeName(void * hEntry, rtl_uString** pMethodParamType, sal_uInt16 index, sal_uInt16 paramIndex) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pMethodParamType); + return; + } + + const char* pTmp = pEntry->m_pMethods->getMethodParamType(index, paramIndex); + rtl_string2UString( + pMethodParamType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +void TYPEREG_CALLTYPE typereg_reader_getMethodParameterName(void * hEntry, rtl_uString** pMethodParamName, sal_uInt16 index, sal_uInt16 paramIndex) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pMethodParamName); + return; + } + + const char* pTmp = pEntry->m_pMethods->getMethodParamName(index, paramIndex); + rtl_string2UString( + pMethodParamName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +RTParamMode TYPEREG_CALLTYPE typereg_reader_getMethodParameterFlags(void * hEntry, sal_uInt16 index, sal_uInt16 paramIndex) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return RT_PARAM_INVALID; + + return pEntry->m_pMethods->getMethodParamMode(index, paramIndex); +} + +sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodExceptionCount( + void * hEntry, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return 0; + + return pEntry->m_pMethods->getMethodExcCount(index); +} + +void TYPEREG_CALLTYPE typereg_reader_getMethodExceptionTypeName(void * hEntry, rtl_uString** pMethodExcpType, sal_uInt16 index, sal_uInt16 excIndex) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pMethodExcpType); + return; + } + + const char* pTmp = pEntry->m_pMethods->getMethodExcType(index, excIndex); + rtl_string2UString( + pMethodExcpType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +void TYPEREG_CALLTYPE typereg_reader_getMethodReturnTypeName(void * hEntry, rtl_uString** pMethodReturnType, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pMethodReturnType); + return; + } + + const char* pTmp = pEntry->m_pMethods->getMethodReturnType(index); + rtl_string2UString( + pMethodReturnType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +RTMethodMode TYPEREG_CALLTYPE typereg_reader_getMethodFlags(void * hEntry, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return RTMethodMode::INVALID; + + return pEntry->m_pMethods->getMethodMode(index); +} + +void TYPEREG_CALLTYPE typereg_reader_getMethodDocumentation(void * hEntry, rtl_uString** pMethodDoku, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pMethodDoku); + return; + } + + const char* pTmp = pEntry->m_pMethods->getMethodDoku(index); + rtl_string2UString( + pMethodDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getReferenceCount(void * hEntry) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return 0; + + return pEntry->m_pReferences->m_numOfEntries; +} + +void TYPEREG_CALLTYPE typereg_reader_getReferenceTypeName(void * hEntry, rtl_uString** pReferenceName, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pReferenceName); + return; + } + + const char* pTmp = pEntry->m_pReferences->getReferenceName(index); + rtl_string2UString( + pReferenceName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +RTReferenceType TYPEREG_CALLTYPE typereg_reader_getReferenceSort(void * hEntry, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return RTReferenceType::INVALID; + + return pEntry->m_pReferences->getReferenceType(index); +} + +void TYPEREG_CALLTYPE typereg_reader_getReferenceDocumentation(void * hEntry, rtl_uString** pReferenceDoku, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) + { + rtl_uString_new(pReferenceDoku); + return; + } + + const char* pTmp = pEntry->m_pReferences->getReferenceDoku(index); + rtl_string2UString( + pReferenceDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); +} + +RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getReferenceFlags(void * hEntry, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return RTFieldAccess::INVALID; + + return pEntry->m_pReferences->getReferenceAccess(index); +} + +sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getSuperTypeCount(void * hEntry) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + + if (pEntry == nullptr) return 0; + + return pEntry->m_nSuperTypes; +} + +void TYPEREG_CALLTYPE typereg_reader_getSuperTypeName( + void * hEntry, rtl_uString ** pSuperTypeName, sal_uInt16 index) +{ + TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry); + if (pEntry != nullptr) { + try { + OSL_ASSERT(index < pEntry->m_nSuperTypes); + const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(pEntry->m_offset_SUPERTYPES + (index * sizeof(sal_uInt16)))); + rtl_string2UString( + pSuperTypeName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp), + RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); + return; + } catch (BlopObject::BoundsError &) { + SAL_WARN("registry", "bad data"); + } + } + rtl_uString_new(pSuperTypeName); +} + +RegistryTypeReader::RegistryTypeReader(const sal_uInt8* buffer, + sal_uInt32 bufferLen) + : m_hImpl(nullptr) +{ + m_hImpl = createEntry(buffer, bufferLen); +} + +RegistryTypeReader::~RegistryTypeReader() +{ typereg_reader_release(m_hImpl); } + +RTTypeClass RegistryTypeReader::getTypeClass() const +{ return typereg_reader_getTypeClass(m_hImpl); } + +OUString RegistryTypeReader::getTypeName() const +{ + OUString sRet; + typereg_reader_getTypeName(m_hImpl, &sRet.pData); + return sRet; +} + +OUString RegistryTypeReader::getSuperTypeName() const +{ + OUString sRet; + ::getSuperTypeName(m_hImpl, &sRet.pData); + return sRet; +} + +sal_uInt32 RegistryTypeReader::getFieldCount() const +{ return ::getFieldCount(m_hImpl); } + +OUString RegistryTypeReader::getFieldName( sal_uInt16 index ) const +{ + OUString sRet; + typereg_reader_getFieldName(m_hImpl, &sRet.pData, index); + return sRet; +} + +OUString RegistryTypeReader::getFieldType( sal_uInt16 index ) const +{ + OUString sRet; + typereg_reader_getFieldTypeName(m_hImpl, &sRet.pData, index); + return sRet; +} + +RTFieldAccess RegistryTypeReader::getFieldAccess( sal_uInt16 index ) const +{ return typereg_reader_getFieldFlags(m_hImpl, index); } + +RTConstValue RegistryTypeReader::getFieldConstValue( sal_uInt16 index ) const +{ + RTConstValue ret; + ret.m_type = ::getFieldConstValue(m_hImpl, index, &ret.m_value); + return ret; +} + +OUString RegistryTypeReader::getFieldDoku( sal_uInt16 index ) const +{ + OUString sRet; + typereg_reader_getFieldDocumentation(m_hImpl, &sRet.pData, index); + return sRet; +} + +OUString RegistryTypeReader::getFieldFileName( sal_uInt16 index ) const +{ + OUString sRet; + typereg_reader_getFieldFileName(m_hImpl, &sRet.pData, index); + return sRet; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |