nf 0.1.0

use crate::mnl::attr::Attribute;
use crate::mnl::ALIGN;
use crate::tp;
use libc::{c_void, fileno, fprintf, isatty, FILE};
use std::ptr::{copy_nonoverlapping, write_bytes};

/// Represents a netlink message container
///
/// This structure provides a view of a netlink message, containing
/// both the header pointer and the data buffer.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct Message {
    /// Pointer to the netlink message header
    pub hdr: *mut Header,
    /// Pointer to the message data buffer
    pub data: *mut u8,
    /// Length of the message in bytes
    pub len: usize,
}

/// Represents a netlink message header
///
/// All netlink messages start with this header which defines
/// the message length, type, flags, sequence number, and port ID.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct Header {
    /// Total message length including header
    pub len: u32,
    /// Message content type
    pub type_: u16,
    /// Additional message flags
    pub flags: u16,
    /// Sequence number
    pub seq: u32,
    /// Sender port ID
    pub pid: u32,
}

/// Represents a batch of netlink messages
///
/// Used to efficiently send multiple netlink messages in a single buffer.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(C)]
pub struct Batch {
    /// The buffer used to store the batch messages
    pub buf: *mut u8,
    /// Maximum size of the buffer
    pub limit: usize,
    /// Current used length of the buffer
    pub buflen: usize,
    /// Pointer to the current netlink message in the batch
    pub cur: *mut u8,
    /// Flag indicating if the batch buffer has overflowed
    pub overflow: bool,
}

impl Message {
    /// Flag for request messages
    pub const REQUEST: u32 = 1; /* It is request message. */
    /// Flag for multipart messages (terminated by NLMSG_DONE)
    pub const MULTI: u32 = 2; /* Multipart message, terminated by NLMSG_DONE */
    /// Flag for reply with acknowledgment
    pub const ACK: u32 = 4; /* Reply with ack, with zero or error code */
    /// Flag to request echo of the message
    pub const ECHO: u32 = 8; /* Echo this request */
    /// Flag indicating dump was interrupted due to sequence change
    pub const DUMP_INTR: u32 = 16; /* Dump was inconsistent due to sequence change */

    /* Modifiers to GET request */
    /// Specifies tree root for GET requests
    pub const ROOT: u32 = 0x100; /* specify tree root */
    /// Returns all matching items for GET requests
    pub const MATCH: u32 = 0x200; /* return all matching */
    /// Requests atomic GET operation
    pub const ATOMIC: u32 = 0x400; /* atomic GET */
    /// Combination of ROOT and MATCH flags for dump operations
    pub const DUMP: u32 = Self::ROOT | Self::MATCH;

    /* Modifiers to NEW request */
    /// Override existing object if it exists
    pub const REPLACE: u32 = 0x100; /* Override existing */
    /// Don't touch object if it already exists
    pub const EXCLUDE: u32 = 0x200; /* Do not touch, if it exists */
    /// Create object if it doesn't exist
    pub const CREATE: u32 = 0x400; /* Create, if it does not exist */
    /// Add to end of list
    pub const APPEND: u32 = 0x800; /* Add to end of list */

    /// Alignment boundary for netlink messages
    pub const ALIGNTO: u32 = 4;
    /* Netlink message types */
    /// No operation message
    pub const NOOP: u16 = 0x1; /* Nothing. */
    /// Error message
    pub const ERROR: u16 = 0x2; /* Error */
    /// End of dump marker
    pub const DONE: u16 = 0x3; /* End of a dump */
    /// Data overflow indicator
    pub const OVERRUN: u16 = 0x4; /* Data lost */
    /// Minimum user-defined message type
    pub const MIN_TYPE: u16 = 0x10; /* < 0x10: reserved control messages */
    /// Size of the netlink message header, aligned
    pub const HDRLEN: usize = ALIGN(size_of::<Header>());

    /// Calculates the total message length including header
    ///
    /// # Parameters
    /// * `len` - Length of the payload
    ///
    /// # Returns
    /// Total message length including header
    #[inline]
    pub const fn len(len: usize) -> usize {
        len + Self::HDRLEN
    }

    /// Calculates the aligned space needed for this message
    ///
    /// # Returns
    /// The aligned message size
    #[inline]
    pub fn space(&self) -> usize {
        ALIGN(self.len)
    }

    /// Gets a pointer to the message data (payload)
    ///
    /// # Parameters
    /// * `nlh` - Pointer to the netlink header
    ///
    /// # Returns
    /// Pointer to the message payload
    #[inline]
    pub fn data(nlh: *const Header) -> *mut u8 {
        unsafe { (nlh as *const u8).add(Self::HDRLEN) as *mut u8 }
    }

    /// Gets the next message in a sequence
    ///
    /// Updates internal pointers and counters.
    ///
    /// # Returns
    /// Pointer to the next message header
    #[inline]
    pub fn next(&mut self) -> *const Header {
        let len = unsafe { (*self.hdr).len };
        let aligned_len = ALIGN(len as usize);
        self.len -= aligned_len;
        unsafe { (self.hdr as *const u8).add(aligned_len) as *const Header }
    }

    /// Checks if the message structure is valid
    ///
    /// Verifies that the message header and length are consistent
    /// with the buffer size.
    ///
    /// # Returns
    /// `true` if the message is valid, `false` otherwise
    #[inline]
    pub fn is_ok(&self) -> bool {
        unsafe {
            self.len >= size_of::<Header>()
                && (*self.hdr).len >= size_of::<Header>() as u32
                && (*self.hdr).len as usize <= self.len
        }
    }

    /// Gets the payload length of the message
    ///
    /// # Returns
    /// Length of the message payload in bytes
    #[inline]
    pub fn payload(&self) -> u32 {
        unsafe { (*self.hdr).len - Self::HDRLEN as u32 }
    }
}

impl Header {
    /// Gets a const pointer to this header
    ///
    /// # Returns
    /// A const pointer to this header
    pub const fn as_ptr(&self) -> *const Self {
        self as *const Self
    }

    /// Gets a mutable pointer to this header
    ///
    /// # Returns
    /// A mutable pointer to this header
    pub const fn as_mut_ptr(&mut self) -> *mut Self {
        self as *mut Self
    }

    /// Aligns the header to the next message boundary
    ///
    /// # Parameters
    /// * `nlh` - Pointer to the netlink header
    ///
    /// # Returns
    /// Pointer to the next aligned header
    pub const fn align(nlh: *const Self) -> *const Self {
        unsafe { (nlh as *const u8).wrapping_add(ALIGN((*nlh).len as usize)) as *const Self }
    }

    /// Size of the netlink message header
    pub const HDRLEN: usize = size_of::<Self>();

    /// Calculates the size of a message including header
    ///
    /// # Parameters
    /// * `len` - Length of the payload
    ///
    /// # Returns
    /// Total message length including header
    pub const fn size(len: usize) -> usize {
        len + Self::HDRLEN
    }

    /// Gets the payload length of a message
    ///
    /// # Parameters
    /// * `nlh` - Pointer to the netlink header
    ///
    /// # Returns
    /// Length of the message payload in bytes
    pub const fn get_payload_len(nlh: *const Self) -> usize {
        unsafe { (*nlh).len as usize - Self::HDRLEN }
    }

    /// Initializes a new netlink message header
    ///
    /// # Parameters
    /// * `buf` - Pointer to the message buffer
    ///
    /// # Returns
    /// Pointer to the initialized header
    pub fn put_header(buf: *mut i8) -> *mut Self {
        unsafe {
            let len = ALIGN(size_of::<Self>()) as u32;
            let nlh = buf as *mut Self;
            write_bytes(buf, 0, len as usize);
            (*nlh).len = len;
            nlh
        }
    }

    /// Initializes an extra header for this message
    ///
    /// # Parameters
    /// * `size` - Size of the extra header
    ///
    /// # Returns
    /// Pointer to the extra header
    pub fn put_extra_header(&mut self, size: usize) -> *mut i8 {
        unsafe {
            let ptr = (self as *mut Self as *mut i8).add(self.len as usize);
            let len = ALIGN(size);
            write_bytes(ptr, 0, len);
            self.len += len as u32;
            ptr
        }
    }

    /// Gets a pointer to the message payload
    ///
    /// # Returns
    /// Pointer to the message payload
    pub fn get_payload(&self) -> *mut u8 {
        unsafe { (self as *const Self as *mut u8).add(Self::HDRLEN) }
    }

    /// Gets a pointer to the message payload at a specific offset
    ///
    /// # Parameters
    /// * `offset` - Offset into the payload
    ///
    /// # Returns
    /// Pointer to the payload at the specified offset
    pub fn get_payload_offset(&self, offset: usize) -> *mut u8 {
        unsafe { (self as *const Self as *mut u8).add(Self::HDRLEN + ALIGN(offset)) }
    }

    /// Checks if the message header is valid
    ///
    /// Verifies that the message header and length are consistent
    /// with the buffer size.
    ///
    /// # Parameters
    /// * `len` - Length of the buffer
    ///
    /// # Returns
    /// `true` if the message is valid, `false` otherwise
    pub fn is_ok(&self, len: i32) -> bool {
        if len < 0 {
            return false;
        }
        let ulen = len as usize;
        ulen >= size_of::<Self>()
            && self.len as usize >= size_of::<Self>()
            && self.len as usize <= ulen
    }

    /// Gets the next message in a sequence
    ///
    /// Updates internal pointers and counters.
    ///
    /// # Parameters
    /// * `len` - Pointer to the remaining buffer length
    ///
    /// # Returns
    /// Pointer to the next message header
    pub fn next(&self, len: &mut i32) -> &mut Self {
        unsafe {
            *len -= ALIGN(self.len as usize) as i32;
            (self as *const Self as *mut Self)
                .add(ALIGN(self.len as usize) / size_of::<Self>())
                .as_mut()
                .unwrap()
        }
    }

    /// Gets a pointer to the end of the message payload
    ///
    /// # Returns
    /// Pointer to the end of the message payload
    pub fn get_payload_tail(&self) -> *mut u8 {
        unsafe { (self as *const Self as *mut u8).add(self.len as usize) }
    }

    /// Checks if the sequence number matches
    ///
    /// # Parameters
    /// * `seq` - Sequence number to check
    ///
    /// # Returns
    /// `true` if the sequence numbers match, `false` otherwise
    pub fn seq_ok(&self, seq: u32) -> bool {
        if self.seq == 0 || seq == 0 {
            return true;
        }
        self.seq == seq
    }

    /// Checks if the port ID matches
    ///
    /// # Parameters
    /// * `portid` - Port ID to check
    ///
    /// # Returns
    /// `true` if the port IDs match, `false` otherwise
    pub fn portid_ok(&self, portid: u32) -> bool {
        if self.pid == 0 || portid == 0 {
            return true;
        }
        self.pid == portid
    }

    /// Prints the message header to a file
    ///
    /// # Parameters
    /// * `fd` - File descriptor to print to
    pub fn fprintf_header(&self, fd: *mut FILE) {
        unsafe {
            fprintf(fd, tp!("----------------\t------------------\n"));
            fprintf(fd, tp!("|  %.010u  |\t| message length |\n"), self.len);
            fprintf(
                fd,
                tp!("| %.05u | %c%c%c%c |\t|  type | flags  |\n"),
                self.type_ as u32,
                if (self.flags as u32 & Message::REQUEST) == Message::REQUEST {
                    'R'
                } else {
                    '-'
                },
                if (self.flags & Message::MULTI as u16) == Message::MULTI as u16 {
                    'M'
                } else {
                    '-'
                },
                if (self.flags & Message::ACK as u16) == Message::ACK as u16 {
                    'A'
                } else {
                    '-'
                },
                if (self.flags & Message::ECHO as u16) == Message::ECHO as u16 {
                    'E'
                } else {
                    '-'
                },
            );
            fprintf(fd, tp!("|  %.010u  |\t| sequence number|\n"), self.seq);
            fprintf(fd, tp!("|  %.010u  |\t|     port ID    |\n"), self.pid);
            fprintf(fd, tp!("----------------\t------------------\n"));
        }
    }

    /// Prints an attribute to a file
    ///
    /// # Parameters
    /// * `fd` - File descriptor to print to
    /// * `attr` - Attribute to print
    pub fn fprintf_attr_color(fd: *mut FILE, attr: *const Attribute) {
        unsafe {
            fprintf(
                fd,
                tp!("|%c[%d;%dm%.5u%c[%dm|%c[%d;%dm%c%c%c[%dm|%c[%d;%dm%.5u%c[%dm|\t"),
                27,
                1,
                31,
                (*attr).len as u32,
                27,
                0,
                27,
                1,
                32,
                if ((*attr).type_ & Attribute::NESTED as u16) == Attribute::NESTED as u16 {
                    'N'
                } else {
                    '-'
                },
                if ((*attr).type_ & Attribute::NET_BYTEORDER as u16)
                    == Attribute::NET_BYTEORDER as u16
                {
                    'B'
                } else {
                    '-'
                },
                27,
                0,
                27,
                1,
                34,
                ((*attr).type_ & Attribute::TYPE_MASK as u16) as u32,
                27,
                0,
            );
        }
    }

    /// Prints an attribute to a file in raw format
    ///
    /// # Parameters
    /// * `fd` - File descriptor to print to
    /// * `attr` - Attribute to print
    pub fn fprintf_attr_raw(fd: *mut FILE, attr: *const Attribute) {
        unsafe {
            fprintf(
                fd,
                tp!("|%.5u|%c%c|%.5u|\t"),
                (*attr).len as u32,
                if ((*attr).type_ & Attribute::NESTED as u16) == Attribute::NESTED as u16 {
                    'N'
                } else {
                    '-'
                },
                if ((*attr).type_ & Attribute::NET_BYTEORDER as u16)
                    == Attribute::NET_BYTEORDER as u16
                {
                    'B'
                } else {
                    '-'
                },
                ((*attr).type_ & Attribute::TYPE_MASK as u16) as u32,
            );
        }
    }

    /// Prints the message payload to a file
    ///
    /// # Parameters
    /// * `fd` - File descriptor to print to
    /// * `extra_header_size` - Size of any extra headers
    pub fn fprintf_payload(&self, fd: *mut FILE, mut extra_header_size: usize) {
        unsafe {
            const ANSI_SPACE: *mut i8 = 0x20 as *mut i8;
            let colorize = if let Ok(fdnum) = fileno(fd).try_into() {
                isatty(fdnum) != 0
            } else {
                false
            };

            let mut i = size_of::<Header>();
            let mut rem = 0;
            let base_ptr = self as *const Self as *const i8;

            while i < self.len as usize {
                let attr = base_ptr.add(i) as *const Attribute;
                let ba = [
                    base_ptr.add(i),
                    base_ptr.add(i + 1),
                    base_ptr.add(i + 2),
                    base_ptr.add(i + 3),
                ];

                // netlink control message
                if self.type_ < Message::MIN_TYPE {
                    fprintf(
                        fd,
                        tp!("| %.2x %.2x %.2x %.2x  |\t"),
                        0xff & *ba[0] as u32,
                        0xff & *ba[1] as u32,
                        0xff & *ba[2] as u32,
                        0xff & *ba[3] as u32,
                    );
                    fprintf(fd, tp!("|                |\n"));
                // special handling for the extra header
                } else if extra_header_size > 0 {
                    extra_header_size = extra_header_size.saturating_sub(4);
                    fprintf(
                        fd,
                        tp!("| %.2x %.2x %.2x %.2x  |\t"),
                        0xff & *ba[0] as u32,
                        0xff & *ba[1] as u32,
                        0xff & *ba[2] as u32,
                        0xff & *ba[3] as u32,
                    );
                    fprintf(fd, tp!("|  extra header  |\n"));
                // this seems like an attribute header
                } else if rem == 0 && ((*attr).type_ & Attribute::TYPE_MASK as u16) != 0 {
                    if colorize {
                        Self::fprintf_attr_color(fd, attr);
                    } else {
                        Self::fprintf_attr_raw(fd, attr);
                    }
                    fprintf(fd, tp!("|len |flags| type|\n"));

                    if ((*attr).type_ & Attribute::NESTED as u16) != Attribute::NESTED as u16 {
                        rem = (Attribute::align((*attr).len as usize) - size_of::<Attribute>())
                            as i32;
                    }
                // this is the attribute payload
                } else if rem > 0 {
                    rem -= 4;
                    fprintf(
                        fd,
                        tp!("| %.2x %.2x %.2x %.2x  |\t"),
                        0xff & *ba[0] as u32,
                        0xff & *ba[1] as u32,
                        0xff & *ba[2] as u32,
                        0xff & *ba[3] as u32,
                    );
                    fprintf(fd, tp!("|      data      |"));

                    let chars = ba.map(|ptr| {
                        let c = *ptr;
                        if c == 0 { *ANSI_SPACE } else { c }
                    });

                    fprintf(
                        fd,
                        tp!("\t %c %c %c %c\n"),
                        chars[0] as i32,
                        chars[1] as i32,
                        chars[2] as i32,
                        chars[3] as i32,
                    );
                }
                i += 4;
            }
            fprintf(fd, tp!("----------------\t------------------\n"));
        }
    }

    /// Prints the message to a file
    ///
    /// # Parameters
    /// * `fd` - File descriptor to print to
    /// * `len` - Pointer to the remaining buffer length
    /// * `extra_header_size` - Size of any extra headers
    pub fn fprintf(&mut self, fd: *mut FILE, len: &mut i32, extra_header_size: usize) {
        let mut current = self;
        let mut remaining = len;
        unsafe {
            while current.is_ok(*remaining) {
                current.fprintf_header(fd);
                current.fprintf_payload(fd, extra_header_size);
                current = current.next(remaining);
            }
        }
    }
}

impl Batch {
    /// Creates a new batch from a buffer
    ///
    /// # Parameters
    /// * `buf` - Pointer to the buffer
    /// * `limit` - Maximum size of the buffer
    ///
    /// # Returns
    /// A new batch instance
    pub fn new(buf: *mut u8, limit: usize) -> Self {
        Batch {
            buf,
            limit,
            buflen: 0,
            cur: buf,
            overflow: false,
        }
    }

    /// Gets a pointer to this batch
    ///
    /// # Returns
    /// A pointer to this batch
    pub fn as_ptr(&mut self) -> *mut Self {
        self as *mut Self
    }

    /// Gets a mutable pointer to this batch
    ///
    /// # Returns
    /// A mutable pointer to this batch
    pub fn as_mut_ptr(&mut self) -> *mut Self {
        self as *mut Self
    }

    /// Starts a new batch from a buffer
    ///
    /// # Parameters
    /// * `buf` - Pointer to the buffer
    /// * `limit` - Maximum size of the buffer
    ///
    /// # Returns
    /// A pointer to this batch
    pub fn start(&mut self, buf: *mut u8, limit: usize) -> *mut Self {
        self.buf = buf;
        self.limit = limit;
        self.buflen = 0;
        self.cur = buf;
        self.overflow = false;
        self.as_mut_ptr()
    }

    /// Stops the batch and frees the buffer
    pub fn stop(&mut self) {
        unsafe {
            libc::free(self.buf as *mut c_void);
        }
    }

    /// Moves to the next message in the batch
    ///
    /// # Returns
    /// `true` if the next message is valid, `false` otherwise
    pub fn next(&mut self) -> bool {
        unsafe {
            let nlh = self.cur as *mut Header;
            let next_size = (*nlh).len as usize;
            if self.buflen + next_size > self.limit {
                self.overflow = true;
                return false;
            }
            self.cur = self.buf.add(self.buflen);
            self.buflen += next_size;
            true
        }
    }

    /// Resets the batch to its initial state
    pub fn reset(&mut self) {
        unsafe {
            if self.overflow {
                let nlh = self.cur as *mut Header;
                let len = (*nlh).len as usize;
                copy_nonoverlapping(self.cur, self.buf, len);
                self.buflen = len;
                self.cur = self.buf;
                self.overflow = false;
            } else {
                self.buflen = 0;
                self.cur = self.buf;
            }
        }
    }

    /// Gets the size of the batch
    ///
    /// # Returns
    /// The size of the batch in bytes
    pub fn size(&self) -> usize {
        self.buflen
    }

    /// Gets a pointer to the head of the batch
    ///
    /// # Returns
    /// A pointer to the head of the batch
    pub fn head(&self) -> *mut u8 {
        self.buf
    }

    /// Gets a pointer to the current message in the batch
    ///
    /// # Returns
    /// A pointer to the current message in the batch
    pub fn current(&self) -> *mut u8 {
        self.cur
    }

    /// Checks if the batch is empty
    ///
    /// # Returns
    /// `true` if the batch is empty, `false` otherwise
    pub fn is_empty(&self) -> bool {
        self.buflen == 0
    }
}