rscamper 0.2.2

// rscamper - Rust wrapper for scamper load-balancing traceroute results
//
// Copyright (C) 2026 Dimitrios Giakatos
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 3.

use std::ffi::CStr;
use std::time::{Duration, UNIX_EPOCH, SystemTime};

use crate::addr::ScamperAddr;
use crate::icmpext::ScamperIcmpExts;
use crate::list::{ScamperList, ScamperCycle};
use crate::ffi::scamper_tracelb::{self, ScamperTracelbT, ScamperTracelbNodeT,
    ScamperTracelbLinkT, ScamperTracelbProbeT, ScamperTracelbReplyT,
    ScamperTracelbProbesetT, ScamperTracelbProbesetSummaryT};

fn timeval_to_duration(tv: *const libc::timeval) -> Option<Duration> {
    if tv.is_null() { return None; }
    let tv = unsafe { &*tv };
    Some(Duration::new(tv.tv_sec as u64, tv.tv_usec as u32 * 1000))
}

fn timeval_to_systemtime(tv: *const libc::timeval) -> Option<SystemTime> {
    timeval_to_duration(tv).map(|d| UNIX_EPOCH + d)
}

/// A reply in a load-balancing traceroute probe.
pub struct ScamperTracelbReply {
    inner: *mut ScamperTracelbReplyT,
}

impl ScamperTracelbReply {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperTracelbReplyT) -> Option<Self> {
        if ptr.is_null() { return None; }
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_reply_use(ptr) };
        Some(ScamperTracelbReply { inner: ptr })
    }

    pub fn from_addr(&self) -> Option<ScamperAddr> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_reply_from_get(self.inner) };
        unsafe { ScamperAddr::from_ptr(ptr) }
    }

    pub fn rx(&self) -> Option<SystemTime> {
        let tv = unsafe { scamper_tracelb::scamper_tracelb_reply_rx_get(self.inner) };
        timeval_to_systemtime(tv)
    }

    pub fn ttl(&self) -> u8 {
        unsafe { scamper_tracelb::scamper_tracelb_reply_ttl_get(self.inner) }
    }

    pub fn ipid(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_reply_ipid_get(self.inner) }
    }

    pub fn is_icmp(&self) -> bool {
        unsafe { scamper_tracelb::scamper_tracelb_reply_is_icmp(self.inner) != 0 }
    }

    pub fn is_icmp_ttl_exp(&self) -> bool {
        unsafe { scamper_tracelb::scamper_tracelb_reply_is_icmp_ttl_exp(self.inner) != 0 }
    }

    pub fn is_tcp(&self) -> bool {
        unsafe { scamper_tracelb::scamper_tracelb_reply_is_tcp(self.inner) != 0 }
    }

    pub fn icmp_exts(&self) -> Option<ScamperIcmpExts> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_reply_icmp_exts_get(self.inner) };
        unsafe { ScamperIcmpExts::from_ptr(ptr) }
    }
}

impl Drop for ScamperTracelbReply {
    fn drop(&mut self) {
        unsafe { scamper_tracelb::scamper_tracelb_reply_free(self.inner) };
    }
}

unsafe impl Send for ScamperTracelbReply {}
unsafe impl Sync for ScamperTracelbReply {}

/// A probe in a load-balancing traceroute.
pub struct ScamperTracelbProbe {
    inner: *mut ScamperTracelbProbeT,
}

impl ScamperTracelbProbe {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperTracelbProbeT) -> Option<Self> {
        if ptr.is_null() { return None; }
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_probe_use(ptr) };
        Some(ScamperTracelbProbe { inner: ptr })
    }

    pub fn tx(&self) -> Option<SystemTime> {
        let tv = unsafe { scamper_tracelb::scamper_tracelb_probe_tx_get(self.inner) };
        timeval_to_systemtime(tv)
    }

    pub fn flowid(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_probe_flowid_get(self.inner) }
    }

    pub fn ttl(&self) -> u8 {
        unsafe { scamper_tracelb::scamper_tracelb_probe_ttl_get(self.inner) }
    }

    pub fn attempt(&self) -> u8 {
        unsafe { scamper_tracelb::scamper_tracelb_probe_attempt_get(self.inner) }
    }

    pub fn rxc(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_probe_rxc_get(self.inner) }
    }

    pub fn rx(&self, i: u16) -> Option<ScamperTracelbReply> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_probe_rx_get(self.inner, i) };
        unsafe { ScamperTracelbReply::from_ptr(ptr) }
    }
}

impl Drop for ScamperTracelbProbe {
    fn drop(&mut self) {
        unsafe { scamper_tracelb::scamper_tracelb_probe_free(self.inner) };
    }
}

unsafe impl Send for ScamperTracelbProbe {}
unsafe impl Sync for ScamperTracelbProbe {}

/// A probeset in a load-balancing traceroute.
pub struct ScamperTracelbProbeset {
    inner: *mut ScamperTracelbProbesetT,
}

impl ScamperTracelbProbeset {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperTracelbProbesetT) -> Option<Self> {
        if ptr.is_null() { return None; }
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_probeset_use(ptr) };
        Some(ScamperTracelbProbeset { inner: ptr })
    }

    pub fn probec(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_probeset_probec_get(self.inner) }
    }

    pub fn probe(&self, i: u16) -> Option<ScamperTracelbProbe> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_probeset_probe_get(self.inner, i) };
        unsafe { ScamperTracelbProbe::from_ptr(ptr) }
    }

    pub fn summary(&self) -> Option<ScamperTracelbProbesetSummary> {
        let ptr = unsafe {
            scamper_tracelb::scamper_tracelb_probeset_summary_alloc(self.inner)
        };
        if ptr.is_null() { None } else { Some(ScamperTracelbProbesetSummary { inner: ptr }) }
    }
}

impl Drop for ScamperTracelbProbeset {
    fn drop(&mut self) {
        unsafe { scamper_tracelb::scamper_tracelb_probeset_free(self.inner) };
    }
}

unsafe impl Send for ScamperTracelbProbeset {}
unsafe impl Sync for ScamperTracelbProbeset {}

/// Summary of a probeset.
pub struct ScamperTracelbProbesetSummary {
    inner: *mut ScamperTracelbProbesetSummaryT,
}

impl ScamperTracelbProbesetSummary {
    pub fn addrc(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_probeset_summary_addrc_get(self.inner) }
    }

    pub fn addr(&self, i: u16) -> Option<ScamperAddr> {
        let ptr = unsafe {
            scamper_tracelb::scamper_tracelb_probeset_summary_addr_get(self.inner, i)
        };
        unsafe { ScamperAddr::from_ptr(ptr) }
    }

    pub fn nullc(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_probeset_summary_nullc_get(self.inner) }
    }
}

impl Drop for ScamperTracelbProbesetSummary {
    fn drop(&mut self) {
        unsafe { scamper_tracelb::scamper_tracelb_probeset_summary_free(self.inner) };
    }
}

unsafe impl Send for ScamperTracelbProbesetSummary {}
unsafe impl Sync for ScamperTracelbProbesetSummary {}

/// A node in the load-balancing traceroute graph.
pub struct ScamperTracelbNode {
    inner: *mut ScamperTracelbNodeT,
}

impl ScamperTracelbNode {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperTracelbNodeT) -> Option<Self> {
        if ptr.is_null() { return None; }
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_node_use(ptr) };
        Some(ScamperTracelbNode { inner: ptr })
    }

    pub fn addr(&self) -> Option<ScamperAddr> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_node_addr_get(self.inner) };
        unsafe { ScamperAddr::from_ptr(ptr) }
    }

    pub fn name(&self) -> Option<&str> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_node_name_get(self.inner) };
        if ptr.is_null() { None } else {
            Some(unsafe { CStr::from_ptr(ptr) }.to_str().unwrap_or(""))
        }
    }

    pub fn q_ttl(&self) -> u8 {
        unsafe { scamper_tracelb::scamper_tracelb_node_q_ttl_get(self.inner) }
    }

    pub fn flags(&self) -> u32 {
        unsafe { scamper_tracelb::scamper_tracelb_node_flags_get(self.inner) }
    }

    pub fn linkc(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_node_linkc_get(self.inner) }
    }

    pub fn link(&self, i: u16) -> Option<ScamperTracelbLink> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_node_link_get(self.inner, i) };
        unsafe { ScamperTracelbLink::from_ptr(ptr) }
    }

    pub fn is_q_ttl(&self) -> bool {
        unsafe { scamper_tracelb::scamper_tracelb_node_is_q_ttl(self.inner) != 0 }
    }
}

impl Drop for ScamperTracelbNode {
    fn drop(&mut self) {
        unsafe { scamper_tracelb::scamper_tracelb_node_free(self.inner) };
    }
}

unsafe impl Send for ScamperTracelbNode {}
unsafe impl Sync for ScamperTracelbNode {}

/// A directed link between two nodes in the load-balancing traceroute graph.
pub struct ScamperTracelbLink {
    inner: *mut ScamperTracelbLinkT,
}

impl ScamperTracelbLink {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperTracelbLinkT) -> Option<Self> {
        if ptr.is_null() { return None; }
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_link_use(ptr) };
        Some(ScamperTracelbLink { inner: ptr })
    }

    pub fn from_node(&self) -> Option<ScamperTracelbNode> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_link_from_get(self.inner) };
        unsafe { ScamperTracelbNode::from_ptr(ptr) }
    }

    pub fn to_node(&self) -> Option<ScamperTracelbNode> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_link_to_get(self.inner) };
        unsafe { ScamperTracelbNode::from_ptr(ptr) }
    }

    pub fn hopc(&self) -> u8 {
        unsafe { scamper_tracelb::scamper_tracelb_link_hopc_get(self.inner) }
    }

    pub fn probeset(&self, hop: u8) -> Option<ScamperTracelbProbeset> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_link_probeset_get(self.inner, hop) };
        unsafe { ScamperTracelbProbeset::from_ptr(ptr) }
    }
}

impl Drop for ScamperTracelbLink {
    fn drop(&mut self) {
        unsafe { scamper_tracelb::scamper_tracelb_link_free(self.inner) };
    }
}

unsafe impl Send for ScamperTracelbLink {}
unsafe impl Sync for ScamperTracelbLink {}

/// A scamper load-balancing traceroute measurement result.
pub struct ScamperTracelb {
    pub(crate) inner: *mut ScamperTracelbT,
}

impl ScamperTracelb {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperTracelbT) -> Option<Self> {
        if ptr.is_null() { return None; }
        Some(ScamperTracelb { inner: ptr })
    }

    pub fn src(&self) -> Option<ScamperAddr> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_src_get(self.inner) };
        unsafe { ScamperAddr::from_ptr(ptr) }
    }

    pub fn dst(&self) -> Option<ScamperAddr> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_dst_get(self.inner) };
        unsafe { ScamperAddr::from_ptr(ptr) }
    }

    pub fn userid(&self) -> u32 {
        unsafe { scamper_tracelb::scamper_tracelb_userid_get(self.inner) }
    }

    pub fn start(&self) -> Option<SystemTime> {
        let tv = unsafe { scamper_tracelb::scamper_tracelb_start_get(self.inner) };
        timeval_to_systemtime(tv)
    }

    pub fn sport(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_sport_get(self.inner) }
    }

    pub fn dport(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_dport_get(self.inner) }
    }

    pub fn nodec(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_nodec_get(self.inner) }
    }

    pub fn node(&self, i: u16) -> Option<ScamperTracelbNode> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_node_get(self.inner, i) };
        unsafe { ScamperTracelbNode::from_ptr(ptr) }
    }

    pub fn linkc(&self) -> u16 {
        unsafe { scamper_tracelb::scamper_tracelb_linkc_get(self.inner) }
    }

    pub fn link(&self, i: u16) -> Option<ScamperTracelbLink> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_link_get(self.inner, i) };
        unsafe { ScamperTracelbLink::from_ptr(ptr) }
    }

    pub fn probec(&self) -> u32 {
        unsafe { scamper_tracelb::scamper_tracelb_probec_get(self.inner) }
    }

    pub fn errmsg(&self) -> Option<&str> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_errmsg_get(self.inner) };
        if ptr.is_null() { None } else {
            Some(unsafe { CStr::from_ptr(ptr) }.to_str().unwrap_or(""))
        }
    }

    pub fn is_type_udp(&self) -> bool {
        unsafe { scamper_tracelb::scamper_tracelb_type_is_udp(self.inner) != 0 }
    }

    pub fn is_type_tcp(&self) -> bool {
        unsafe { scamper_tracelb::scamper_tracelb_type_is_tcp(self.inner) != 0 }
    }

    pub fn is_type_icmp(&self) -> bool {
        unsafe { scamper_tracelb::scamper_tracelb_type_is_icmp(self.inner) != 0 }
    }

    pub fn list(&self) -> Option<ScamperList> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_list_get(self.inner) };
        unsafe { ScamperList::from_ptr(ptr) }
    }

    pub fn cycle(&self) -> Option<ScamperCycle> {
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_cycle_get(self.inner) };
        unsafe { ScamperCycle::from_ptr(ptr) }
    }

    /// Convert to JSON string.
    pub fn to_json(&self) -> Option<String> {
        let mut len = 0usize;
        let ptr = unsafe { scamper_tracelb::scamper_tracelb_tojson(self.inner, &mut len) };
        if ptr.is_null() { return None; }
        let s = unsafe { CStr::from_ptr(ptr) }.to_string_lossy().into_owned();
        unsafe { libc::free(ptr as *mut libc::c_void) };
        Some(s)
    }
}

impl Drop for ScamperTracelb {
    fn drop(&mut self) {
        unsafe { scamper_tracelb::scamper_tracelb_free(self.inner) };
    }
}

unsafe impl Send for ScamperTracelb {}
unsafe impl Sync for ScamperTracelb {}