services/mctp/api/src/error.rs

// Licensed under the Apache-2.0 license
// SPDX-License-Identifier: Apache-2.0

//! MCTP error types
//!
//! This module defines error types for MCTP operations, providing both
//! transport-level errors and higher-level service response codes.

use core::fmt;

/// Response codes from the MCTP service.
///
/// These codes indicate the result of an MCTP operation and are designed
/// to be compatible with IPC/RPC response handling.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum ResponseCode {
    /// Operation completed successfully.
    Success = 0,
    /// Internal server error.
    InternalError = 1,
    /// No space available (e.g., message buffers full).
    NoSpace = 2,
    /// Address/handle already in use.
    AddrInUse = 3,
    /// Operation timed out.
    TimedOut = 4,
    /// Invalid argument provided.
    BadArgument = 5,
    /// Server restarted, state lost.
    ServerRestarted = 6,
}

impl ResponseCode {
    /// Returns `true` if this represents a successful operation.
    #[inline]
    pub const fn is_success(self) -> bool {
        matches!(self, ResponseCode::Success)
    }

    /// Returns `true` if this represents an error condition.
    #[inline]
    pub const fn is_error(self) -> bool {
        !self.is_success()
    }

    /// Converts from a raw u8 value.
    pub const fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(ResponseCode::Success),
            1 => Some(ResponseCode::InternalError),
            2 => Some(ResponseCode::NoSpace),
            3 => Some(ResponseCode::AddrInUse),
            4 => Some(ResponseCode::TimedOut),
            5 => Some(ResponseCode::BadArgument),
            6 => Some(ResponseCode::ServerRestarted),
            _ => None,
        }
    }
}

impl fmt::Display for ResponseCode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ResponseCode::Success => write!(f, "success"),
            ResponseCode::InternalError => write!(f, "internal error"),
            ResponseCode::NoSpace => write!(f, "no space"),
            ResponseCode::AddrInUse => write!(f, "address in use"),
            ResponseCode::TimedOut => write!(f, "timed out"),
            ResponseCode::BadArgument => write!(f, "bad argument"),
            ResponseCode::ServerRestarted => write!(f, "server restarted"),
        }
    }
}

/// MCTP operation error.
///
/// This is the main error type returned by MCTP client operations.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MctpError {
    /// The response code from the service.
    pub code: ResponseCode,
}

impl MctpError {
    /// Creates a new error from a response code.
    pub const fn from_code(code: ResponseCode) -> Self {
        MctpError { code }
    }

    /// Returns `true` if this is a timeout error.
    #[inline]
    pub const fn is_timeout(&self) -> bool {
        matches!(self.code, ResponseCode::TimedOut)
    }
}

impl fmt::Display for MctpError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "MCTP error: {}", self.code)
    }
}

impl From<ResponseCode> for MctpError {
    fn from(code: ResponseCode) -> Self {
        MctpError::from_code(code)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    extern crate std;
    use std::string::ToString;

    #[test]
    fn response_code_is_success() {
        assert!(ResponseCode::Success.is_success());
        assert!(!ResponseCode::Success.is_error());
        for &code in &[
            ResponseCode::InternalError,
            ResponseCode::NoSpace,
            ResponseCode::AddrInUse,
            ResponseCode::TimedOut,
            ResponseCode::BadArgument,
            ResponseCode::ServerRestarted,
        ] {
            assert!(!code.is_success(), "{code:?} should not be success");
            assert!(code.is_error(), "{code:?} should be an error");
        }
    }

    #[test]
    fn response_code_from_u8_roundtrip() {
        for val in 0u8..=6 {
            let code = ResponseCode::from_u8(val).expect("known code");
            assert_eq!(code as u8, val);
        }
        assert_eq!(ResponseCode::from_u8(7), None);
        assert_eq!(ResponseCode::from_u8(255), None);
    }

    #[test]
    fn response_code_display() {
        assert_eq!(ResponseCode::Success.to_string(), "success");
        assert_eq!(ResponseCode::InternalError.to_string(), "internal error");
        assert_eq!(ResponseCode::NoSpace.to_string(), "no space");
        assert_eq!(ResponseCode::AddrInUse.to_string(), "address in use");
        assert_eq!(ResponseCode::TimedOut.to_string(), "timed out");
        assert_eq!(ResponseCode::BadArgument.to_string(), "bad argument");
        assert_eq!(
            ResponseCode::ServerRestarted.to_string(),
            "server restarted"
        );
    }

    #[test]
    fn mctp_error_is_timeout() {
        let e = MctpError::from_code(ResponseCode::TimedOut);
        assert!(e.is_timeout());
        let e2 = MctpError::from_code(ResponseCode::NoSpace);
        assert!(!e2.is_timeout());
    }

    #[test]
    fn mctp_error_display() {
        let e = MctpError::from_code(ResponseCode::BadArgument);
        assert_eq!(e.to_string(), "MCTP error: bad argument");
    }

    #[test]
    fn mctp_error_from_response_code() {
        let e: MctpError = ResponseCode::ServerRestarted.into();
        assert_eq!(e.code, ResponseCode::ServerRestarted);
    }
}