rscamper 0.2.2

Rust interface to scamper network measurement tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

// rscamper - Rust wrapper for scamper list/cycle metadata
//
// 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::fmt;
use std::time::{Duration, UNIX_EPOCH, SystemTime};

use crate::ffi::scamper_list::{self, ScamperListT, ScamperCycleT};

/// Represents metadata for a scamper measurement list.
pub struct ScamperList {
    inner: *mut ScamperListT,
}

impl ScamperList {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperListT) -> Option<Self> {
        if ptr.is_null() {
            return None;
        }
        let ptr = unsafe { scamper_list::scamper_list_use(ptr) };
        Some(ScamperList { inner: ptr })
    }

    /// Return the list ID.
    pub fn id(&self) -> u32 {
        unsafe { scamper_list::scamper_list_id_get(self.inner) }
    }

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

    /// Return the list description.
    pub fn descr(&self) -> Option<&str> {
        let ptr = unsafe { scamper_list::scamper_list_descr_get(self.inner) };
        if ptr.is_null() {
            None
        } else {
            Some(unsafe { CStr::from_ptr(ptr) }.to_str().unwrap_or(""))
        }
    }

    /// Return the monitor string.
    pub fn monitor(&self) -> Option<&str> {
        let ptr = unsafe { scamper_list::scamper_list_monitor_get(self.inner) };
        if ptr.is_null() {
            None
        } else {
            Some(unsafe { CStr::from_ptr(ptr) }.to_str().unwrap_or(""))
        }
    }
}

impl Drop for ScamperList {
    fn drop(&mut self) {
        unsafe { scamper_list::scamper_list_free(self.inner) };
    }
}

impl Clone for ScamperList {
    fn clone(&self) -> Self {
        let ptr = unsafe { scamper_list::scamper_list_use(self.inner) };
        ScamperList { inner: ptr }
    }
}

impl PartialEq for ScamperList {
    fn eq(&self, other: &Self) -> bool {
        unsafe { scamper_list::scamper_list_cmp(self.inner, other.inner) == 0 }
    }
}

impl Eq for ScamperList {}

impl fmt::Debug for ScamperList {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ScamperList")
            .field("id", &self.id())
            .field("name", &self.name())
            .finish()
    }
}

unsafe impl Send for ScamperList {}
unsafe impl Sync for ScamperList {}

/// Represents a measurement cycle within a list.
pub struct ScamperCycle {
    inner: *mut ScamperCycleT,
}

impl ScamperCycle {
    pub(crate) unsafe fn from_ptr(ptr: *mut ScamperCycleT) -> Option<Self> {
        if ptr.is_null() {
            return None;
        }
        let ptr = unsafe { scamper_list::scamper_cycle_use(ptr) };
        Some(ScamperCycle { inner: ptr })
    }

    pub(crate) fn as_ptr(&self) -> *mut ScamperCycleT {
        self.inner
    }

    /// Return the cycle ID.
    pub fn id(&self) -> u32 {
        unsafe { scamper_list::scamper_cycle_id_get(self.inner) }
    }

    /// Return the cycle start time.
    pub fn start(&self) -> SystemTime {
        let t = unsafe { scamper_list::scamper_cycle_start_time_get(self.inner) };
        UNIX_EPOCH + Duration::from_secs(t as u64)
    }

    /// Return the cycle stop time.
    pub fn stop(&self) -> SystemTime {
        let t = unsafe { scamper_list::scamper_cycle_stop_time_get(self.inner) };
        UNIX_EPOCH + Duration::from_secs(t as u64)
    }

    /// Return the hostname.
    pub fn hostname(&self) -> Option<&str> {
        let ptr = unsafe { scamper_list::scamper_cycle_hostname_get(self.inner) };
        if ptr.is_null() {
            None
        } else {
            Some(unsafe { CStr::from_ptr(ptr) }.to_str().unwrap_or(""))
        }
    }

    /// Return the list associated with this cycle.
    pub fn list(&self) -> Option<ScamperList> {
        let ptr = unsafe { scamper_list::scamper_cycle_list_get(self.inner) };
        unsafe { ScamperList::from_ptr(ptr) }
    }
}

impl Drop for ScamperCycle {
    fn drop(&mut self) {
        unsafe { scamper_list::scamper_cycle_free(self.inner) };
    }
}

impl Clone for ScamperCycle {
    fn clone(&self) -> Self {
        let ptr = unsafe { scamper_list::scamper_cycle_use(self.inner) };
        ScamperCycle { inner: ptr }
    }
}

impl fmt::Debug for ScamperCycle {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ScamperCycle")
            .field("id", &self.id())
            .finish()
    }
}

unsafe impl Send for ScamperCycle {}
unsafe impl Sync for ScamperCycle {}