Coverage Report

Created: 2020-05-23 13:54

/src/botan/src/lib/utils/exceptn.cpp
Line
Count
Source (jump to first uncovered line)
1
/*
2
* (C) 2017 Jack Lloyd
3
*
4
* Botan is released under the Simplified BSD License (see license.txt)
5
*/
6
7
#include <botan/exceptn.h>
8
9
namespace Botan {
10
11
std::string to_string(ErrorType type)
12
0
   {
13
0
   switch(type)
14
0
      {
15
0
      case ErrorType::Unknown:
16
0
         return "Unknown";
17
0
      case ErrorType::SystemError:
18
0
         return "SystemError";
19
0
      case ErrorType::NotImplemented:
20
0
         return "NotImplemented";
21
0
      case ErrorType::OutOfMemory:
22
0
         return "OutOfMemory";
23
0
      case ErrorType::InternalError:
24
0
         return "InternalError";
25
0
      case ErrorType::IoError:
26
0
         return "IoError";
27
0
      case ErrorType::InvalidObjectState :
28
0
         return "InvalidObjectState";
29
0
      case ErrorType::KeyNotSet:
30
0
         return "KeyNotSet";
31
0
      case ErrorType::InvalidArgument:
32
0
         return "InvalidArgument";
33
0
      case ErrorType::InvalidKeyLength:
34
0
         return "InvalidKeyLength";
35
0
      case ErrorType::InvalidNonceLength:
36
0
         return "InvalidNonceLength";
37
0
      case ErrorType::LookupError:
38
0
         return "LookupError";
39
0
      case ErrorType::EncodingFailure:
40
0
         return "EncodingFailure";
41
0
      case ErrorType::DecodingFailure:
42
0
         return "DecodingFailure";
43
0
      case ErrorType::TLSError:
44
0
         return "TLSError";
45
0
      case ErrorType::HttpError:
46
0
         return "HttpError";
47
0
      case ErrorType::InvalidTag:
48
0
         return "InvalidTag";
49
0
      case ErrorType::RoughtimeError:
50
0
         return "RoughtimeError";
51
0
      case ErrorType::OpenSSLError :
52
0
         return "OpenSSLError";
53
0
      case ErrorType::CommonCryptoError:
54
0
         return "CommonCryptoError";
55
0
      case ErrorType::Pkcs11Error:
56
0
         return "Pkcs11Error";
57
0
      case ErrorType::TPMError:
58
0
         return "TPMError";
59
0
      case ErrorType::DatabaseError:
60
0
         return "DatabaseError";
61
0
      case ErrorType::ZlibError :
62
0
         return "ZlibError";
63
0
      case ErrorType::Bzip2Error:
64
0
         return "Bzip2Error" ;
65
0
      case ErrorType::LzmaError:
66
0
         return "LzmaError";
67
0
      }
68
0
69
0
   // No default case in above switch so compiler warns
70
0
   return "Unrecognized Botan error";
71
0
   }
72
73
Exception::Exception(const std::string& msg) : m_msg(msg)
74
60.7k
   {}
75
76
Exception::Exception(const std::string& msg, const std::exception& e) :
77
   m_msg(msg + " failed with " + std::string(e.what()))
78
9.20k
   {}
79
80
Exception::Exception(const char* prefix, const std::string& msg) :
81
   m_msg(std::string(prefix) + " " + msg)
82
0
   {}
83
84
Invalid_Argument::Invalid_Argument(const std::string& msg) :
85
   Exception(msg)
86
53.6k
   {}
87
88
Invalid_Argument::Invalid_Argument(const std::string& msg, const std::string& where) :
89
   Exception(msg + " in " + where)
90
0
   {}
91
92
Invalid_Argument::Invalid_Argument(const std::string& msg, const std::exception& e) :
93
9.20k
   Exception(msg, e) {}
94
95
Lookup_Error::Lookup_Error(const std::string& type,
96
                           const std::string& algo,
97
                           const std::string& provider) :
98
   Exception("Unavailable " + type + " " + algo +
99
             (provider.empty() ? std::string("") : (" for provider " + provider)))
100
0
   {}
101
102
Internal_Error::Internal_Error(const std::string& err) :
103
   Exception("Internal error: " + err)
104
807
   {}
105
106
Invalid_Key_Length::Invalid_Key_Length(const std::string& name, size_t length) :
107
   Invalid_Argument(name + " cannot accept a key of length " +
108
                    std::to_string(length))
109
0
   {}
110
111
Invalid_IV_Length::Invalid_IV_Length(const std::string& mode, size_t bad_len) :
112
   Invalid_Argument("IV length " + std::to_string(bad_len) +
113
                    " is invalid for " + mode)
114
0
   {}
115
116
Key_Not_Set::Key_Not_Set(const std::string& algo) :
117
   Invalid_State("Key not set in " + algo)
118
0
   {}
119
120
Policy_Violation::Policy_Violation(const std::string& err) :
121
0
   Invalid_State("Policy violation: " + err) {}
122
123
PRNG_Unseeded::PRNG_Unseeded(const std::string& algo) :
124
   Invalid_State("PRNG not seeded: " + algo)
125
0
   {}
126
127
Algorithm_Not_Found::Algorithm_Not_Found(const std::string& name) :
128
   Lookup_Error("Could not find any algorithm named \"" + name + "\"")
129
2
   {}
130
131
No_Provider_Found::No_Provider_Found(const std::string& name) :
132
   Exception("Could not find any provider for algorithm named \"" + name + "\"")
133
0
   {}
134
135
Provider_Not_Found::Provider_Not_Found(const std::string& algo, const std::string& provider) :
136
   Lookup_Error("Could not find provider '" + provider + "' for " + algo)
137
0
   {}
138
139
Invalid_Algorithm_Name::Invalid_Algorithm_Name(const std::string& name):
140
   Invalid_Argument("Invalid algorithm name: " + name)
141
0
   {}
142
143
Encoding_Error::Encoding_Error(const std::string& name) :
144
   Invalid_Argument("Encoding error: " + name)
145
208
   {}
146
147
Decoding_Error::Decoding_Error(const std::string& name) :
148
   Invalid_Argument(name)
149
41.8k
   {}
150
151
Decoding_Error::Decoding_Error(const std::string& msg, const std::exception& e) :
152
   Invalid_Argument(msg, e)
153
9.20k
   {}
154
155
Decoding_Error::Decoding_Error(const std::string& name, const char* exception_message) :
156
0
   Invalid_Argument(name + " failed with exception " + exception_message) {}
157
158
Invalid_Authentication_Tag::Invalid_Authentication_Tag(const std::string& msg) :
159
   Exception("Invalid authentication tag: " + msg)
160
576
   {}
161
162
Invalid_OID::Invalid_OID(const std::string& oid) :
163
   Decoding_Error("Invalid ASN.1 OID: " + oid)
164
0
   {}
165
166
Stream_IO_Error::Stream_IO_Error(const std::string& err) :
167
   Exception("I/O error: " + err)
168
14
   {}
169
170
System_Error::System_Error(const std::string& msg, int err_code) :
171
   Exception(msg + " error code " + std::to_string(err_code)),
172
   m_error_code(err_code)
173
0
   {}
174
175
Self_Test_Failure::Self_Test_Failure(const std::string& err) :
176
   Internal_Error("Self test failed: " + err)
177
0
   {}
178
179
Not_Implemented::Not_Implemented(const std::string& err) :
180
   Exception("Not implemented", err)
181
0
   {}
182
183
}