Struct Scanner 

pub struct Scanner {
    pub if_index: u32,
    pub if_name: String,
    pub src_mac: String,
    pub dst_mac: String,
    pub src_ip: IpAddr,
    pub src_port: u16,
    pub probe_targets: Vec<ProbeTarget>,
    pub probe_types: Vec<ProbeType>,
    pub timeout: Duration,
    pub wait_time: Duration,
    pub send_rate: Duration,
    pub probe_results: Vec<ProbeResult>,
}

Available on crate feature os only.

Struct for fingerprint probe

Example

fn main() -> Result<(), String> {
#[cfg(feature = "os")]
{
    use e_libscanner::os;
    use e_libscanner::Opts;
    // more command information use: -h
    let mut scanner = Opts::new(Some(&[
        "e-libscanner",
        "--ips",
        "192.168.80.8",
        "192.168.80.1",
        "--ports",
        "80",
        "135",
        "554",
        "8000",
        "22",
        "--model",
        "os",
        "--no-gui",
        "--",
        "-AS",
    ]))?
    .init()?
    .downcast::<os::Scanner>()
    .unwrap();
    let results = scanner.scan(None);
    for result in results {
        println!("{}", result.ip_addr);
        println!("{:?}", result.icmp_echo_result);
        println!("{:?}", result.icmp_timestamp_result);
        println!("{:?}", result.icmp_address_mask_result);
        println!("{:?}", result.icmp_information_result);
        println!("{:?}", result.icmp_unreachable_ip_result);
        println!("{:?}", result.icmp_unreachable_data_result);
        println!("{:?}", result.tcp_syn_ack_result);
        println!("{:?}", result.tcp_rst_ack_result);
        println!("{:?}", result.tcp_ecn_result);
        println!("{:?}", result.tcp_header_result);
        println!();
    }
    Ok(())
}
}

Fields

if_index: u32

Index of network interface

if_name: String

Name of network interface

src_mac: String

Source MAC Address

dst_mac: String

Destination MAC Address (Gateway)

src_ip: IpAddr

Source IP Address

src_port: u16

Source port

probe_targets: Vec<ProbeTarget>

Probe Targets

probe_types: Vec<ProbeType>

Probe Types

timeout: Duration

Timeout setting

wait_time: Duration

Wait time after send task is finished

send_rate: Duration

Packet send rate

probe_results: Vec<ProbeResult>

Result of probes

Implementations

impl Scanner

pub fn new(src_ip: IpAddr) -> Result<Scanner, String>

Create new fingerprinter with interfece IP

pub fn new_with_gateway_ip( src_ip: IpAddr, gateway_ip: IpAddr, ) -> Result<Scanner, String>

Create new fingerprinter with interfece IP and gateway IP

pub fn len(&self) -> usize

get scan count

pub fn set_method(&mut self, cmd: &Vec<String>) -> Result<(), String>

Set method

pub fn set_src_port(&mut self, src_port: u16)

Set source port number

pub fn add_probe_target(&mut self, dst_info: ProbeTarget)

Add probe target (IP address and tcp/udp port)

pub fn set_probe_targets(&mut self, probe_targets: Vec<ProbeTarget>)

Set probe targets

pub fn add_probe_type(&mut self, probe_type: ProbeType)

Add probe type

pub fn set_probe_types(&mut self, probe_types: Vec<ProbeType>)

Set probe types

pub fn set_full_probe(&mut self)

Set all probe types

pub fn set_timeout(&mut self, timeout: Duration)

Set probe timeout

pub fn set_wait_time(&mut self, wait_time: Duration)

Set wait-time after the sending task is completed

pub fn set_send_rate(&mut self, send_rate: Duration)

Set packet send rate

pub fn get_probe_results(&self) -> Vec<ProbeResult>

Get probe result

pub fn run_scan(&mut self)

Run probe with the current settings

pub fn scan(&mut self, _pstop: Option<Arc<Mutex<bool>>>) -> Vec<ProbeResult>

Run probe and return result

Trait Implementations

impl Debug for Scanner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.