algparam.h

Go to the documentation of this file.

// algparam.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_ALGPARAM_H
#define CRYPTOPP_ALGPARAM_H
 
#include "config.h"
#include "cryptlib.h"
 
#include "smartptr.h"
#include "secblock.h"
#include "integer.h"
#include "misc.h"
 
#include <string>
#include <typeinfo>
#include <exception>
 
NAMESPACE_BEGIN(CryptoPP)
 
 
class ConstByteArrayParameter
{
public:
        ConstByteArrayParameter(const char *data = NULLPTR, bool deepCopy = false)
                : m_deepCopy(false), m_data(NULLPTR), m_size(0)
        {
                Assign(reinterpret_cast<const byte *>(data), data ? strlen(data) : 0, deepCopy);
        }
 
        ConstByteArrayParameter(const byte *data, size_t size, bool deepCopy = false)
                : m_deepCopy(false), m_data(NULLPTR), m_size(0)
        {
                Assign(data, size, deepCopy);
        }
 
        template <class T> ConstByteArrayParameter(const T &string, bool deepCopy = false)
                : m_deepCopy(false), m_data(NULLPTR), m_size(0)
        {
                CRYPTOPP_COMPILE_ASSERT(sizeof(typename T::value_type) == 1);
                Assign(reinterpret_cast<const byte *>(&string[0]), string.size(), deepCopy);
        }
 
        void Assign(const byte *data, size_t size, bool deepCopy)
        {
                // This fires, which means: no data with a size, or data with no size.
                // CRYPTOPP_ASSERT((data && size) || !(data || size));
                if (deepCopy)
                        m_block.Assign(data, size);
                else
                {
                        m_data = data;
                        m_size = size;
                }
                m_deepCopy = deepCopy;
        }
 
        const byte *begin() const {return m_deepCopy ? m_block.begin() : m_data;}
        const byte *end() const {return m_deepCopy ? m_block.end() : m_data + m_size;}
        size_t size() const {return m_deepCopy ? m_block.size() : m_size;}
 
private:
        bool m_deepCopy;
        const byte *m_data;
        size_t m_size;
        SecByteBlock m_block;
};
 
class ByteArrayParameter
{
public:
        ByteArrayParameter(byte *data = NULLPTR, unsigned int size = 0)
                : m_data(data), m_size(size) {}
 
        ByteArrayParameter(SecByteBlock &block)
                : m_data(block.begin()), m_size(block.size()) {}
 
        byte *begin() const {return m_data;}
        byte *end() const {return m_data + m_size;}
        size_t size() const {return m_size;}
 
private:
        byte *m_data;
        size_t m_size;
};
 
class CRYPTOPP_DLL CombinedNameValuePairs : public NameValuePairs
{
public:
        CombinedNameValuePairs(const NameValuePairs &pairs1, const NameValuePairs &pairs2)
                : m_pairs1(pairs1), m_pairs2(pairs2) {}
 
        bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;
 
private:
        const NameValuePairs &m_pairs1, &m_pairs2;
};
 
#ifndef CRYPTOPP_DOXYGEN_PROCESSING
template <class T, class BASE>
class GetValueHelperClass
{
public:
        GetValueHelperClass(const T *pObject, const char *name, const std::type_info &valueType, void *pValue, const NameValuePairs *searchFirst)
                : m_pObject(pObject), m_name(name), m_valueType(&valueType), m_pValue(pValue), m_found(false), m_getValueNames(false)
        {
                if (strcmp(m_name, "ValueNames") == 0)
                {
                        m_found = m_getValueNames = true;
                        NameValuePairs::ThrowIfTypeMismatch(m_name, typeid(std::string), *m_valueType);
                        if (searchFirst)
                                searchFirst->GetVoidValue(m_name, valueType, pValue);
                        if (typeid(T) != typeid(BASE))
                                pObject->BASE::GetVoidValue(m_name, valueType, pValue);
                        ((*reinterpret_cast<std::string *>(m_pValue) += "ThisPointer:") += typeid(T).name()) += ';';
                }
 
                if (!m_found && strncmp(m_name, "ThisPointer:", 12) == 0 && strcmp(m_name+12, typeid(T).name()) == 0)
                {
                        NameValuePairs::ThrowIfTypeMismatch(m_name, typeid(T *), *m_valueType);
                        *reinterpret_cast<const T **>(pValue) = pObject;
                        m_found = true;
                        return;
                }
 
                if (!m_found && searchFirst)
                        m_found = searchFirst->GetVoidValue(m_name, valueType, pValue);
 
                if (!m_found && typeid(T) != typeid(BASE))
                        m_found = pObject->BASE::GetVoidValue(m_name, valueType, pValue);
        }
 
        operator bool() const {return m_found;}
 
        template <class R>
        GetValueHelperClass<T,BASE> & operator()(const char *name, const R & (T::*pm)() const)
        {
                if (m_getValueNames)
                        (*reinterpret_cast<std::string *>(m_pValue) += name) += ";";
                if (!m_found && strcmp(name, m_name) == 0)
                {
                        NameValuePairs::ThrowIfTypeMismatch(name, typeid(R), *m_valueType);
                        *reinterpret_cast<R *>(m_pValue) = (m_pObject->*pm)();
                        m_found = true;
                }
                return *this;
        }
 
        GetValueHelperClass<T,BASE> &Assignable()
        {
#ifndef __INTEL_COMPILER        // ICL 9.1 workaround: Intel compiler copies the vTable pointer for some reason
                if (m_getValueNames)
                        ((*reinterpret_cast<std::string *>(m_pValue) += "ThisObject:") += typeid(T).name()) += ';';
                if (!m_found && strncmp(m_name, "ThisObject:", 11) == 0 && strcmp(m_name+11, typeid(T).name()) == 0)
                {
                        NameValuePairs::ThrowIfTypeMismatch(m_name, typeid(T), *m_valueType);
                        *reinterpret_cast<T *>(m_pValue) = *m_pObject;
                        m_found = true;
                }
#endif
                return *this;
        }
 
private:
        const T *m_pObject;
        const char *m_name;
        const std::type_info *m_valueType;
        void *m_pValue;
        bool m_found, m_getValueNames;
};
 
template <class BASE, class T>
GetValueHelperClass<T, BASE> GetValueHelper(const T *pObject, const char *name, const std::type_info &valueType, void *pValue, const NameValuePairs *searchFirst=NULLPTR)
{
        return GetValueHelperClass<T, BASE>(pObject, name, valueType, pValue, searchFirst);
}
 
template <class T>
GetValueHelperClass<T, T> GetValueHelper(const T *pObject, const char *name, const std::type_info &valueType, void *pValue, const NameValuePairs *searchFirst=NULLPTR)
{
        return GetValueHelperClass<T, T>(pObject, name, valueType, pValue, searchFirst);
}
 
// ********************************************************
 
template <class T, class BASE>
class AssignFromHelperClass
{
public:
        AssignFromHelperClass(T *pObject, const NameValuePairs &source)
                : m_pObject(pObject), m_source(source), m_done(false)
        {
                if (source.GetThisObject(*pObject))
                        m_done = true;
                else if (typeid(BASE) != typeid(T))
                        pObject->BASE::AssignFrom(source);
        }
 
        template <class R>
        AssignFromHelperClass & operator()(const char *name, void (T::*pm)(const R&))
        {
                if (!m_done)
                {
                        R value;
                        if (!m_source.GetValue(name, value))
                                throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name + "'");
                        (m_pObject->*pm)(value);
                }
                return *this;
        }
 
        template <class R, class S>
        AssignFromHelperClass & operator()(const char *name1, const char *name2, void (T::*pm)(const R&, const S&))
        {
                if (!m_done)
                {
                        R value1;
                        if (!m_source.GetValue(name1, value1))
                                throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name1 + "'");
                        S value2;
                        if (!m_source.GetValue(name2, value2))
                                throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name2 + "'");
                        (m_pObject->*pm)(value1, value2);
                }
                return *this;
        }
 
private:
        T *m_pObject;
        const NameValuePairs &m_source;
        bool m_done;
};
 
template <class BASE, class T>
AssignFromHelperClass<T, BASE> AssignFromHelper(T *pObject, const NameValuePairs &source)
{
        return AssignFromHelperClass<T, BASE>(pObject, source);
}
 
template <class T>
AssignFromHelperClass<T, T> AssignFromHelper(T *pObject, const NameValuePairs &source)
{
        return AssignFromHelperClass<T, T>(pObject, source);
}
 
#endif // CRYPTOPP_DOXYGEN_PROCESSING
 
// ********************************************************
 
#ifndef CRYPTOPP_NO_ASSIGN_TO_INTEGER
// Allow the linker to discard Integer code if not needed.
// Also see http://github.com/weidai11/cryptopp/issues/389.
CRYPTOPP_DLL bool AssignIntToInteger(const std::type_info &valueType, void *pInteger, const void *pInt);
#endif
 
CRYPTOPP_DLL const std::type_info & CRYPTOPP_API IntegerTypeId();
 
class CRYPTOPP_DLL AlgorithmParametersBase
{
public:
        class ParameterNotUsed : public Exception
        {
        public:
                ParameterNotUsed(const char *name) : Exception(OTHER_ERROR, std::string("AlgorithmParametersBase: parameter \"") + name + "\" not used") {}
        };
 
        virtual ~AlgorithmParametersBase() CRYPTOPP_THROW
        {
 
#if defined(CRYPTOPP_CXX17_UNCAUGHT_EXCEPTIONS)
                if (std::uncaught_exceptions() == 0)
#elif defined(CRYPTOPP_CXX98_UNCAUGHT_EXCEPTION)
                if (std::uncaught_exception() == false)
#else
                try
#endif
                {
                        if (m_throwIfNotUsed && !m_used)
                                throw ParameterNotUsed(m_name);
                }
#if !defined(CRYPTOPP_CXX98_UNCAUGHT_EXCEPTION)
# if !defined(CRYPTOPP_CXX17_UNCAUGHT_EXCEPTIONS)
                catch(const Exception&)
                {
                }
# endif
#endif
        }
 
        // this is actually a move, not a copy
        AlgorithmParametersBase(const AlgorithmParametersBase &x)
                : m_name(x.m_name), m_throwIfNotUsed(x.m_throwIfNotUsed), m_used(x.m_used)
        {
                m_next.reset(const_cast<AlgorithmParametersBase &>(x).m_next.release());
                x.m_used = true;
        }
 
        AlgorithmParametersBase(const char *name, bool throwIfNotUsed)
                : m_name(name), m_throwIfNotUsed(throwIfNotUsed), m_used(false) {}
 
        bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;
 
protected:
        friend class AlgorithmParameters;
        void operator=(const AlgorithmParametersBase& rhs);  // assignment not allowed, declare this for VC60
 
        virtual void AssignValue(const char *name, const std::type_info &valueType, void *pValue) const =0;
        virtual void MoveInto(void *p) const =0;        // not really const
 
        const char *m_name;
        bool m_throwIfNotUsed;
        mutable bool m_used;
        member_ptr<AlgorithmParametersBase> m_next;
};
 
template <class T>
class AlgorithmParametersTemplate : public AlgorithmParametersBase
{
public:
        AlgorithmParametersTemplate(const char *name, const T &value, bool throwIfNotUsed)
                : AlgorithmParametersBase(name, throwIfNotUsed), m_value(value)
        {
        }
 
        void AssignValue(const char *name, const std::type_info &valueType, void *pValue) const
        {
#ifndef CRYPTOPP_NO_ASSIGN_TO_INTEGER
                // Special case for retrieving an Integer parameter when an int was passed in
                if (!(typeid(T) == typeid(int) && AssignIntToInteger(valueType, pValue, &m_value)))
#endif
                {
                        NameValuePairs::ThrowIfTypeMismatch(name, typeid(T), valueType);
                        *reinterpret_cast<T *>(pValue) = m_value;
                }
        }
 
#if defined(DEBUG_NEW) && (_MSC_VER >= 1300)
# pragma push_macro("new")
# undef new
#endif
 
        void MoveInto(void *buffer) const
        {
                AlgorithmParametersTemplate<T>* p = new(buffer) AlgorithmParametersTemplate<T>(*this);
                CRYPTOPP_UNUSED(p);     // silence warning
        }
 
#if defined(DEBUG_NEW) && (_MSC_VER >= 1300)
# pragma pop_macro("new")
#endif
 
protected:
        T m_value;
};
 
CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<bool>;
CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<int>;
CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<ConstByteArrayParameter>;
 
class CRYPTOPP_DLL AlgorithmParameters : public NameValuePairs
{
public:
        AlgorithmParameters();
 
#ifdef __BORLANDC__
        template <class T>
        AlgorithmParameters(const char *name, const T &value, bool throwIfNotUsed=true)
                : m_next(new AlgorithmParametersTemplate<T>(name, value, throwIfNotUsed))
                , m_defaultThrowIfNotUsed(throwIfNotUsed)
        {
        }
#endif
 
        AlgorithmParameters(const AlgorithmParameters &x);
 
        AlgorithmParameters & operator=(const AlgorithmParameters &x);
 
        template <class T>
        AlgorithmParameters & operator()(const char *name, const T &value, bool throwIfNotUsed)
        {
                member_ptr<AlgorithmParametersBase> p(new AlgorithmParametersTemplate<T>(name, value, throwIfNotUsed));
                p->m_next.reset(m_next.release());
                m_next.reset(p.release());
                m_defaultThrowIfNotUsed = throwIfNotUsed;
                return *this;
        }
 
        template <class T>
        AlgorithmParameters & operator()(const char *name, const T &value)
        {
                return operator()(name, value, m_defaultThrowIfNotUsed);
        }
 
        bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;
 
protected:
        member_ptr<AlgorithmParametersBase> m_next;
        bool m_defaultThrowIfNotUsed;
};
 
#ifdef __BORLANDC__
typedef AlgorithmParameters MakeParameters;
#else
template <class T>
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed = true)
{
        return AlgorithmParameters()(name, value, throwIfNotUsed);
}
#endif
 
#define CRYPTOPP_GET_FUNCTION_ENTRY(name)               (Name::name(), &ThisClass::Get##name)
#define CRYPTOPP_SET_FUNCTION_ENTRY(name)               (Name::name(), &ThisClass::Set##name)
#define CRYPTOPP_SET_FUNCTION_ENTRY2(name1, name2)      (Name::name1(), Name::name2(), &ThisClass::Set##name1##And##name2)
 
NAMESPACE_END
 
#endif