tpcpr/src/parser.rs

extern crate byteorder;
extern crate bitfield;
extern crate eui48;
mod packet_handler;
use pcap::Capture;
use eui48::MacAddress;
use std::net::{IpAddr, Ipv4Addr};
use std::str;

fn build_ether () -> packet_handler::EtherHeader {
    packet_handler::EtherHeader {
        ether_dhost: (MacAddress::new([0;6])).to_hex_string(),
        ether_shost: (MacAddress::new([0;6])).to_hex_string(),
        ether_type: 0, 
    }
}
 
fn build_ipv4 () -> packet_handler::IpV4Header  {
    packet_handler::IpV4Header {
    ip_version:                     0,
    ip_ihl:                         0,
    ip_dscp:                        0,
    ip_ecn:                         0,
    ip_total_length:                0,
    ip_identification:              0,
    ip_df:                          0,
    ip_mf:                          0,
    ip_fragment_offset:             0,
    ip_time_to_live:                0,
    ip_protocol:                    0,
    ip_header_checksum:             0,
    ip_source_address:              IpAddr::V4(Ipv4Addr::new(0,0,0,0)),
    ip_destination_address:         IpAddr::V4(Ipv4Addr::new(0,0,0,0)),
    }
}

fn build_tcp () -> packet_handler::TcpHeader {
    packet_handler::TcpHeader {
    source_port:          0,
    destination_port:     0,
    seq_num:              0,
    ack_num:              0,
    data_offset:          0,
    reserved:             0,
    ns:                   0,
    cwr:                  0,
    ece:                  0,
    urg:                  0,
    ack:                  0,
    psh:                  0,
    rst:                  0,
    syn:                  0,
    fin:                  0,    
    window_size:          0,
    checksum:             0,
    urgent_pointer:       0,
    }
} 

// TODO: wrap packet_handler types inside Option<T>
#[derive(Debug, Clone)]
pub struct QryData{ 
    pub id:                             i32,
    pub time:                           f64,
    pub data:                           Option<Vec<u8>>,
    pub ether_header:                   packet_handler::EtherHeader,
    pub ipv4_header:                    packet_handler::IpV4Header,
    pub tcp_header:                     packet_handler::TcpHeader,
}

pub fn parse (parse_file: &str, filter_str: &str) -> Vec<QryData> { 
        let ether_init = build_ether();
        let ipv4_init = build_ipv4();
        let tcp_init = build_tcp();

        let mut me = QryData {
            id: 0,
            time: 0.0,
            data: None,
            ether_header: ether_init,
            ipv4_header: ipv4_init,
            tcp_header: tcp_init,
        };
    let mut v: Vec<QryData> = Vec::new();

        //let mut cap = Capture::from_file("../target/wohnung2.pcapng").unwrap();
        let mut cap = Capture::from_file(parse_file).unwrap();
        //let filter_str: String = "tcp && !ip6".to_owned();
        //let filter_str: String = "tcp && ip dst 18.202.15.201".to_owned();
        //let filter_str: String = "tcp && ip dst 192.168.0.7".to_owned();
        //println!("{:?}", filter_str);
        Capture::filter(&mut cap, &filter_str).unwrap();

    while let Ok(packet) = cap.next() {
        me.time = (packet.header.ts.tv_usec as f64 / 1000000.0) + packet.header.ts.tv_sec as f64; 
        me.data = Some(packet.data.to_vec());  
        me.ether_header = packet_handler::ethernet_handler( packet.data );
        if  8 == me.ether_header.ether_type {
              me.ipv4_header = packet_handler::ip_handler( packet.data );
              if 6 == me.ipv4_header.ip_protocol {
                me.tcp_header = packet_handler::tcp_handler( me.ipv4_header.ip_ihl, packet.data );
                me.data= packet_handler::payload_handler( me.ipv4_header.ip_ihl, me.tcp_header.data_offset, packet.data);
              }

        }

        v.push(QryData{id:0, time:me.time, data: me.data, ether_header:me.ether_header, ipv4_header: me.ipv4_header, tcp_header: me.tcp_header});
        
    }
    v
}

pub fn parse_device (parse_device: &str, filter_str: &str, insert_max: &usize) -> Vec<QryData> { 
    let ether_init = build_ether();
    let ipv4_init = build_ipv4();
    let tcp_init = build_tcp();

    let mut me = QryData {
        id: 0,
        time: 0.0,
        data: None,
        ether_header: ether_init,
        ipv4_header: ipv4_init,
        tcp_header: tcp_init,
    };
    let mut v: Vec<QryData> = Vec::new();
    let mut cap = Capture::from_device(parse_device).unwrap().open().unwrap();
    Capture::filter(&mut cap, &filter_str).unwrap();
    
    'parse: while let Ok(packet) = cap.next(){
        me.time = (packet.header.ts.tv_usec as f64 / 1000000.0) + packet.header.ts.tv_sec as f64; 
        me.data = Some(packet.data.to_vec());  
        me.ether_header = packet_handler::ethernet_handler( packet.data );
        if  8 == me.ether_header.ether_type {
              me.ipv4_header = packet_handler::ip_handler( packet.data );
              if 6 == me.ipv4_header.ip_protocol {
                me.tcp_header = packet_handler::tcp_handler( me.ipv4_header.ip_ihl, packet.data );
                me.data= packet_handler::payload_handler( me.ipv4_header.ip_ihl, me.tcp_header.data_offset, packet.data);
              }

        }

        v.push(QryData{id:0, time:me.time, data: me.data, ether_header:me.ether_header, ipv4_header: me.ipv4_header, tcp_header: me.tcp_header});
        if &v.len() >= insert_max {
            break 'parse;
        }
    }
    v
}