Struct Scanner 

pub struct Scanner {

    pub if_index: u32,
    pub if_name: String,
    pub src_mac: [u8; 6],
    pub dst_mac: [u8; 6],
    pub src_ip: IpAddr,
    pub src_port: u16,
    pub destinations: Vec<Destination>,
    pub scan_type: ScanType,
    pub timeout: Duration,
    pub wait_time: Duration,
    pub send_rate: Duration,
    pub scan_result: ScanResult,
    pub tx: Arc<Mutex<Sender<SocketAddr>>>,
    pub rx: Arc<Mutex<Receiver<SocketAddr>>>,
}

Available on crate feature sync only.

Host Scanner

Example

fn main() -> Result<(), String> {
#[cfg(feature = "sync")]
{
    use e_libscanner::sync_scan;
    use e_libscanner::Opts;
    use std::thread;
    // more command information use: -h
    let mut scanner = Opts::new(Some(&[
        "e-libscanner",
        "--ips",
        "192.168.1.0/24",
        "192.168.2-3.1-10",
        "baidu.com",
        "--model",
        "sync",
        "--scan",
        "Icmp",
        "--no-gui",
        "--",
        "-AS",
    ]))?
    .init()?
    .downcast::<sync_scan::Scanner>()
    .unwrap();
    let rx = scanner.get_progress_receiver();
    // Run scan
    let handle = thread::spawn(move || scanner.scan(None));
    // Print progress
    while let Ok(socket_addr) = rx.lock().unwrap().recv() {
        println!("Check: {}", socket_addr);
    }
    let result = handle.join().unwrap();
    // Print results
    println!("Status: {:?}", result.scan_status);
    println!("UP Hosts:");
    let len = result.ips.len();
    for host in result.ips {
        println!("{:?}", host);
    }
    println!("Scan Time: {:?} count[ {} ]", result.scan_time, len);
}
Ok(())
}

Fields

if_index: u32

Index of network interface

if_name: String

Name of network interface

src_mac: [u8; 6]

MAC address of network interface

dst_mac: [u8; 6]

MAC address of default gateway(or scan target host)

src_ip: IpAddr

Source IP address

src_port: u16

Source port

destinations: Vec<Destination>

Destinations

scan_type: ScanType

Scan Type

timeout: Duration

Timeout setting for entire scan task

wait_time: Duration

Waiting time after packet sending task is completed

send_rate: Duration

Packet sending interval(0 for unlimited)

scan_result: ScanResult

Scan Result

tx: Arc<Mutex<Sender<SocketAddr>>>

Sender for progress messaging

rx: Arc<Mutex<Receiver<SocketAddr>>>

Receiver for progress messaging

Implementations

impl Scanner

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

Create new HostScanner with source IP address

Initialized with default value based on the specified IP address

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_ip(&mut self, src_ip: IpAddr)

Set source IP address

pub fn get_src_ip(&self) -> IpAddr

Get source IP address

pub fn add_destination(&mut self, dst: Destination)

Add Destination

pub fn set_destinations(&mut self, dst: Vec<Destination>)

Set Destinations

pub fn get_destinations(&self) -> Vec<Destination>

Get Destinations

pub fn set_scan_type(&mut self, scan_type: ScanType)

Set ScanType

pub fn get_scan_type(&self) -> ScanType

Get ScanType

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

Set timeout

pub fn get_timeout(&self) -> Duration

Get timeout

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

Set wait time

pub fn get_wait_time(&self) -> Duration

Get wait time

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

Set send rate

pub fn get_send_rate(&self) -> Duration

Get send rate

pub fn get_scan_result(&self) -> ScanResult

Get scan result

pub fn get_progress_receiver(&self) -> Arc<Mutex<Receiver<SocketAddr>>>

Get progress receiver

pub fn run_scan(&mut self, pstop: Option<Arc<Mutex<bool>>>)

Run Scan

pub fn scan(&mut self, pstop: Option<Arc<Mutex<bool>>>) -> ScanResult

Run Sync scan and return result

Trait Implementations

impl Clone for Scanner

fn clone(&self) -> Scanner

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scanner

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

Formats the value using the given formatter.