lcpfs 2026.1.102

// Copyright 2025 LunaOS Contributors
// SPDX-License-Identifier: Apache-2.0

//! NFS error types and status codes.
//!
//! This module defines NFSv4 error status codes as defined in RFC 7530.

use alloc::string::String;
use core::fmt;

// ═══════════════════════════════════════════════════════════════════════════════
// NFS STATUS CODES
// ═══════════════════════════════════════════════════════════════════════════════

/// NFSv4 status codes (RFC 7530).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum NfsStatus {
    /// No error.
    Ok = 0,
    /// Permission denied.
    Perm = 1,
    /// No such file or directory.
    Noent = 2,
    /// I/O error.
    Io = 5,
    /// No such device or address.
    Nxio = 6,
    /// Permission denied.
    Acces = 13,
    /// File exists.
    Exist = 17,
    /// Cross-device link.
    Xdev = 18,
    /// Not a directory.
    Notdir = 20,
    /// Is a directory.
    Isdir = 21,
    /// Invalid argument.
    Inval = 22,
    /// File too large.
    Fbig = 27,
    /// No space left on device.
    Nospc = 28,
    /// Read-only file system.
    Rofs = 30,
    /// Too many hard links.
    Mlink = 31,
    /// File name too long.
    Nametoolong = 63,
    /// Directory not empty.
    Notempty = 66,
    /// Disk quota exceeded.
    Dquot = 69,
    /// Stale file handle.
    Stale = 70,
    /// Remote I/O error.
    Remote = 71,

    // NFSv4 specific errors
    /// Bad file handle.
    Badhandle = 10001,
    /// Update synchronization mismatch.
    NotSync = 10002,
    /// READDIR cookie is stale.
    BadCookie = 10003,
    /// Operation not supported.
    Notsupp = 10004,
    /// Buffer or request is too small.
    Toosmall = 10005,
    /// An error occurred on the server which does not map to any RFC.
    Serverfault = 10006,
    /// Type not supported.
    Badtype = 10007,
    /// A delay occurred during the processing.
    Delay = 10008,
    /// The file is the same as the source.
    Same = 10009,
    /// Lock denied.
    Denied = 10010,
    /// The server has run out of a resource.
    Resource = 10011,
    /// An XDR decode error.
    Badxdr = 10036,
    /// Lock held by another.
    Locked = 10012,
    /// Lock grace period in effect.
    Grace = 10013,
    /// File lock range not supported.
    FhExpired = 10014,
    /// Share reservation conflict.
    ShareDenied = 10015,
    /// Wrong security flavor.
    Wrongsec = 10016,
    /// Client ID in use.
    ClidInuse = 10017,
    /// Operation moved to a different server.
    Moved = 10019,
    /// No matching grant for LOCKT.
    NoGrace = 10020,
    /// Reclaim outside of grace period.
    ReclaimBad = 10021,
    /// Reclaim conflict.
    ReclaimConflict = 10022,
    /// Request too big.
    ReqTooBig = 10023,
    /// Bad sequence number.
    BadSeqid = 10026,
    /// Not the same client.
    NotSame = 10027,
    /// Lock range is not supported.
    LockRange = 10028,
    /// Symlink too many levels.
    Symlink = 10029,
    /// Lease expired.
    Expired = 10035,
    /// Lock was not contested.
    LockNotsupp = 10043,
    /// Old state ID.
    OldStateid = 10024,
    /// Bad state ID.
    BadStateid = 10025,
    /// Admin revoked the state.
    AdminRevoked = 10047,
    /// Operation not in session.
    OpNotInSession = 10071,

    // NFSv4.1 specific
    /// Client must use BIND_CONN_TO_SESSION.
    ConnNotBoundToSession = 10055,
    /// Wrong credential.
    WrongCred = 10082,
    /// Wrong type.
    WrongType = 10083,
    /// Dir delegation unavailable.
    DirDelegUnavail = 10084,
    /// Reject.
    Reject = 10085,
    /// Return conflict.
    Returnconflict = 10086,
    /// Server ran out of deleg.
    DelegAlreadyWanted = 10087,
    /// Sequence position is bad.
    BadHighSlot = 10077,
    /// Retry.
    Retry = 10049,
    /// Server is null.
    SeqMisordered = 10063,
    /// Sequence false retry.
    SeqFalseRetry = 10076,

    /// No file handle.
    Nofilehandle = 10040,
    /// Bad session (NFSv4.1).
    BadSession = 10052,

    /// Unknown error.
    Unknown = 0xFFFFFFFF,
}

impl NfsStatus {
    /// Convert from raw u32.
    pub fn from_u32(v: u32) -> Self {
        match v {
            0 => Self::Ok,
            1 => Self::Perm,
            2 => Self::Noent,
            5 => Self::Io,
            6 => Self::Nxio,
            13 => Self::Acces,
            17 => Self::Exist,
            18 => Self::Xdev,
            20 => Self::Notdir,
            21 => Self::Isdir,
            22 => Self::Inval,
            27 => Self::Fbig,
            28 => Self::Nospc,
            30 => Self::Rofs,
            31 => Self::Mlink,
            63 => Self::Nametoolong,
            66 => Self::Notempty,
            69 => Self::Dquot,
            70 => Self::Stale,
            71 => Self::Remote,
            10001 => Self::Badhandle,
            10002 => Self::NotSync,
            10003 => Self::BadCookie,
            10004 => Self::Notsupp,
            10005 => Self::Toosmall,
            10006 => Self::Serverfault,
            10007 => Self::Badtype,
            10008 => Self::Delay,
            10009 => Self::Same,
            10010 => Self::Denied,
            10011 => Self::Resource,
            10012 => Self::Locked,
            10013 => Self::Grace,
            10014 => Self::FhExpired,
            10015 => Self::ShareDenied,
            10016 => Self::Wrongsec,
            10017 => Self::ClidInuse,
            10019 => Self::Moved,
            10020 => Self::NoGrace,
            10021 => Self::ReclaimBad,
            10022 => Self::ReclaimConflict,
            10023 => Self::ReqTooBig,
            10024 => Self::OldStateid,
            10025 => Self::BadStateid,
            10026 => Self::BadSeqid,
            10027 => Self::NotSame,
            10028 => Self::LockRange,
            10029 => Self::Symlink,
            10035 => Self::Expired,
            10036 => Self::Badxdr,
            10043 => Self::LockNotsupp,
            10047 => Self::AdminRevoked,
            10049 => Self::Retry,
            10055 => Self::ConnNotBoundToSession,
            10063 => Self::SeqMisordered,
            10071 => Self::OpNotInSession,
            10076 => Self::SeqFalseRetry,
            10077 => Self::BadHighSlot,
            10082 => Self::WrongCred,
            10083 => Self::WrongType,
            10084 => Self::DirDelegUnavail,
            10085 => Self::Reject,
            10086 => Self::Returnconflict,
            10087 => Self::DelegAlreadyWanted,
            10040 => Self::Nofilehandle,
            10052 => Self::BadSession,
            _ => Self::Unknown,
        }
    }

    /// Get the numeric status code.
    pub fn code(&self) -> u32 {
        *self as u32
    }

    /// Check if this is a success status.
    pub fn is_ok(&self) -> bool {
        matches!(self, Self::Ok)
    }

    /// Check if this is an error status.
    pub fn is_err(&self) -> bool {
        !self.is_ok()
    }

    /// Get a human-readable message for the status.
    pub fn message(&self) -> &'static str {
        match self {
            Self::Ok => "No error",
            Self::Perm => "Permission denied",
            Self::Noent => "No such file or directory",
            Self::Io => "I/O error",
            Self::Nxio => "No such device or address",
            Self::Acces => "Permission denied",
            Self::Exist => "File exists",
            Self::Xdev => "Cross-device link",
            Self::Notdir => "Not a directory",
            Self::Isdir => "Is a directory",
            Self::Inval => "Invalid argument",
            Self::Fbig => "File too large",
            Self::Nospc => "No space left on device",
            Self::Rofs => "Read-only file system",
            Self::Mlink => "Too many hard links",
            Self::Nametoolong => "File name too long",
            Self::Notempty => "Directory not empty",
            Self::Dquot => "Disk quota exceeded",
            Self::Stale => "Stale file handle",
            Self::Remote => "Remote I/O error",
            Self::Badhandle => "Bad file handle",
            Self::NotSync => "Update synchronization mismatch",
            Self::BadCookie => "READDIR cookie is stale",
            Self::Notsupp => "Operation not supported",
            Self::Toosmall => "Buffer or request is too small",
            Self::Serverfault => "Server fault",
            Self::Badtype => "Type not supported",
            Self::Delay => "Delay occurred during processing",
            Self::Same => "File is the same as source",
            Self::Denied => "Lock denied",
            Self::Resource => "Server ran out of resources",
            Self::Badxdr => "XDR decode error",
            Self::Locked => "Lock held by another",
            Self::Grace => "Lock grace period in effect",
            Self::FhExpired => "File handle expired",
            Self::ShareDenied => "Share reservation conflict",
            Self::Wrongsec => "Wrong security flavor",
            Self::ClidInuse => "Client ID in use",
            Self::Moved => "Operation moved to different server",
            Self::NoGrace => "No matching grant for LOCKT",
            Self::ReclaimBad => "Reclaim outside of grace period",
            Self::ReclaimConflict => "Reclaim conflict",
            Self::ReqTooBig => "Request too big",
            Self::BadSeqid => "Bad sequence number",
            Self::NotSame => "Not the same client",
            Self::LockRange => "Lock range not supported",
            Self::Symlink => "Symlink too many levels",
            Self::Expired => "Lease expired",
            Self::LockNotsupp => "Lock not supported",
            Self::OldStateid => "Old state ID",
            Self::BadStateid => "Bad state ID",
            Self::AdminRevoked => "Admin revoked the state",
            Self::OpNotInSession => "Operation not in session",
            Self::ConnNotBoundToSession => "Connection not bound to session",
            Self::WrongCred => "Wrong credential",
            Self::WrongType => "Wrong type",
            Self::DirDelegUnavail => "Dir delegation unavailable",
            Self::Reject => "Reject",
            Self::Returnconflict => "Return conflict",
            Self::DelegAlreadyWanted => "Delegation already wanted",
            Self::BadHighSlot => "Bad high slot",
            Self::Retry => "Retry",
            Self::SeqMisordered => "Sequence misordered",
            Self::SeqFalseRetry => "Sequence false retry",
            Self::Nofilehandle => "No file handle",
            Self::BadSession => "Bad session",
            Self::Unknown => "Unknown error",
        }
    }
}

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

// ═══════════════════════════════════════════════════════════════════════════════
// NFS ERROR TYPE
// ═══════════════════════════════════════════════════════════════════════════════

/// NFS error with status and optional message.
#[derive(Debug, Clone)]
pub struct NfsError {
    /// Status code.
    pub status: NfsStatus,
    /// Optional detail message.
    pub message: Option<String>,
}

impl NfsError {
    /// Create a new error.
    pub fn new(status: NfsStatus) -> Self {
        Self {
            status,
            message: None,
        }
    }

    /// Create an error with a message.
    pub fn with_message(status: NfsStatus, msg: impl Into<String>) -> Self {
        Self {
            status,
            message: Some(msg.into()),
        }
    }

    // Convenience constructors for common errors

    /// Permission denied.
    pub fn perm() -> Self {
        Self::new(NfsStatus::Perm)
    }

    /// No such file or directory.
    pub fn noent() -> Self {
        Self::new(NfsStatus::Noent)
    }

    /// I/O error.
    pub fn io() -> Self {
        Self::new(NfsStatus::Io)
    }

    /// Access denied.
    pub fn access() -> Self {
        Self::new(NfsStatus::Acces)
    }

    /// File exists.
    pub fn exist() -> Self {
        Self::new(NfsStatus::Exist)
    }

    /// Not a directory.
    pub fn notdir() -> Self {
        Self::new(NfsStatus::Notdir)
    }

    /// Is a directory.
    pub fn isdir() -> Self {
        Self::new(NfsStatus::Isdir)
    }

    /// Invalid argument.
    pub fn inval() -> Self {
        Self::new(NfsStatus::Inval)
    }

    /// No space left.
    pub fn nospc() -> Self {
        Self::new(NfsStatus::Nospc)
    }

    /// Read-only file system.
    pub fn rofs() -> Self {
        Self::new(NfsStatus::Rofs)
    }

    /// Name too long.
    pub fn nametoolong() -> Self {
        Self::new(NfsStatus::Nametoolong)
    }

    /// Directory not empty.
    pub fn notempty() -> Self {
        Self::new(NfsStatus::Notempty)
    }

    /// Stale file handle.
    pub fn stale() -> Self {
        Self::new(NfsStatus::Stale)
    }

    /// Bad file handle.
    pub fn badhandle() -> Self {
        Self::new(NfsStatus::Badhandle)
    }

    /// Operation not supported.
    pub fn notsupp() -> Self {
        Self::new(NfsStatus::Notsupp)
    }

    /// Server fault.
    pub fn serverfault() -> Self {
        Self::new(NfsStatus::Serverfault)
    }

    /// Bad XDR.
    pub fn badxdr() -> Self {
        Self::new(NfsStatus::Badxdr)
    }

    /// Locked.
    pub fn locked() -> Self {
        Self::new(NfsStatus::Locked)
    }

    /// Bad state ID.
    pub fn bad_stateid() -> Self {
        Self::new(NfsStatus::BadStateid)
    }

    /// Get the status code.
    pub fn code(&self) -> u32 {
        self.status.code()
    }
}

impl fmt::Display for NfsError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(ref msg) = self.message {
            write!(
                f,
                "NFS error {}: {} ({})",
                self.status.code(),
                self.status.message(),
                msg
            )
        } else {
            write!(
                f,
                "NFS error {}: {}",
                self.status.code(),
                self.status.message()
            )
        }
    }
}

impl From<NfsStatus> for NfsError {
    fn from(status: NfsStatus) -> Self {
        Self::new(status)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// RESULT TYPE
// ═══════════════════════════════════════════════════════════════════════════════

/// Result type for NFS operations.
pub type NfsResult<T> = core::result::Result<T, NfsError>;

// ═══════════════════════════════════════════════════════════════════════════════
// TESTS
// ═══════════════════════════════════════════════════════════════════════════════

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_nfs_status_from_u32() {
        assert_eq!(NfsStatus::from_u32(0), NfsStatus::Ok);
        assert_eq!(NfsStatus::from_u32(2), NfsStatus::Noent);
        assert_eq!(NfsStatus::from_u32(10001), NfsStatus::Badhandle);
        assert_eq!(NfsStatus::from_u32(99999), NfsStatus::Unknown);
    }

    #[test]
    fn test_nfs_status_code() {
        assert_eq!(NfsStatus::Ok.code(), 0);
        assert_eq!(NfsStatus::Noent.code(), 2);
        assert_eq!(NfsStatus::Badhandle.code(), 10001);
    }

    #[test]
    fn test_nfs_status_is_ok() {
        assert!(NfsStatus::Ok.is_ok());
        assert!(!NfsStatus::Noent.is_ok());
        assert!(NfsStatus::Noent.is_err());
    }

    #[test]
    fn test_nfs_status_message() {
        assert_eq!(NfsStatus::Ok.message(), "No error");
        assert_eq!(NfsStatus::Noent.message(), "No such file or directory");
    }

    #[test]
    fn test_nfs_error_creation() {
        let err = NfsError::new(NfsStatus::Noent);
        assert_eq!(err.status, NfsStatus::Noent);
        assert!(err.message.is_none());

        let err2 = NfsError::with_message(NfsStatus::Io, "disk failure");
        assert_eq!(err2.status, NfsStatus::Io);
        assert_eq!(err2.message, Some("disk failure".into()));
    }

    #[test]
    fn test_nfs_error_convenience() {
        assert_eq!(NfsError::noent().status, NfsStatus::Noent);
        assert_eq!(NfsError::stale().status, NfsStatus::Stale);
        assert_eq!(NfsError::inval().status, NfsStatus::Inval);
    }

    #[test]
    fn test_nfs_error_from_status() {
        let err: NfsError = NfsStatus::Perm.into();
        assert_eq!(err.status, NfsStatus::Perm);
    }

    #[test]
    fn test_nfs_error_display() {
        let err = NfsError::new(NfsStatus::Noent);
        let msg = alloc::format!("{}", err);
        assert!(msg.contains("No such file or directory"));

        let err2 = NfsError::with_message(NfsStatus::Io, "disk read failed");
        let msg2 = alloc::format!("{}", err2);
        assert!(msg2.contains("disk read failed"));
    }
}