Crypto++
|
00001 #ifndef CRYPTOPP_ALGPARAM_H 00002 #define CRYPTOPP_ALGPARAM_H 00003 00004 #include "cryptlib.h" 00005 #include "smartptr.h" 00006 #include "secblock.h" 00007 00008 NAMESPACE_BEGIN(CryptoPP) 00009 00010 //! used to pass byte array input as part of a NameValuePairs object 00011 /*! the deepCopy option is used when the NameValuePairs object can't 00012 keep a copy of the data available */ 00013 class ConstByteArrayParameter 00014 { 00015 public: 00016 ConstByteArrayParameter(const char *data = NULL, bool deepCopy = false) 00017 { 00018 Assign((const byte *)data, data ? strlen(data) : 0, deepCopy); 00019 } 00020 ConstByteArrayParameter(const byte *data, size_t size, bool deepCopy = false) 00021 { 00022 Assign(data, size, deepCopy); 00023 } 00024 template <class T> ConstByteArrayParameter(const T &string, bool deepCopy = false) 00025 { 00026 CRYPTOPP_COMPILE_ASSERT(sizeof(CPP_TYPENAME T::value_type) == 1); 00027 Assign((const byte *)string.data(), string.size(), deepCopy); 00028 } 00029 00030 void Assign(const byte *data, size_t size, bool deepCopy) 00031 { 00032 if (deepCopy) 00033 m_block.Assign(data, size); 00034 else 00035 { 00036 m_data = data; 00037 m_size = size; 00038 } 00039 m_deepCopy = deepCopy; 00040 } 00041 00042 const byte *begin() const {return m_deepCopy ? m_block.begin() : m_data;} 00043 const byte *end() const {return m_deepCopy ? m_block.end() : m_data + m_size;} 00044 size_t size() const {return m_deepCopy ? m_block.size() : m_size;} 00045 00046 private: 00047 bool m_deepCopy; 00048 const byte *m_data; 00049 size_t m_size; 00050 SecByteBlock m_block; 00051 }; 00052 00053 class ByteArrayParameter 00054 { 00055 public: 00056 ByteArrayParameter(byte *data = NULL, unsigned int size = 0) 00057 : m_data(data), m_size(size) {} 00058 ByteArrayParameter(SecByteBlock &block) 00059 : m_data(block.begin()), m_size(block.size()) {} 00060 00061 byte *begin() const {return m_data;} 00062 byte *end() const {return m_data + m_size;} 00063 size_t size() const {return m_size;} 00064 00065 private: 00066 byte *m_data; 00067 size_t m_size; 00068 }; 00069 00070 class CRYPTOPP_DLL CombinedNameValuePairs : public NameValuePairs 00071 { 00072 public: 00073 CombinedNameValuePairs(const NameValuePairs &pairs1, const NameValuePairs &pairs2) 00074 : m_pairs1(pairs1), m_pairs2(pairs2) {} 00075 00076 bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const; 00077 00078 private: 00079 const NameValuePairs &m_pairs1, &m_pairs2; 00080 }; 00081 00082 template <class T, class BASE> 00083 class GetValueHelperClass 00084 { 00085 public: 00086 GetValueHelperClass(const T *pObject, const char *name, const std::type_info &valueType, void *pValue, const NameValuePairs *searchFirst) 00087 : m_pObject(pObject), m_name(name), m_valueType(&valueType), m_pValue(pValue), m_found(false), m_getValueNames(false) 00088 { 00089 if (strcmp(m_name, "ValueNames") == 0) 00090 { 00091 m_found = m_getValueNames = true; 00092 NameValuePairs::ThrowIfTypeMismatch(m_name, typeid(std::string), *m_valueType); 00093 if (searchFirst) 00094 searchFirst->GetVoidValue(m_name, valueType, pValue); 00095 if (typeid(T) != typeid(BASE)) 00096 pObject->BASE::GetVoidValue(m_name, valueType, pValue); 00097 ((*reinterpret_cast<std::string *>(m_pValue) += "ThisPointer:") += typeid(T).name()) += ';'; 00098 } 00099 00100 if (!m_found && strncmp(m_name, "ThisPointer:", 12) == 0 && strcmp(m_name+12, typeid(T).name()) == 0) 00101 { 00102 NameValuePairs::ThrowIfTypeMismatch(m_name, typeid(T *), *m_valueType); 00103 *reinterpret_cast<const T **>(pValue) = pObject; 00104 m_found = true; 00105 return; 00106 } 00107 00108 if (!m_found && searchFirst) 00109 m_found = searchFirst->GetVoidValue(m_name, valueType, pValue); 00110 00111 if (!m_found && typeid(T) != typeid(BASE)) 00112 m_found = pObject->BASE::GetVoidValue(m_name, valueType, pValue); 00113 } 00114 00115 operator bool() const {return m_found;} 00116 00117 template <class R> 00118 GetValueHelperClass<T,BASE> & operator()(const char *name, const R & (T::*pm)() const) 00119 { 00120 if (m_getValueNames) 00121 (*reinterpret_cast<std::string *>(m_pValue) += name) += ";"; 00122 if (!m_found && strcmp(name, m_name) == 0) 00123 { 00124 NameValuePairs::ThrowIfTypeMismatch(name, typeid(R), *m_valueType); 00125 *reinterpret_cast<R *>(m_pValue) = (m_pObject->*pm)(); 00126 m_found = true; 00127 } 00128 return *this; 00129 } 00130 00131 GetValueHelperClass<T,BASE> &Assignable() 00132 { 00133 #ifndef __INTEL_COMPILER // ICL 9.1 workaround: Intel compiler copies the vTable pointer for some reason 00134 if (m_getValueNames) 00135 ((*reinterpret_cast<std::string *>(m_pValue) += "ThisObject:") += typeid(T).name()) += ';'; 00136 if (!m_found && strncmp(m_name, "ThisObject:", 11) == 0 && strcmp(m_name+11, typeid(T).name()) == 0) 00137 { 00138 NameValuePairs::ThrowIfTypeMismatch(m_name, typeid(T), *m_valueType); 00139 *reinterpret_cast<T *>(m_pValue) = *m_pObject; 00140 m_found = true; 00141 } 00142 #endif 00143 return *this; 00144 } 00145 00146 private: 00147 const T *m_pObject; 00148 const char *m_name; 00149 const std::type_info *m_valueType; 00150 void *m_pValue; 00151 bool m_found, m_getValueNames; 00152 }; 00153 00154 template <class BASE, class T> 00155 GetValueHelperClass<T, BASE> GetValueHelper(const T *pObject, const char *name, const std::type_info &valueType, void *pValue, const NameValuePairs *searchFirst=NULL, BASE *dummy=NULL) 00156 { 00157 return GetValueHelperClass<T, BASE>(pObject, name, valueType, pValue, searchFirst); 00158 } 00159 00160 template <class T> 00161 GetValueHelperClass<T, T> GetValueHelper(const T *pObject, const char *name, const std::type_info &valueType, void *pValue, const NameValuePairs *searchFirst=NULL) 00162 { 00163 return GetValueHelperClass<T, T>(pObject, name, valueType, pValue, searchFirst); 00164 } 00165 00166 // ******************************************************** 00167 00168 template <class R> 00169 R Hack_DefaultValueFromConstReferenceType(const R &) 00170 { 00171 return R(); 00172 } 00173 00174 template <class R> 00175 bool Hack_GetValueIntoConstReference(const NameValuePairs &source, const char *name, const R &value) 00176 { 00177 return source.GetValue(name, const_cast<R &>(value)); 00178 } 00179 00180 template <class T, class BASE> 00181 class AssignFromHelperClass 00182 { 00183 public: 00184 AssignFromHelperClass(T *pObject, const NameValuePairs &source) 00185 : m_pObject(pObject), m_source(source), m_done(false) 00186 { 00187 if (source.GetThisObject(*pObject)) 00188 m_done = true; 00189 else if (typeid(BASE) != typeid(T)) 00190 pObject->BASE::AssignFrom(source); 00191 } 00192 00193 template <class R> 00194 AssignFromHelperClass & operator()(const char *name, void (T::*pm)(R)) // VC60 workaround: "const R &" here causes compiler error 00195 { 00196 if (!m_done) 00197 { 00198 R value = Hack_DefaultValueFromConstReferenceType(reinterpret_cast<R>(*(int *)NULL)); 00199 if (!Hack_GetValueIntoConstReference(m_source, name, value)) 00200 throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name + "'"); 00201 (m_pObject->*pm)(value); 00202 } 00203 return *this; 00204 } 00205 00206 template <class R, class S> 00207 AssignFromHelperClass & operator()(const char *name1, const char *name2, void (T::*pm)(R, S)) // VC60 workaround: "const R &" here causes compiler error 00208 { 00209 if (!m_done) 00210 { 00211 R value1 = Hack_DefaultValueFromConstReferenceType(reinterpret_cast<R>(*(int *)NULL)); 00212 if (!Hack_GetValueIntoConstReference(m_source, name1, value1)) 00213 throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name1 + "'"); 00214 S value2 = Hack_DefaultValueFromConstReferenceType(reinterpret_cast<S>(*(int *)NULL)); 00215 if (!Hack_GetValueIntoConstReference(m_source, name2, value2)) 00216 throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name2 + "'"); 00217 (m_pObject->*pm)(value1, value2); 00218 } 00219 return *this; 00220 } 00221 00222 private: 00223 T *m_pObject; 00224 const NameValuePairs &m_source; 00225 bool m_done; 00226 }; 00227 00228 template <class BASE, class T> 00229 AssignFromHelperClass<T, BASE> AssignFromHelper(T *pObject, const NameValuePairs &source, BASE *dummy=NULL) 00230 { 00231 return AssignFromHelperClass<T, BASE>(pObject, source); 00232 } 00233 00234 template <class T> 00235 AssignFromHelperClass<T, T> AssignFromHelper(T *pObject, const NameValuePairs &source) 00236 { 00237 return AssignFromHelperClass<T, T>(pObject, source); 00238 } 00239 00240 // ******************************************************** 00241 00242 // to allow the linker to discard Integer code if not needed. 00243 typedef bool (CRYPTOPP_API * PAssignIntToInteger)(const std::type_info &valueType, void *pInteger, const void *pInt); 00244 CRYPTOPP_DLL extern PAssignIntToInteger g_pAssignIntToInteger; 00245 00246 CRYPTOPP_DLL const std::type_info & CRYPTOPP_API IntegerTypeId(); 00247 00248 class CRYPTOPP_DLL AlgorithmParametersBase 00249 { 00250 public: 00251 class ParameterNotUsed : public Exception 00252 { 00253 public: 00254 ParameterNotUsed(const char *name) : Exception(OTHER_ERROR, std::string("AlgorithmParametersBase: parameter \"") + name + "\" not used") {} 00255 }; 00256 00257 // this is actually a move, not a copy 00258 AlgorithmParametersBase(const AlgorithmParametersBase &x) 00259 : m_name(x.m_name), m_throwIfNotUsed(x.m_throwIfNotUsed), m_used(x.m_used) 00260 { 00261 m_next.reset(const_cast<AlgorithmParametersBase &>(x).m_next.release()); 00262 x.m_used = true; 00263 } 00264 00265 AlgorithmParametersBase(const char *name, bool throwIfNotUsed) 00266 : m_name(name), m_throwIfNotUsed(throwIfNotUsed), m_used(false) {} 00267 00268 virtual ~AlgorithmParametersBase() 00269 { 00270 #ifdef CRYPTOPP_UNCAUGHT_EXCEPTION_AVAILABLE 00271 if (!std::uncaught_exception()) 00272 #else 00273 try 00274 #endif 00275 { 00276 if (m_throwIfNotUsed && !m_used) 00277 throw ParameterNotUsed(m_name); 00278 } 00279 #ifndef CRYPTOPP_UNCAUGHT_EXCEPTION_AVAILABLE 00280 catch(...) 00281 { 00282 } 00283 #endif 00284 } 00285 00286 bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const; 00287 00288 protected: 00289 friend class AlgorithmParameters; 00290 void operator=(const AlgorithmParametersBase& rhs); // assignment not allowed, declare this for VC60 00291 00292 virtual void AssignValue(const char *name, const std::type_info &valueType, void *pValue) const =0; 00293 virtual void MoveInto(void *p) const =0; // not really const 00294 00295 const char *m_name; 00296 bool m_throwIfNotUsed; 00297 mutable bool m_used; 00298 member_ptr<AlgorithmParametersBase> m_next; 00299 }; 00300 00301 template <class T> 00302 class AlgorithmParametersTemplate : public AlgorithmParametersBase 00303 { 00304 public: 00305 AlgorithmParametersTemplate(const char *name, const T &value, bool throwIfNotUsed) 00306 : AlgorithmParametersBase(name, throwIfNotUsed), m_value(value) 00307 { 00308 } 00309 00310 void AssignValue(const char *name, const std::type_info &valueType, void *pValue) const 00311 { 00312 // special case for retrieving an Integer parameter when an int was passed in 00313 if (!(g_pAssignIntToInteger != NULL && typeid(T) == typeid(int) && g_pAssignIntToInteger(valueType, pValue, &m_value))) 00314 { 00315 NameValuePairs::ThrowIfTypeMismatch(name, typeid(T), valueType); 00316 *reinterpret_cast<T *>(pValue) = m_value; 00317 } 00318 } 00319 00320 void MoveInto(void *buffer) const 00321 { 00322 AlgorithmParametersTemplate<T>* p = new(buffer) AlgorithmParametersTemplate<T>(*this); 00323 } 00324 00325 protected: 00326 T m_value; 00327 }; 00328 00329 CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<bool>; 00330 CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<int>; 00331 CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<ConstByteArrayParameter>; 00332 00333 class CRYPTOPP_DLL AlgorithmParameters : public NameValuePairs 00334 { 00335 public: 00336 AlgorithmParameters(); 00337 00338 #ifdef __BORLANDC__ 00339 template <class T> 00340 AlgorithmParameters(const char *name, const T &value, bool throwIfNotUsed=true) 00341 : m_next(new AlgorithmParametersTemplate<T>(name, value, throwIfNotUsed)) 00342 , m_defaultThrowIfNotUsed(throwIfNotUsed) 00343 { 00344 } 00345 #endif 00346 00347 AlgorithmParameters(const AlgorithmParameters &x); 00348 00349 AlgorithmParameters & operator=(const AlgorithmParameters &x); 00350 00351 template <class T> 00352 AlgorithmParameters & operator()(const char *name, const T &value, bool throwIfNotUsed) 00353 { 00354 member_ptr<AlgorithmParametersBase> p(new AlgorithmParametersTemplate<T>(name, value, throwIfNotUsed)); 00355 p->m_next.reset(m_next.release()); 00356 m_next.reset(p.release()); 00357 m_defaultThrowIfNotUsed = throwIfNotUsed; 00358 return *this; 00359 } 00360 00361 template <class T> 00362 AlgorithmParameters & operator()(const char *name, const T &value) 00363 { 00364 return operator()(name, value, m_defaultThrowIfNotUsed); 00365 } 00366 00367 bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const; 00368 00369 protected: 00370 member_ptr<AlgorithmParametersBase> m_next; 00371 bool m_defaultThrowIfNotUsed; 00372 }; 00373 00374 //! Create an object that implements NameValuePairs for passing parameters 00375 /*! \param throwIfNotUsed if true, the object will throw an exception if the value is not accessed 00376 \note throwIfNotUsed is ignored if using a compiler that does not support std::uncaught_exception(), 00377 such as MSVC 7.0 and earlier. 00378 \note A NameValuePairs object containing an arbitrary number of name value pairs may be constructed by 00379 repeatedly using operator() on the object returned by MakeParameters, for example: 00380 AlgorithmParameters parameters = MakeParameters(name1, value1)(name2, value2)(name3, value3); 00381 */ 00382 #ifdef __BORLANDC__ 00383 typedef AlgorithmParameters MakeParameters; 00384 #else 00385 template <class T> 00386 AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed = true) 00387 { 00388 return AlgorithmParameters()(name, value, throwIfNotUsed); 00389 } 00390 #endif 00391 00392 #define CRYPTOPP_GET_FUNCTION_ENTRY(name) (Name::name(), &ThisClass::Get##name) 00393 #define CRYPTOPP_SET_FUNCTION_ENTRY(name) (Name::name(), &ThisClass::Set##name) 00394 #define CRYPTOPP_SET_FUNCTION_ENTRY2(name1, name2) (Name::name1(), Name::name2(), &ThisClass::Set##name1##And##name2) 00395 00396 NAMESPACE_END 00397 00398 #endif