105 lines
4.0 KiB
Rust
105 lines
4.0 KiB
Rust
extern crate serde_json;
|
|
use crate::parser;
|
|
use rayon::prelude::*;
|
|
use serde::ser::{Serialize, SerializeStruct, Serializer};
|
|
use std::thread::{spawn, JoinHandle};
|
|
use std::thread;
|
|
use std::sync::mpsc::{channel, Receiver};
|
|
use serde_json::json;
|
|
|
|
impl Serialize for parser::QryData {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let mut state = serializer.serialize_struct("parser::QryData", 11)?;
|
|
state.serialize_field("time", &self.time)?;
|
|
state.serialize_field("ether_header.ether_dhost", &self.ether_header.ether_dhost.to_hex_string())?;
|
|
state.serialize_field("ether_header.ether_shost", &self.ether_header.ether_shost.to_hex_string())?;
|
|
state.serialize_field("ether_header.ether_type", &self.ether_header.ether_type)?;
|
|
state.serialize_field("ipv4_header", &self.ipv4_header)?;
|
|
state.serialize_field("ipv6_header", &self.ipv6_header)?;
|
|
state.serialize_field("tcp_header", &self.tcp_header)?;
|
|
state.serialize_field("udp_header", &self.udp_header)?;
|
|
state.serialize_field("arp_header", &self.arp_header)?;
|
|
state.serialize_field("data", &self.data)?;
|
|
state.serialize_field("reg_res", &self.reg_res)?;
|
|
state.end()
|
|
}
|
|
}
|
|
|
|
pub fn serialize_packets(v: Vec<parser::QryData>) -> Vec<serde_json::Value> {
|
|
|
|
/* rayon parallelized */
|
|
// TODO: Benchmark. As far as I tested, this reaps no benefit.
|
|
let packets_serialized = v.par_iter().map(|x| serde_json::to_value(x).unwrap()).collect();
|
|
//let packets_serialized: Vec<serde_json::Value> = v.par_iter().map(|x| json!(x)).collect();
|
|
|
|
packets_serialized
|
|
}
|
|
|
|
|
|
// This is way faster than serialize_packets() but I can not figure out how to properly select parts from the resulting json structure as an sql query
|
|
#[allow(dead_code)]
|
|
pub fn serialize_packets_as_string(v: Vec<parser::QryData>) -> Vec<serde_json::Value> {
|
|
let mut packets_serialized: Vec<serde_json::Value> = Vec::with_capacity(v.len() * 2);
|
|
for packet in v.iter() {
|
|
packets_serialized.push(serde_json::Value::String(serde_json::to_string(&packet).unwrap()));
|
|
}
|
|
|
|
packets_serialized
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn smallest_prime_divisor(remainder: usize ) -> usize {
|
|
let smallest_divisor: usize = (2..(remainder/2)).into_par_iter().find_first(|x| remainder % x == 0).unwrap();
|
|
smallest_divisor
|
|
}
|
|
#[allow(dead_code)]
|
|
//pub fn start_serialize_packets_thread(parsed_data: Receiver<parser::QryData>) -> (Receiver<serde_json::Value>, JoinHandle<()>) {
|
|
pub fn start_serialize_packets_thread(parsed_data: Receiver<parser::QryData>) -> (Receiver<serde_json::Value>, JoinHandle<()>) {
|
|
let (sender, receiver) = channel();
|
|
let handle = spawn ( move || {
|
|
for data in parsed_data {
|
|
//serde_json::Value::String(serde_json::to_string(&packet).unwrap())
|
|
if sender.send(serde_json::to_value(data).unwrap()).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
(receiver, handle)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn start_collect_serialized( serialized_data: Receiver<serde_json::Value> ) -> Vec<serde_json::Value> {
|
|
//let (sender, receiver) = channel();
|
|
let mut packets_serialized:Vec<serde_json::Value> = Vec::new();
|
|
for data in serialized_data {
|
|
packets_serialized.push(data);
|
|
}
|
|
|
|
packets_serialized
|
|
|
|
|
|
}
|
|
|
|
pub fn start_serialize_vec_thread(parsed_data: Receiver<Vec<parser::QryData>>) -> Receiver<serde_json::Value> {
|
|
let (sender, receiver) = channel();
|
|
for vec in parsed_data {
|
|
for packet in vec {
|
|
let sender = sender.clone();
|
|
let handle = spawn ( move || {
|
|
//sender.send(start_serialize_packets_thread(packet));
|
|
sender.send(json!(packet))
|
|
//sender.send( serde_json::to_value(packet).unwrap())
|
|
//serde_json::Value::String(serde_json::to_string(&packet).unwrap())
|
|
//if sender.send(serde_json::to_value(data).unwrap()).is_err() {
|
|
// break;
|
|
}
|
|
);}
|
|
//});
|
|
}
|
|
receiver
|
|
}
|