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

use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{Arc, Mutex};
use crate::option::PacketCaptureOptions;
use crate::packet::PacketFrame;
use crate::pcap::start_capture;

/// Listner
#[derive(Debug)]
pub struct Listner {
    pub options: PacketCaptureOptions,
    pub tx: Arc<Mutex<Sender<PacketFrame>>>,
    pub rx: Arc<Mutex<Receiver<PacketFrame>>>,
    pub stop: Arc<Mutex<bool>>,
    pub packets: Arc<Mutex<Vec<PacketFrame>>>,
}

impl Listner {
    /// Create new Listner
    pub fn new(options: PacketCaptureOptions) -> Listner {
        let (tx, rx) = channel();
        let listener: Listner = Listner {
            options: options,
            tx: Arc::new(Mutex::new(tx)),
            rx: Arc::new(Mutex::new(rx)),
            stop: Arc::new(Mutex::new(false)),
            packets: Arc::new(Mutex::new(Vec::new())),
        };
        listener
    }

    /// Get progress receiver
    pub fn get_receiver(&self) -> Arc<Mutex<Receiver<PacketFrame>>> {
        self.rx.clone()
    }
    
    /// Get stop handle
    pub fn get_stop_handle(&self) -> Arc<Mutex<bool>> {
        self.stop.clone()
    }

    // Get packets
    pub fn get_packets(&self) -> Vec<PacketFrame> {
        self.packets.lock().unwrap().clone()
    }
    
    /// Start capture
    pub fn start(&self) {
        let options = self.options.clone();
        let packets: Vec<PacketFrame> = start_capture(options, &self.tx, &self.stop);
        for packet in packets {
            self.packets.lock().unwrap().push(packet);
        }
    }
}