/*

* (C) 2017 Jack Lloyd

*

* Botan is released under the Simplified BSD License (see license.txt)

*/

#include <botan/exceptn.h>

namespace Botan {

std::string to_string(ErrorType type)

   {

   switch(type)

      {

      case ErrorType::Unknown:

         return "Unknown";

      case ErrorType::SystemError:

         return "SystemError";

      case ErrorType::NotImplemented:

         return "NotImplemented";

      case ErrorType::OutOfMemory:

         return "OutOfMemory";

      case ErrorType::InternalError:

         return "InternalError";

      case ErrorType::IoError:

         return "IoError";

      case ErrorType::InvalidObjectState :

         return "InvalidObjectState";

      case ErrorType::KeyNotSet:

         return "KeyNotSet";

      case ErrorType::InvalidArgument:

         return "InvalidArgument";

      case ErrorType::InvalidKeyLength:

         return "InvalidKeyLength";

      case ErrorType::InvalidNonceLength:

         return "InvalidNonceLength";

      case ErrorType::LookupError:

         return "LookupError";

      case ErrorType::EncodingFailure:

         return "EncodingFailure";

      case ErrorType::DecodingFailure:

         return "DecodingFailure";

      case ErrorType::TLSError:

         return "TLSError";

      case ErrorType::HttpError:

         return "HttpError";

      case ErrorType::InvalidTag:

         return "InvalidTag";

      case ErrorType::RoughtimeError:

         return "RoughtimeError";

      case ErrorType::CommonCryptoError:

         return "CommonCryptoError";

      case ErrorType::Pkcs11Error:

         return "Pkcs11Error";

      case ErrorType::TPMError:

         return "TPMError";

      case ErrorType::DatabaseError:

         return "DatabaseError";

      case ErrorType::ZlibError :

         return "ZlibError";

      case ErrorType::Bzip2Error:

         return "Bzip2Error" ;

      case ErrorType::LzmaError:

         return "LzmaError";

      }

   // No default case in above switch so compiler warns

   return "Unrecognized Botan error";

   }

Exception::Exception(const std::string& msg) : m_msg(msg)

   {}

Exception::Exception(const std::string& msg, const std::exception& e) :

   m_msg(msg + " failed with " + std::string(e.what()))

   {}

Exception::Exception(const char* prefix, const std::string& msg) :

   m_msg(std::string(prefix) + " " + msg)

   {}

Invalid_Argument::Invalid_Argument(const std::string& msg) :

   Exception(msg)

   {}

Invalid_Argument::Invalid_Argument(const std::string& msg, const std::string& where) :

   Exception(msg + " in " + where)

   {}

Invalid_Argument::Invalid_Argument(const std::string& msg, const std::exception& e) :

   Exception(msg, e) {}

Lookup_Error::Lookup_Error(const std::string& type,

                           const std::string& algo,

                           const std::string& provider) :

   Exception("Unavailable " + type + " " + algo +

             (provider.empty() ? std::string("") : (" for provider " + provider)))

   {}

Internal_Error::Internal_Error(const std::string& err) :

   Exception("Internal error: " + err)

   {}

Unknown_PK_Field_Name::Unknown_PK_Field_Name(const std::string& algo_name,

                                             const std::string& field_name) :

   Invalid_Argument("Unknown field '" + field_name +

                    "' for algorithm " + algo_name)

   {}

Invalid_Key_Length::Invalid_Key_Length(const std::string& name, size_t length) :

   Invalid_Argument(name + " cannot accept a key of length " +

                    std::to_string(length))

   {}

Invalid_IV_Length::Invalid_IV_Length(const std::string& mode, size_t bad_len) :

   Invalid_Argument("IV length " + std::to_string(bad_len) +

                    " is invalid for " + mode)

   {}

Key_Not_Set::Key_Not_Set(const std::string& algo) :

   Invalid_State("Key not set in " + algo)

   {}

PRNG_Unseeded::PRNG_Unseeded(const std::string& algo) :

   Invalid_State("PRNG not seeded: " + algo)

   {}

Algorithm_Not_Found::Algorithm_Not_Found(const std::string& name) :

   Lookup_Error("Could not find any algorithm named \"" + name + "\"")

   {}

Provider_Not_Found::Provider_Not_Found(const std::string& algo, const std::string& provider) :

   Lookup_Error("Could not find provider '" + provider + "' for " + algo)

   {}

Invalid_Algorithm_Name::Invalid_Algorithm_Name(const std::string& name):

   Invalid_Argument("Invalid algorithm name: " + name)

   {}

Encoding_Error::Encoding_Error(const std::string& name) :

   Exception("Encoding error: " + name)

   {}

Decoding_Error::Decoding_Error(const std::string& name) :

   Exception(name)

   {}

Decoding_Error::Decoding_Error(const std::string& msg, const std::exception& e) :

   Exception(msg, e)

   {}

Decoding_Error::Decoding_Error(const std::string& name, const char* exception_message) :

   Exception(name + " failed with exception " + exception_message) {}

Invalid_Authentication_Tag::Invalid_Authentication_Tag(const std::string& msg) :

   Exception("Invalid authentication tag: " + msg)

   {}

Stream_IO_Error::Stream_IO_Error(const std::string& err) :

   Exception("I/O error: " + err)

   {}

System_Error::System_Error(const std::string& msg, int err_code) :

   Exception(msg + " error code " + std::to_string(err_code)),

   m_error_code(err_code)

   {}

Not_Implemented::Not_Implemented(const std::string& err) :

   Exception("Not implemented", err)

   {}

}