error.rs (10140B)
1 // 2 // Error generator macro 3 // 4 use core::error::Error as StdError; 5 use core::fmt::{self, Debug, Display, Formatter}; 6 7 macro_rules! make_error { 8 ( $( $name:ident ( $ty:ty ): $src_fn:expr, $usr_msg_fun:expr ),+ $(,)? ) => { 9 const BAD_REQUEST: u16 = 400; 10 enum ErrorKind { $($name( $ty )),+ } 11 #[allow(clippy::error_impl_error)] 12 pub struct Error { message: String, error: ErrorKind, error_code: u16 } 13 14 $(impl From<$ty> for Error { 15 fn from(err: $ty) -> Self { Error::from((stringify!($name), err)) } 16 })+ 17 $(impl<S: Into<String>> From<(S, $ty)> for Error { 18 fn from(val: (S, $ty)) -> Self { 19 Error { message: val.0.into(), error: ErrorKind::$name(val.1), error_code: BAD_REQUEST } 20 } 21 })+ 22 impl StdError for Error { 23 fn source(&self) -> Option<&(dyn StdError + 'static)> { 24 match self.error {$( ErrorKind::$name(ref e) => $src_fn(e), )+} 25 } 26 } 27 impl Display for Error { 28 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { 29 match self.error {$( 30 ErrorKind::$name(ref e) => f.write_str(&$usr_msg_fun(e, &self.message)), 31 )+} 32 } 33 } 34 }; 35 } 36 use core::any::Any; 37 use core::convert::Infallible; 38 use diesel::ConnectionError as DieselConErr; 39 use diesel::r2d2::PoolError as R2d2Err; 40 use diesel::result::Error as DieselErr; 41 use jsonwebtoken::errors::Error as JwtErr; 42 use openssl::error::ErrorStack as SSLErr; 43 #[cfg(all(feature = "priv_sep", target_os = "openbsd"))] 44 use priv_sep::UnveilErr; 45 use rocket::error::Error as RocketErr; 46 use serde_json::{Error as SerdeErr, Value}; 47 use std::io::Error as IoErr; 48 use std::time::SystemTimeError as TimeErr; 49 use webauthn_rp::AggErr as WebAuthnErr; 50 51 #[derive(Serialize)] 52 struct Empty; 53 54 // Error struct 55 // Contains a String error message, meant for the user and an enum variant, with an error of different types. 56 // 57 // After the variant itself, there are two expressions. The first one indicates whether the error contains a source error (that we pretty print). 58 // The second one contains the function used to obtain the response sent to the client 59 #[cfg(not(all(feature = "priv_sep", target_os = "openbsd")))] 60 make_error! { 61 // Just an empty error 62 Empty(Empty): _no_source, _serialize, 63 // Used to represent err! calls 64 Simple(String): _no_source, _api_error, 65 // Used for special return values, like 2FA errors 66 Json(Value): _no_source, _serialize, 67 Db(DieselErr): _has_source, _api_error, 68 R2d2(R2d2Err): _has_source, _api_error, 69 Serde(SerdeErr): _has_source, _api_error, 70 JWt(JwtErr): _has_source, _api_error, 71 72 Io(IoErr): _has_source, _api_error, 73 Time(TimeErr): _has_source, _api_error, 74 75 OpenSSL(SSLErr): _has_source, _api_error, 76 Rocket(RocketErr): _has_source, _api_error, 77 78 DieselCon(DieselConErr): _has_source, _api_error, 79 WebAuthn(WebAuthnErr): _has_source, _api_error, 80 } 81 // Error struct 82 // Contains a String error message, meant for the user and an enum variant, with an error of different types. 83 // 84 // After the variant itself, there are two expressions. The first one indicates whether the error contains a source error (that we pretty print). 85 // The second one contains the function used to obtain the response sent to the client 86 #[cfg(all(feature = "priv_sep", target_os = "openbsd"))] 87 make_error! { 88 // Just an empty error 89 Empty(Empty): _no_source, _serialize, 90 // Used to represent err! calls 91 Simple(String): _no_source, _api_error, 92 // Used for special return values, like 2FA errors 93 Json(Value): _no_source, _serialize, 94 Db(DieselErr): _has_source, _api_error, 95 R2d2(R2d2Err): _has_source, _api_error, 96 Serde(SerdeErr): _has_source, _api_error, 97 JWt(JwtErr): _has_source, _api_error, 98 99 Io(IoErr): _has_source, _api_error, 100 Time(TimeErr): _has_source, _api_error, 101 102 OpenSSL(SSLErr): _has_source, _api_error, 103 Rocket(RocketErr): _has_source, _api_error, 104 Unveil(UnveilErr): _has_source, _api_error, 105 106 DieselCon(DieselConErr): _has_source, _api_error, 107 WebAuthn(WebAuthnErr): _has_source, _api_error, 108 } 109 impl From<Infallible> for Error { 110 #[inline] 111 fn from(value: Infallible) -> Self { 112 match value {} 113 } 114 } 115 impl Debug for Error { 116 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { 117 match self.source() { 118 Some(e) => write!(f, "{}.\n[CAUSE] {:#?}", self.message, e), 119 None => match self.error { 120 ErrorKind::Empty(_) => Ok(()), 121 ErrorKind::Simple(ref s) => { 122 if &self.message == s { 123 write!(f, "{}", self.message) 124 } else { 125 write!(f, "{}. {}", self.message, s) 126 } 127 } 128 #[cfg(all(feature = "priv_sep", target_os = "openbsd"))] 129 ErrorKind::Unveil(ref err) => Display::fmt(err, f), 130 ErrorKind::Json(_) => write!(f, "{}", self.message), 131 ErrorKind::Db(_) 132 | ErrorKind::R2d2(_) 133 | ErrorKind::Serde(_) 134 | ErrorKind::JWt(_) 135 | ErrorKind::Io(_) 136 | ErrorKind::Time(_) 137 | ErrorKind::OpenSSL(_) 138 | ErrorKind::Rocket(_) 139 | ErrorKind::DieselCon(_) 140 | ErrorKind::WebAuthn(_) => unreachable!(), 141 }, 142 } 143 } 144 } 145 146 impl Error { 147 pub fn new<M: Into<String>, N: Into<String>>(usr_msg: M, log_msg: N) -> Self { 148 (usr_msg, log_msg.into()).into() 149 } 150 #[must_use] 151 pub fn empty() -> Self { 152 Empty {}.into() 153 } 154 #[must_use] 155 fn with_msg<M: Into<String>>(mut self, msg: M) -> Self { 156 self.message = msg.into(); 157 self 158 } 159 #[must_use] 160 pub const fn with_code(mut self, code: u16) -> Self { 161 self.error_code = code; 162 self 163 } 164 } 165 166 pub trait MapResult<S> { 167 fn map_res(self, msg: &str) -> Result<S, Error>; 168 } 169 170 impl<S, E: Into<Error>> MapResult<S> for Result<S, E> { 171 fn map_res(self, msg: &str) -> Result<S, Error> { 172 self.map_err(|e| e.into().with_msg(msg)) 173 } 174 } 175 176 impl<E: Into<Error>> MapResult<()> for Result<usize, E> { 177 fn map_res(self, msg: &str) -> Result<(), Error> { 178 self.and(Ok(())).map_res(msg) 179 } 180 } 181 182 impl<S> MapResult<S> for Option<S> { 183 fn map_res(self, msg: &str) -> Result<S, Error> { 184 self.ok_or_else(|| Error::new(msg, "")) 185 } 186 } 187 #[allow(clippy::unnecessary_wraps)] 188 const fn _has_source<T>(e: T) -> Option<T> { 189 Some(e) 190 } 191 fn _no_source<T, S>(_: T) -> Option<S> { 192 None 193 } 194 195 fn _serialize(e: &impl serde::Serialize, _msg: &str) -> String { 196 serde_json::to_string(e).unwrap() 197 } 198 199 fn _api_error(_: &impl Any, msg: &str) -> String { 200 let json = json!({ 201 "Message": msg, 202 "error": "", 203 "error_description": "", 204 "ValidationErrors": {"": [ msg ]}, 205 "ErrorModel": { 206 "Message": msg, 207 "Object": "error" 208 }, 209 "ExceptionMessage": null, 210 "ExceptionStackTrace": null, 211 "InnerExceptionMessage": null, 212 "Object": "error" 213 }); 214 _serialize(&json, "") 215 } 216 217 // 218 // Rocket responder impl 219 // 220 use rocket::http::{ContentType, Status}; 221 use rocket::request::Request; 222 use rocket::response::{self, Responder, Response}; 223 use std::io::Cursor; 224 225 impl Responder<'_, 'static> for Error { 226 fn respond_to(self, _: &Request<'_>) -> response::Result<'static> { 227 let code = Status::from_code(self.error_code).unwrap_or(Status::BadRequest); 228 let body = self.to_string(); 229 Response::build() 230 .status(code) 231 .header(ContentType::JSON) 232 .sized_body(Some(body.len()), Cursor::new(body)) 233 .ok() 234 } 235 } 236 237 // 238 // Error return macros 239 // 240 #[macro_export] 241 macro_rules! err { 242 ($msg:expr) => {{ 243 return Err($crate::error::Error::new($msg, $msg)); 244 }}; 245 ($msg:expr, ErrorEvent $err_event:tt) => {{ 246 return Err($crate::error::Error::new($msg, $msg).with_event($crate::error::ErrorEvent $err_event)); 247 }}; 248 ($usr_msg:expr, $log_value:expr) => {{ 249 return Err($crate::error::Error::new($usr_msg, $log_value)); 250 }}; 251 ($usr_msg:expr, $log_value:expr, ErrorEvent $err_event:tt) => {{ 252 return Err($crate::error::Error::new($usr_msg, $log_value).with_event($crate::error::ErrorEvent $err_event)); 253 }}; 254 } 255 256 #[macro_export] 257 macro_rules! err_silent { 258 ($msg:expr) => {{ 259 return Err($crate::error::Error::new($msg, $msg)); 260 }}; 261 ($usr_msg:expr, $log_value:expr) => {{ 262 return Err($crate::error::Error::new($usr_msg, $log_value)); 263 }}; 264 } 265 266 #[macro_export] 267 macro_rules! err_code { 268 ($msg:expr, $err_code:expr) => {{ 269 return Err($crate::error::Error::new($msg, $msg).with_code($err_code)); 270 }}; 271 ($usr_msg:expr, $log_value:expr, $err_code:expr) => {{ 272 return Err($crate::error::Error::new($usr_msg, $log_value).with_code($err_code)); 273 }}; 274 } 275 276 #[macro_export] 277 macro_rules! err_discard { 278 ($msg:expr, $data:expr) => {{ 279 std::io::copy(&mut $data.open(), &mut std::io::sink()).ok(); 280 return Err($crate::error::Error::new($msg, $msg)); 281 }}; 282 ($usr_msg:expr, $log_value:expr, $data:expr) => {{ 283 std::io::copy(&mut $data.open(), &mut std::io::sink()).ok(); 284 return Err($crate::error::Error::new($usr_msg, $log_value)); 285 }}; 286 } 287 288 #[macro_export] 289 macro_rules! err_json { 290 ($expr:expr, $log_value:expr) => {{ 291 return Err(($log_value, $expr).into()); 292 }}; 293 ($expr:expr, $log_value:expr, $err_event:expr, ErrorEvent) => {{ 294 return Err(($log_value, $expr).into().with_event($err_event)); 295 }}; 296 } 297 298 #[macro_export] 299 macro_rules! err_handler { 300 ($expr:expr) => {{ 301 return ::rocket::request::Outcome::Error((rocket::http::Status::Unauthorized, $expr)); 302 }}; 303 ($usr_msg:expr, $log_value:expr) => {{ 304 return ::rocket::request::Outcome::Error((rocket::http::Status::Unauthorized, $usr_msg)); 305 }}; 306 }