General Upgrade, NEW: WebServers, Better Docs

host/src/error.rs

@@ -0,0 +1,88 @@
+use mtp_codec::{CommunicationType, CommunicationValue, DataType, DataValue, Version};
+use mtp_common::{CommunicationError, RejectionReason};
+use mtp_transport::Sender;
+use std::{error::Error, fmt};
+
+#[cfg(feature = "crypto")]
+pub(crate) fn random_client_id() -> u64 {
+    rand::random::<u64>() & mtp_codec::MAX_WIRE_ID
+}
+
+pub(crate) async fn send_rejection(sender: &Sender, reason: RejectionReason) {
+    let response = match &reason {
+        RejectionReason::BadVersion { supported_versions } => {
+            CommunicationValue::new(CommunicationType::ErrorBadVersion)
+                .add_typed_default(
+                    DataType::Version,
+                    DataValue::Str(supported_versions.join(",")),
+                )
+                .add_typed_default(DataType::ErrorMessage, DataValue::Str(reason.to_string()))
+        }
+        _ => CommunicationValue::new(CommunicationType::IdentificationResponse)
+            .add_typed_default(DataType::Connected, DataValue::BoolFalse)
+            .add_typed_default(DataType::ErrorMessage, DataValue::Str(reason.to_string())),
+    };
+    let _ = sender.send(&response).await;
+}
+
+pub(crate) async fn send_accepted(
+    sender: &Sender,
+    version: &Version,
+    assigned_id: Option<u64>,
+) -> Result<(), CommunicationError> {
+    let mut response = CommunicationValue::new(CommunicationType::IdentificationResponse)
+        .add_typed_default(DataType::Connected, DataValue::BoolTrue)
+        .add_typed_default(DataType::Version, DataValue::Str(version.to_string()));
+    if let Some(id) = assigned_id {
+        response = response.add_typed_default(DataType::Id, DataValue::UnsignedNumber(id as u128));
+    }
+    sender.send(&response).await?;
+    sender.finish_stream().await
+}
+
+pub(crate) fn extract_version(msg: &CommunicationValue) -> Option<Version> {
+    let value = msg.get_data(DataType::Version);
+    match value {
+        DataValue::Str(s) => Version::parse(s.as_str()),
+        _ => None,
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AcceptError {
+    Receive(CommunicationError),
+    MissingVersion,
+    UnsupportedVersion(Version),
+    AuthenticationFailed(String),
+    AuthenticationTimedOut,
+    Send(CommunicationError),
+}
+
+impl fmt::Display for AcceptError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Receive(error) => write!(f, "failed to receive opening message: {error}"),
+            Self::MissingVersion => write!(
+                f,
+                "opening message did not include a valid protocol version"
+            ),
+            Self::UnsupportedVersion(version) => {
+                write!(f, "unsupported protocol version: {version}")
+            }
+            Self::AuthenticationFailed(reason) => write!(f, "authentication failed: {reason}"),
+            Self::AuthenticationTimedOut => write!(f, "authentication handshake timed out"),
+            Self::Send(error) => write!(f, "failed to send handshake message: {error}"),
+        }
+    }
+}
+
+impl Error for AcceptError {}
+
+#[cfg(feature = "crypto")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AuthState {
+    Unauthenticated,
+    Pending,
+    Authenticated,
+    Failed,
+}