Struct netscan_os::Fingerprinter

pub struct Fingerprinter {
    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>,
}

Struct for fingerprint probe

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 Fingerprinter

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

Create new fingerprinter with interfece IP

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

Create new fingerprinter with interfece IP and gateway IP

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_probe(&mut self)

Run probe with the current settings

pub fn probe(&mut self) -> Vec<ProbeResult>

Run probe and return result