You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1112 lines
36 KiB
1112 lines
36 KiB
////////////////////////////////////////////////////////////////////////////////// |
|
// Name: actException.h |
|
// Product: cv act library |
|
// Purpose: exception hierarchy |
|
// |
|
// Copyright: (c) 2000 cv cryptovision GmbH |
|
// all rights reserved |
|
// Licence: The conditions for the use of this software are regulated |
|
// in the cv act library licence agreement. |
|
////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#ifndef ACT_Exception_h |
|
#define ACT_Exception_h |
|
|
|
#include <new> |
|
#include <exception> |
|
|
|
#include "actMove.h" |
|
#include "actBlob.h" |
|
|
|
namespace act |
|
{ |
|
// --------------------------------------------------------------------------- |
|
enum ExceptionId |
|
{ |
|
eiException = 0, |
|
eiBadException = eiException + 1, |
|
eiNullPointerException, |
|
eiOutOfRangeException, |
|
|
|
eiBadCastException = eiException + 10, |
|
eiBadNumericCast, |
|
eiNegativeOverflow, |
|
eiPositiveOverflow, |
|
|
|
eiRuntimeException = eiException + 20, |
|
eiBadAllocException, |
|
eiNotSupportedException, |
|
eiNotImplementedException, |
|
eiInvalidParameterException, |
|
eiSynchronizationException, |
|
|
|
eiLogicalException = eiException + 40, |
|
eiASN1Exception, |
|
eiNoSuchDLLException, |
|
eiPasswordException, |
|
eiArithmeticException, |
|
eiMessageDigestException, |
|
eiPaddingException, |
|
eiSignatureException, |
|
|
|
eiAlgorithmException = eiException + 80, |
|
eiInvalidAlgorithmParameterException, |
|
eiNoSuchAlgorithmException, |
|
|
|
eiCertificateException = eiException + 80, |
|
eiInvalidCertificateException, |
|
eiCertificateEncodingException, |
|
eiCertificateExpiredException, |
|
eiCertificateNotYetValidException, |
|
eiCertificateParsingException, |
|
|
|
eiKeyException = eiException + 100, |
|
eiInvalidKeyException, |
|
eiKeyManagementException, |
|
|
|
eiEACException = eiException + 120, |
|
eiEACDataException, |
|
eiEACMRZException, |
|
eiEACCVCertException, |
|
|
|
eiSmartcardException = eiException + 140, |
|
eiCardOutOfMemoryException, |
|
eiInvalidPinException, |
|
eiPinLockedException, |
|
eiPinExpiredException, |
|
eiPinLenRangeException, |
|
eiInvalidCRKeyException, |
|
eiInvalidCardException, |
|
eiInvalidAuthException, |
|
eiInvalidAuthObjectException, |
|
eiAuthProtocolException, |
|
eiAuthConstrainedException, |
|
eiSecureMessagingException, |
|
eiSMWrapException, |
|
eiSMUnwrapException, |
|
|
|
eiSubsystemException = eiException + 180, |
|
eiNoSuchSubsystemException, |
|
}; |
|
|
|
#ifndef UNDER_CE_30 |
|
|
|
// --------------------------------------------------------------------------- |
|
class FileAndLine |
|
{ |
|
public: |
|
FileAndLine(const char* file = 0, int line = 0) |
|
: m_line(line) |
|
, m_file(file) |
|
{ } |
|
|
|
FileAndLine(const FileAndLine& other) |
|
: m_line(other.line()) |
|
, m_file(other.file()) |
|
{ } |
|
|
|
int line() const { return m_line; } |
|
const char* file() const { return m_file; } |
|
|
|
// assignment operators. |
|
FileAndLine& operator=(const FileAndLine& other) |
|
{ |
|
m_line = other.line(); |
|
m_file = other.file(); |
|
return *this; |
|
} |
|
|
|
private: |
|
int m_line; |
|
const char* m_file; |
|
}; |
|
|
|
// |
|
// base class for all exceptions thrown by cv act library |
|
// --------------------------------------------------------------------------- |
|
class Exception |
|
{ |
|
public: |
|
typedef Exception Type; |
|
|
|
explicit Exception(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: m_what(msg) |
|
, m_where(where) |
|
, m_code(code) |
|
{ } |
|
|
|
explicit Exception(const std::exception& other) |
|
: m_what(other.what()) |
|
, m_where(0) |
|
, m_code(0) |
|
{ } |
|
|
|
template<typename T> |
|
explicit Exception(const T& other) |
|
: m_what(other.what()) |
|
, m_where(other.where()) |
|
, m_code(0) |
|
{ } |
|
|
|
virtual ~Exception() |
|
{ } |
|
|
|
template<typename _ExceptionT> |
|
_ExceptionT* TypedClone() const |
|
{ |
|
return new(std::nothrow) _ExceptionT(m_what, m_where, m_code); |
|
} |
|
|
|
template<typename _ExceptionT, typename ParamT> |
|
_ExceptionT* TypedClone(const ParamT& param) const |
|
{ |
|
return new(std::nothrow) _ExceptionT(m_what, m_where, param); |
|
} |
|
|
|
template<typename _ExceptionT> |
|
void TypedThrow() const { throw _ExceptionT(m_what, m_where, m_code); } |
|
|
|
template<typename _ExceptionT, typename ParamT> |
|
void TypedThrow(const ParamT& param) const { throw _ExceptionT(m_what, m_where, param); } |
|
|
|
virtual Exception* Clone() const { return new(std::nothrow) Exception(*this); } |
|
virtual int GetId() const { return eiException; } |
|
virtual void Throw() const { throw Exception(*this); } |
|
|
|
const char* what() const { return m_what != 0 ? m_what : ""; } |
|
const char* where() const { return m_where != 0 ? m_where : ""; } |
|
ulong code() const { return m_code; } |
|
|
|
template<typename ExceptionT> |
|
friend ExceptionT& modify(ExceptionT& e, const char* what, const char* where) |
|
{ |
|
if(what != 0) e.m_what = what; |
|
if(where != 0) e.m_where = where; |
|
return e; |
|
} |
|
|
|
protected: |
|
const char* m_what; |
|
const char* m_where; |
|
ulong m_code; |
|
}; |
|
|
|
// |
|
// ExceptionType<> |
|
// --------------------------------------------------------------------------- |
|
template |
|
< |
|
const int _exceptionId, |
|
class ExceptionT, |
|
class BaseT, |
|
typename OtherT = void |
|
> |
|
class ExceptionType : public BaseT, public OtherT |
|
{ |
|
protected: |
|
typedef BaseT BaseType; |
|
typedef OtherT OtherType; |
|
enum { exceptionId = _exceptionId }; |
|
|
|
public: |
|
ExceptionType(const char* msg, const char* where, ulong code) |
|
: BaseType(msg, where, code) |
|
, OtherT() |
|
{ } |
|
|
|
ExceptionT& operator<<(const OtherType& other) |
|
{ |
|
*static_cast<OtherType*>(this) = other; |
|
return *static_cast<ExceptionT*>(this); |
|
} |
|
|
|
template<typename _ExceptionT> |
|
_ExceptionT* TypedClone() const |
|
{ |
|
_ExceptionT* e = new(std::nothrow) _ExceptionT(BaseT::m_what, BaseT::m_where, BaseT::m_code); |
|
if(e != 0) *e << *this; |
|
return e; |
|
} |
|
|
|
virtual void Throw() const { throw ExceptionT(BaseT::m_what, BaseT::m_where, BaseT::m_code); } |
|
virtual int GetId() const { return exceptionId; } |
|
}; |
|
|
|
template |
|
< |
|
const int _exceptionId, |
|
class ExceptionT, |
|
class BaseT |
|
> |
|
class ExceptionType<_exceptionId, ExceptionT, BaseT, void> : public BaseT |
|
{ |
|
protected: |
|
typedef BaseT BaseType; |
|
enum { exceptionId = _exceptionId }; |
|
|
|
public: |
|
ExceptionType(const char* msg, const char* where, ulong code) |
|
: BaseType(msg, where, code) |
|
{ } |
|
|
|
virtual void Throw() const { throw ExceptionT(BaseT::m_what, BaseT::m_where, BaseT::m_code); } |
|
virtual int GetId() const { return exceptionId; } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class BadException : |
|
public ExceptionType<eiBadException, BadException, Exception> |
|
{ |
|
public: |
|
typedef ExceptionType<eiBadException, BadException, Exception> BaseType; |
|
typedef BadException Type; |
|
using BaseType::exceptionId; |
|
|
|
BadException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
}; |
|
|
|
class NullPointerException : |
|
public ExceptionType<eiNullPointerException, NullPointerException, BadException> |
|
{ |
|
public: |
|
typedef ExceptionType<eiNullPointerException, NullPointerException, BadException> BaseType; |
|
typedef NullPointerException Type; |
|
using BaseType::exceptionId; |
|
|
|
NullPointerException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
}; |
|
|
|
class OutOfRangeException : |
|
public ExceptionType<eiOutOfRangeException, OutOfRangeException, BadException> |
|
{ |
|
public: |
|
typedef ExceptionType<eiOutOfRangeException, OutOfRangeException, BadException> BaseType; |
|
typedef OutOfRangeException Type; |
|
using BaseType::exceptionId; |
|
|
|
OutOfRangeException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class BadCastException : |
|
public ExceptionType<eiBadCastException, BadCastException, Exception> |
|
{ |
|
public: |
|
typedef ExceptionType<eiBadCastException, BadCastException, Exception> BaseType; |
|
typedef BadCastException Type; |
|
using BaseType::exceptionId; |
|
|
|
BadCastException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
}; |
|
|
|
class BadNumericCast : |
|
public ExceptionType<eiBadNumericCast, BadNumericCast, BadCastException> |
|
{ |
|
public: |
|
typedef ExceptionType<eiBadNumericCast, BadNumericCast, BadCastException> BaseType; |
|
typedef BadNumericCast Type; |
|
using BaseType::exceptionId; |
|
|
|
BadNumericCast(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
|
|
template<typename overflow_type> |
|
void operator()(overflow_type overflow) |
|
{ |
|
switch(eiBadNumericCast + overflow) |
|
{ |
|
case eiNegativeOverflow: TypedThrow<ExceptionType<eiNegativeOverflow, Type, BaseType> >(); |
|
case eiPositiveOverflow: TypedThrow<ExceptionType<eiNegativeOverflow, Type, BaseType> >(); |
|
default: /* do nothing */; |
|
} |
|
} |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class RuntimeException : |
|
public ExceptionType<eiRuntimeException, RuntimeException, Exception> |
|
{ |
|
public: |
|
typedef ExceptionType<eiRuntimeException, RuntimeException, Exception> BaseType; |
|
typedef RuntimeException Type; |
|
using BaseType::exceptionId; |
|
|
|
RuntimeException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
}; |
|
|
|
class BadAllocException : |
|
public ExceptionType<eiBadAllocException, BadAllocException, RuntimeException> |
|
{ |
|
public: |
|
typedef ExceptionType<eiBadAllocException, BadAllocException, RuntimeException> BaseType; |
|
typedef BadAllocException Type; |
|
using BaseType::exceptionId; |
|
|
|
BadAllocException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
}; |
|
|
|
class NotSupportedException : |
|
public ExceptionType<eiNotSupportedException, NotSupportedException, RuntimeException, FileAndLine> |
|
{ |
|
public: |
|
typedef ExceptionType<eiNotSupportedException, NotSupportedException, RuntimeException, FileAndLine> BaseType; |
|
typedef NotSupportedException Type; |
|
using BaseType::exceptionId; |
|
using BaseType::operator<<; |
|
|
|
explicit NotSupportedException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
}; |
|
|
|
class NotImplementedException : |
|
public ExceptionType<eiNotImplementedException, NotImplementedException, RuntimeException, FileAndLine> |
|
{ |
|
public: |
|
typedef ExceptionType<eiNotImplementedException, NotImplementedException, RuntimeException, FileAndLine> BaseType; |
|
typedef NotImplementedException Type; |
|
using BaseType::exceptionId; |
|
using BaseType::operator<<; |
|
|
|
NotImplementedException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
}; |
|
|
|
class InvalidParameterException : |
|
public ExceptionType<eiInvalidParameterException, InvalidParameterException, RuntimeException, FileAndLine> |
|
{ |
|
public: |
|
typedef ExceptionType<eiInvalidParameterException, InvalidParameterException, RuntimeException, FileAndLine> BaseType; |
|
typedef InvalidParameterException Type; |
|
using BaseType::exceptionId; |
|
using BaseType::operator<<; |
|
|
|
InvalidParameterException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
}; |
|
|
|
class SynchronizationException : |
|
public ExceptionType<eiSynchronizationException, SynchronizationException, RuntimeException, FileAndLine> |
|
{ |
|
public: |
|
typedef ExceptionType<eiSynchronizationException, SynchronizationException, RuntimeException, FileAndLine> BaseType; |
|
typedef SynchronizationException Type; |
|
using BaseType::exceptionId; |
|
using BaseType::operator<<; |
|
|
|
SynchronizationException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: BaseType(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class LogicalException : public Exception |
|
{ |
|
public: |
|
typedef Exception BaseType; |
|
typedef LogicalException Type; |
|
|
|
LogicalException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: Exception(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiLogicalException; } |
|
}; |
|
|
|
class ASN1Exception : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef ASN1Exception Type; |
|
|
|
ASN1Exception(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiASN1Exception; } |
|
}; |
|
|
|
class NoSuchDLLException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef NoSuchDLLException Type; |
|
|
|
NoSuchDLLException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiNoSuchDLLException; } |
|
}; |
|
|
|
class PasswordException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef PasswordException Type; |
|
|
|
PasswordException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiPasswordException; } |
|
}; |
|
|
|
class ArithmeticException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef ArithmeticException Type; |
|
|
|
ArithmeticException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiArithmeticException; } |
|
}; |
|
|
|
class MessageDigestException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef MessageDigestException Type; |
|
|
|
MessageDigestException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiMessageDigestException; } |
|
}; |
|
|
|
class PaddingException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef PaddingException Type; |
|
|
|
PaddingException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiPaddingException; } |
|
}; |
|
|
|
class SignatureException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef SignatureException Type; |
|
|
|
SignatureException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiSignatureException; } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class AlgorithmException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef AlgorithmException Type; |
|
|
|
AlgorithmException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiAlgorithmException; } |
|
}; |
|
|
|
class InvalidAlgorithmParameterException : public AlgorithmException |
|
{ |
|
public: |
|
typedef AlgorithmException BaseType; |
|
typedef InvalidAlgorithmParameterException Type; |
|
|
|
InvalidAlgorithmParameterException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: AlgorithmException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidAlgorithmParameterException; } |
|
}; |
|
|
|
class NoSuchAlgorithmException : public AlgorithmException |
|
{ |
|
public: |
|
typedef AlgorithmException BaseType; |
|
typedef NoSuchAlgorithmException Type; |
|
|
|
NoSuchAlgorithmException(const char* msg = 0, const char* where = 0, const char* algorithm = 0) |
|
: AlgorithmException(msg, where) |
|
, m_algorithm(algorithm) |
|
{ |
|
m_algorithm.push_back(0); |
|
} |
|
|
|
// GCC 4.2.1 whats to have it |
|
virtual ~NoSuchAlgorithmException() |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(algorithm()); } |
|
virtual void Throw() const { throw Type(m_what, m_where, algorithm()); } |
|
virtual int GetId() const { return eiNoSuchAlgorithmException; } |
|
|
|
const char* algorithm() const { return reinterpret_cast<const char*>(&m_algorithm[0]); } |
|
|
|
protected: |
|
mutable Blob m_algorithm; |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class CertificateException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef CertificateException Type; |
|
|
|
CertificateException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiCertificateException; } |
|
}; |
|
|
|
class InvalidCertificateException : public CertificateException |
|
{ |
|
public: |
|
typedef CertificateException BaseType; |
|
typedef InvalidCertificateException Type; |
|
|
|
InvalidCertificateException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: CertificateException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidCertificateException; } |
|
}; |
|
|
|
class CertificateEncodingException : public CertificateException |
|
{ |
|
public: |
|
typedef CertificateException BaseType; |
|
typedef CertificateEncodingException Type; |
|
|
|
CertificateEncodingException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: CertificateException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiCertificateEncodingException; } |
|
}; |
|
|
|
class CertificateExpiredException : public CertificateException |
|
{ |
|
public: |
|
typedef CertificateException BaseType; |
|
typedef CertificateExpiredException Type; |
|
|
|
CertificateExpiredException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: CertificateException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiCertificateExpiredException; } |
|
}; |
|
|
|
class CertificateNotYetValidException : public CertificateException |
|
{ |
|
public: |
|
typedef CertificateException BaseType; |
|
typedef CertificateNotYetValidException Type; |
|
|
|
CertificateNotYetValidException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: CertificateException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiCertificateNotYetValidException; } |
|
}; |
|
|
|
class CertificateParsingException : public CertificateException |
|
{ |
|
public: |
|
typedef CertificateException BaseType; |
|
typedef CertificateParsingException Type; |
|
|
|
CertificateParsingException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: CertificateException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiCertificateParsingException; } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class KeyException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef KeyException Type; |
|
|
|
KeyException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiKeyException; } |
|
}; |
|
|
|
class InvalidKeyException : public KeyException |
|
{ |
|
public: |
|
typedef KeyException BaseType; |
|
typedef InvalidKeyException Type; |
|
|
|
InvalidKeyException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: KeyException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidKeyException; } |
|
}; |
|
|
|
class KeyManagementException : public KeyException |
|
{ |
|
public: |
|
typedef KeyException BaseType; |
|
typedef KeyManagementException Type; |
|
|
|
KeyManagementException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: KeyException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiKeyManagementException; } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class EACException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef EACException Type; |
|
|
|
EACException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiEACException; } |
|
}; |
|
|
|
class EACDataException : public EACException |
|
{ |
|
public: |
|
typedef EACException BaseType; |
|
typedef EACDataException Type; |
|
|
|
EACDataException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: EACException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiEACDataException; } |
|
}; |
|
|
|
class EACMRZException : public EACDataException |
|
{ |
|
public: |
|
typedef EACDataException BaseType; |
|
typedef EACMRZException Type; |
|
|
|
EACMRZException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: EACDataException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiEACMRZException; } |
|
}; |
|
|
|
class EACCVCertException : public EACDataException |
|
{ |
|
public: |
|
typedef EACDataException BaseType; |
|
typedef EACCVCertException Type; |
|
|
|
EACCVCertException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: EACDataException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiEACCVCertException; } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class SmartcardException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef SmartcardException Type; |
|
|
|
SmartcardException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiSmartcardException; } |
|
}; |
|
|
|
class CardOutOfMemoryException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef CardOutOfMemoryException Type; |
|
|
|
CardOutOfMemoryException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiCardOutOfMemoryException; } |
|
}; |
|
|
|
class InvalidPinException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef InvalidPinException Type; |
|
|
|
InvalidPinException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidPinException; } |
|
}; |
|
|
|
class PinLockedException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef PinLockedException Type; |
|
|
|
PinLockedException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiPinLockedException; } |
|
}; |
|
|
|
class PinExpiredException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef PinExpiredException Type; |
|
|
|
PinExpiredException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiPinExpiredException; } |
|
}; |
|
|
|
class PinLenRangeException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef PinLenRangeException Type; |
|
|
|
PinLenRangeException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiPinLenRangeException; } |
|
}; |
|
|
|
class InvalidCRKeyException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef InvalidCRKeyException Type; |
|
|
|
InvalidCRKeyException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidCRKeyException; } |
|
}; |
|
|
|
class InvalidCardException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef InvalidCardException Type; |
|
|
|
InvalidCardException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidCardException; } |
|
}; |
|
|
|
class InvalidAuthException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef InvalidAuthException Type; |
|
|
|
InvalidAuthException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidAuthException; } |
|
}; |
|
|
|
class InvalidAuthObjectException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef InvalidAuthObjectException Type; |
|
|
|
InvalidAuthObjectException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiInvalidAuthObjectException; } |
|
}; |
|
|
|
class AuthProtocolException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef AuthProtocolException Type; |
|
|
|
AuthProtocolException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiAuthProtocolException; } |
|
}; |
|
|
|
class AuthConstrainedException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef AuthConstrainedException Type; |
|
|
|
AuthConstrainedException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiAuthConstrainedException; } |
|
}; |
|
|
|
class SecureMessagingException : public SmartcardException |
|
{ |
|
public: |
|
typedef SmartcardException BaseType; |
|
typedef SecureMessagingException Type; |
|
|
|
SecureMessagingException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SmartcardException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiSecureMessagingException; } |
|
}; |
|
|
|
class SMWrapException : public SecureMessagingException |
|
{ |
|
public: |
|
typedef SecureMessagingException BaseType; |
|
typedef SMWrapException Type; |
|
|
|
SMWrapException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SecureMessagingException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiSMWrapException; } |
|
}; |
|
|
|
class SMUnwrapException : public SecureMessagingException |
|
{ |
|
public: |
|
typedef SecureMessagingException BaseType; |
|
typedef SMUnwrapException Type; |
|
|
|
SMUnwrapException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SecureMessagingException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiSMUnwrapException; } |
|
}; |
|
|
|
// --------------------------------------------------------------------------- |
|
class SubsystemException : public LogicalException |
|
{ |
|
public: |
|
typedef LogicalException BaseType; |
|
typedef SubsystemException Type; |
|
|
|
SubsystemException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: LogicalException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiSubsystemException; } |
|
}; |
|
|
|
class NoSuchSubsystemException : public SubsystemException |
|
{ |
|
public: |
|
typedef SubsystemException BaseType; |
|
typedef NoSuchSubsystemException Type; |
|
|
|
NoSuchSubsystemException(const char* msg = 0, const char* where = 0, ulong code = 0) |
|
: SubsystemException(msg, where, code) |
|
{ } |
|
|
|
virtual Type* Clone() const { return TypedClone<Type>(); } |
|
virtual void Throw() const { throw Type(m_what, m_where, m_code); } |
|
virtual int GetId() const { return eiNoSuchSubsystemException; } |
|
}; |
|
|
|
#else |
|
|
|
#define throw(_x) _exit(_x) |
|
|
|
int Exception(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int BadException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int NullPointerException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int OutOfRangeException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int BadCastException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int BadNumericCast(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int RuntimeException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int BadAllocException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int NotSupportedException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int NotImplementedException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int InvalidParameterException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int SynchronizationException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int LogicalException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int AlgorithmException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int InvalidAlgorithmParameterException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int NoSuchAlgorithmException(const char* msg = 0, const char* where = 0, const char* algorithm); |
|
int ArithmeticException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int CertificateException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int CertificateEncodingException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int CertificateExpiredException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int CertificateNotYetValidException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int CertificateParsingException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int KeyException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int InvalidKeyException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int KeyManagementException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int MessageDigestException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int PaddingException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int SignatureException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int EACException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int EACDataException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int EACMRZException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int EACCVCertException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int SmartcardException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int CardOutOfMemoryException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int InvalidPinException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int InvalidCardException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int InvalidAuthObjectException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int AuthProtocolException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int AuthConstrainedException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int SecureMessagingException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int SMWrapException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int SMUnwrapException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int SubsystemException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
int NoSuchSubsystemException(const char* msg = 0, const char* where = 0, ulong code = 0); |
|
|
|
#endif // UNDER_CE_30 |
|
|
|
}// namespace act |
|
|
|
#endif // ACT_Exception_h
|
|
|