1use std::{
2 borrow::Cow,
3 collections::btree_map::{BTreeMap, Entry},
4 fmt,
5 time::Duration,
6};
7
8use js_int::UInt;
9use serde::{
10 de::{self, Deserialize, Deserializer, MapAccess, Visitor},
11 ser::{self, Serialize, SerializeMap, Serializer},
12};
13use serde_json::from_value as from_json_value;
14
15use super::{ErrorCode, ErrorKind, Extra, RetryAfter};
16
17enum Field<'de> {
18 ErrorCode,
19 SoftLogout,
20 RetryAfterMs,
21 RoomVersion,
22 AdminContact,
23 Status,
24 Body,
25 CurrentVersion,
26 Other(Cow<'de, str>),
27}
28
29impl<'de> Field<'de> {
30 fn new(s: Cow<'de, str>) -> Field<'de> {
31 match s.as_ref() {
32 "errcode" => Self::ErrorCode,
33 "soft_logout" => Self::SoftLogout,
34 "retry_after_ms" => Self::RetryAfterMs,
35 "room_version" => Self::RoomVersion,
36 "admin_contact" => Self::AdminContact,
37 "status" => Self::Status,
38 "body" => Self::Body,
39 "current_version" => Self::CurrentVersion,
40 _ => Self::Other(s),
41 }
42 }
43}
44
45impl<'de> Deserialize<'de> for Field<'de> {
46 fn deserialize<D>(deserializer: D) -> Result<Field<'de>, D::Error>
47 where
48 D: Deserializer<'de>,
49 {
50 struct FieldVisitor;
51
52 impl<'de> Visitor<'de> for FieldVisitor {
53 type Value = Field<'de>;
54
55 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
56 formatter.write_str("any struct field")
57 }
58
59 fn visit_str<E>(self, value: &str) -> Result<Field<'de>, E>
60 where
61 E: de::Error,
62 {
63 Ok(Field::new(Cow::Owned(value.to_owned())))
64 }
65
66 fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Field<'de>, E>
67 where
68 E: de::Error,
69 {
70 Ok(Field::new(Cow::Borrowed(value)))
71 }
72
73 fn visit_string<E>(self, value: String) -> Result<Field<'de>, E>
74 where
75 E: de::Error,
76 {
77 Ok(Field::new(Cow::Owned(value)))
78 }
79 }
80
81 deserializer.deserialize_identifier(FieldVisitor)
82 }
83}
84
85struct ErrorKindVisitor;
86
87impl<'de> Visitor<'de> for ErrorKindVisitor {
88 type Value = ErrorKind;
89
90 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
91 formatter.write_str("enum ErrorKind")
92 }
93
94 fn visit_map<V>(self, mut map: V) -> Result<ErrorKind, V::Error>
95 where
96 V: MapAccess<'de>,
97 {
98 let mut errcode = None;
99 let mut soft_logout = None;
100 let mut retry_after_ms = None;
101 let mut room_version = None;
102 let mut admin_contact = None;
103 let mut status = None;
104 let mut body = None;
105 let mut current_version = None;
106 let mut extra = BTreeMap::new();
107
108 macro_rules! set_field {
109 (errcode) => {
110 set_field!(@inner errcode)
111 };
112 ($field:ident) => {
113 match errcode {
114 Some(set_field!(@variant_containing $field)) | None => {
115 set_field!(@inner $field)
116 }
117 Some(_) => {
120 let _ = map.next_value::<de::IgnoredAny>()?;
121 },
122 }
123 };
124 (@variant_containing soft_logout) => { ErrorCode::UnknownToken };
125 (@variant_containing retry_after_ms) => { ErrorCode::LimitExceeded };
126 (@variant_containing room_version) => { ErrorCode::IncompatibleRoomVersion };
127 (@variant_containing admin_contact) => { ErrorCode::ResourceLimitExceeded };
128 (@variant_containing status) => { ErrorCode::BadStatus };
129 (@variant_containing body) => { ErrorCode::BadStatus };
130 (@variant_containing current_version) => { ErrorCode::WrongRoomKeysVersion };
131 (@inner $field:ident) => {
132 {
133 if $field.is_some() {
134 return Err(de::Error::duplicate_field(stringify!($field)));
135 }
136 $field = Some(map.next_value()?);
137 }
138 };
139 }
140
141 while let Some(key) = map.next_key()? {
142 match key {
143 Field::ErrorCode => set_field!(errcode),
144 Field::SoftLogout => set_field!(soft_logout),
145 Field::RetryAfterMs => set_field!(retry_after_ms),
146 Field::RoomVersion => set_field!(room_version),
147 Field::AdminContact => set_field!(admin_contact),
148 Field::Status => set_field!(status),
149 Field::Body => set_field!(body),
150 Field::CurrentVersion => set_field!(current_version),
151 Field::Other(other) => match extra.entry(other.into_owned()) {
152 Entry::Vacant(v) => {
153 v.insert(map.next_value()?);
154 }
155 Entry::Occupied(o) => {
156 return Err(de::Error::custom(format!("duplicate field `{}`", o.key())));
157 }
158 },
159 }
160 }
161
162 let errcode = errcode.ok_or_else(|| de::Error::missing_field("errcode"))?;
163 let extra = Extra(extra);
164
165 Ok(match errcode {
166 ErrorCode::BadAlias => ErrorKind::BadAlias,
167 ErrorCode::BadJson => ErrorKind::BadJson,
168 ErrorCode::BadState => ErrorKind::BadState,
169 ErrorCode::BadStatus => ErrorKind::BadStatus {
170 status: status
171 .map(|s| {
172 from_json_value::<u16>(s)
173 .map_err(de::Error::custom)?
174 .try_into()
175 .map_err(de::Error::custom)
176 })
177 .transpose()?,
178 body: body.map(from_json_value).transpose().map_err(de::Error::custom)?,
179 },
180 ErrorCode::CannotLeaveServerNoticeRoom => ErrorKind::CannotLeaveServerNoticeRoom,
181 ErrorCode::CannotOverwriteMedia => ErrorKind::CannotOverwriteMedia,
182 ErrorCode::CaptchaInvalid => ErrorKind::CaptchaInvalid,
183 ErrorCode::CaptchaNeeded => ErrorKind::CaptchaNeeded,
184 #[cfg(feature = "unstable-msc4306")]
185 ErrorCode::ConflictingUnsubscription => ErrorKind::ConflictingUnsubscription,
186 ErrorCode::ConnectionFailed => ErrorKind::ConnectionFailed,
187 ErrorCode::ConnectionTimeout => ErrorKind::ConnectionTimeout,
188 ErrorCode::DuplicateAnnotation => ErrorKind::DuplicateAnnotation,
189 ErrorCode::Exclusive => ErrorKind::Exclusive,
190 ErrorCode::Forbidden => ErrorKind::forbidden(),
191 ErrorCode::GuestAccessForbidden => ErrorKind::GuestAccessForbidden,
192 ErrorCode::IncompatibleRoomVersion => ErrorKind::IncompatibleRoomVersion {
193 room_version: from_json_value(
194 room_version.ok_or_else(|| de::Error::missing_field("room_version"))?,
195 )
196 .map_err(de::Error::custom)?,
197 },
198 ErrorCode::InvalidParam => ErrorKind::InvalidParam,
199 ErrorCode::InvalidRoomState => ErrorKind::InvalidRoomState,
200 ErrorCode::InvalidUsername => ErrorKind::InvalidUsername,
201 ErrorCode::LimitExceeded => ErrorKind::LimitExceeded {
202 retry_after: retry_after_ms
203 .map(from_json_value::<UInt>)
204 .transpose()
205 .map_err(de::Error::custom)?
206 .map(Into::into)
207 .map(Duration::from_millis)
208 .map(RetryAfter::Delay),
209 },
210 ErrorCode::MissingParam => ErrorKind::MissingParam,
211 ErrorCode::MissingToken => ErrorKind::MissingToken,
212 ErrorCode::NotFound => ErrorKind::NotFound,
213 #[cfg(feature = "unstable-msc4306")]
214 ErrorCode::NotInThread => ErrorKind::NotInThread,
215 ErrorCode::NotJson => ErrorKind::NotJson,
216 ErrorCode::NotYetUploaded => ErrorKind::NotYetUploaded,
217 ErrorCode::ResourceLimitExceeded => ErrorKind::ResourceLimitExceeded {
218 admin_contact: from_json_value(
219 admin_contact.ok_or_else(|| de::Error::missing_field("admin_contact"))?,
220 )
221 .map_err(de::Error::custom)?,
222 },
223 ErrorCode::RoomInUse => ErrorKind::RoomInUse,
224 ErrorCode::ServerNotTrusted => ErrorKind::ServerNotTrusted,
225 ErrorCode::ThreepidAuthFailed => ErrorKind::ThreepidAuthFailed,
226 ErrorCode::ThreepidDenied => ErrorKind::ThreepidDenied,
227 ErrorCode::ThreepidInUse => ErrorKind::ThreepidInUse,
228 ErrorCode::ThreepidMediumNotSupported => ErrorKind::ThreepidMediumNotSupported,
229 ErrorCode::ThreepidNotFound => ErrorKind::ThreepidNotFound,
230 ErrorCode::TooLarge => ErrorKind::TooLarge,
231 ErrorCode::UnableToAuthorizeJoin => ErrorKind::UnableToAuthorizeJoin,
232 ErrorCode::UnableToGrantJoin => ErrorKind::UnableToGrantJoin,
233 #[cfg(feature = "unstable-msc3843")]
234 ErrorCode::Unactionable => ErrorKind::Unactionable,
235 ErrorCode::Unauthorized => ErrorKind::Unauthorized,
236 ErrorCode::Unknown => ErrorKind::Unknown,
237 #[cfg(feature = "unstable-msc4186")]
238 ErrorCode::UnknownPos => ErrorKind::UnknownPos,
239 ErrorCode::UnknownToken => ErrorKind::UnknownToken {
240 soft_logout: soft_logout
241 .map(from_json_value)
242 .transpose()
243 .map_err(de::Error::custom)?
244 .unwrap_or_default(),
245 },
246 ErrorCode::Unrecognized => ErrorKind::Unrecognized,
247 ErrorCode::UnsupportedRoomVersion => ErrorKind::UnsupportedRoomVersion,
248 ErrorCode::UrlNotSet => ErrorKind::UrlNotSet,
249 ErrorCode::UserDeactivated => ErrorKind::UserDeactivated,
250 ErrorCode::UserInUse => ErrorKind::UserInUse,
251 ErrorCode::UserLocked => ErrorKind::UserLocked,
252 ErrorCode::UserSuspended => ErrorKind::UserSuspended,
253 ErrorCode::WeakPassword => ErrorKind::WeakPassword,
254 ErrorCode::WrongRoomKeysVersion => ErrorKind::WrongRoomKeysVersion {
255 current_version: from_json_value(
256 current_version.ok_or_else(|| de::Error::missing_field("current_version"))?,
257 )
258 .map_err(de::Error::custom)?,
259 },
260 ErrorCode::_Custom(errcode) => ErrorKind::_Custom { errcode, extra },
261 })
262 }
263}
264
265impl<'de> Deserialize<'de> for ErrorKind {
266 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
267 where
268 D: Deserializer<'de>,
269 {
270 deserializer.deserialize_map(ErrorKindVisitor)
271 }
272}
273
274impl Serialize for ErrorKind {
275 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
276 where
277 S: Serializer,
278 {
279 let mut st = serializer.serialize_map(None)?;
280 st.serialize_entry("errcode", &self.errcode())?;
281 match self {
282 Self::UnknownToken { soft_logout: true } | Self::UserLocked => {
283 st.serialize_entry("soft_logout", &true)?;
284 }
285 Self::LimitExceeded { retry_after: Some(RetryAfter::Delay(duration)) } => {
286 st.serialize_entry(
287 "retry_after_ms",
288 &UInt::try_from(duration.as_millis()).map_err(ser::Error::custom)?,
289 )?;
290 }
291 Self::IncompatibleRoomVersion { room_version } => {
292 st.serialize_entry("room_version", room_version)?;
293 }
294 Self::ResourceLimitExceeded { admin_contact } => {
295 st.serialize_entry("admin_contact", admin_contact)?;
296 }
297 Self::_Custom { extra, .. } => {
298 for (k, v) in &extra.0 {
299 st.serialize_entry(k, v)?;
300 }
301 }
302 _ => {}
303 }
304 st.end()
305 }
306}
307
308#[cfg(test)]
309mod tests {
310 use ruma_common::room_version_id;
311 use serde_json::{from_value as from_json_value, json};
312
313 use super::ErrorKind;
314
315 #[test]
316 fn deserialize_forbidden() {
317 let deserialized: ErrorKind = from_json_value(json!({ "errcode": "M_FORBIDDEN" })).unwrap();
318 assert_eq!(
319 deserialized,
320 ErrorKind::Forbidden {
321 #[cfg(feature = "unstable-msc2967")]
322 authenticate: None
323 }
324 );
325 }
326
327 #[test]
328 fn deserialize_forbidden_with_extra_fields() {
329 let deserialized: ErrorKind = from_json_value(json!({
330 "errcode": "M_FORBIDDEN",
331 "error": "…",
332 }))
333 .unwrap();
334
335 assert_eq!(
336 deserialized,
337 ErrorKind::Forbidden {
338 #[cfg(feature = "unstable-msc2967")]
339 authenticate: None
340 }
341 );
342 }
343
344 #[test]
345 fn deserialize_incompatible_room_version() {
346 let deserialized: ErrorKind = from_json_value(json!({
347 "errcode": "M_INCOMPATIBLE_ROOM_VERSION",
348 "room_version": "7",
349 }))
350 .unwrap();
351
352 assert_eq!(
353 deserialized,
354 ErrorKind::IncompatibleRoomVersion { room_version: room_version_id!("7") }
355 );
356 }
357}