Listening to all interfaces

This commit is contained in:
Wiktor Mazur
2019-09-01 19:34:12 +02:00
parent cdac07c8c8
commit 09f0590fb6
+59 -63
View File
@@ -1,5 +1,7 @@
extern crate pnet; extern crate pnet;
use std::sync::{Arc, Mutex};
use std::net::IpAddr; use std::net::IpAddr;
use std::sync::mpsc::Sender; use std::sync::mpsc::Sender;
use std::thread; use std::thread;
@@ -25,75 +27,69 @@ pub struct UdpPacket {
} }
pub fn receive(tx: Sender<UdpPacket>) { pub fn receive(tx: Sender<UdpPacket>) {
let shared_tx = Arc::new(Mutex::new(tx));
use pnet::datalink::Channel::Ethernet; use pnet::datalink::Channel::Ethernet;
let up_interface = datalink::interfaces()
let interfaces = datalink::interfaces()
.into_iter() .into_iter()
.filter(|i| !i.is_loopback() && !i.is_up()) .filter(|i| !i.is_loopback());
.next();
let any_interface = datalink::interfaces() for interface in interfaces {
.into_iter() let tx = shared_tx.clone();
.filter(|i| !i.is_loopback()) let config = pnet::datalink::Config{
.next(); write_buffer_size: 65536,
read_buffer_size: 65536,
..Default::default()
};
let interface = if up_interface.is_some() { // Create a channel to receive on
up_interface.unwrap() let (_, mut rx) = match datalink::channel(&interface, config) {
} else { Ok(Ethernet(tx, rx)) => (tx, rx),
any_interface.unwrap() Ok(_) => panic!("packetdump: unhandled channel type: {}"),
}; Err(e) => panic!("packetdump: unable to create channel: {}", e),
};
let config = pnet::datalink::Config{ thread::spawn(move || {
write_buffer_size: 65536, loop {
read_buffer_size: 65536, let mut buf: [u8; 1600] = [0u8; 1600];
..Default::default() let mut fake_ethernet_frame = MutableEthernetPacket::new(&mut buf[..]).unwrap();
}; match rx.next() {
Ok(packet) => {
// Create a channel to receive on if cfg!(target_os = "macos")
let (_, mut rx) = match datalink::channel(&interface, config) { && interface.is_up()
Ok(Ethernet(tx, rx)) => (tx, rx), && !interface.is_broadcast()
Ok(_) => panic!("packetdump: unhandled channel type: {}"), && !interface.is_loopback()
Err(e) => panic!("packetdump: unable to create channel: {}", e), && interface.is_point_to_point()
}; {
// Maybe is TUN interface
thread::spawn(move || { let version = Ipv4Packet::new(&packet).unwrap().get_version();
loop { if version == 4 {
let mut buf: [u8; 1600] = [0u8; 1600]; fake_ethernet_frame.set_destination(MacAddr(0, 0, 0, 0, 0, 0));
let mut fake_ethernet_frame = MutableEthernetPacket::new(&mut buf[..]).unwrap(); fake_ethernet_frame.set_source(MacAddr(0, 0, 0, 0, 0, 0));
match rx.next() { fake_ethernet_frame.set_ethertype(EtherTypes::Ipv4);
Ok(packet) => { fake_ethernet_frame.set_payload(&packet);
if cfg!(target_os = "macos") handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx);
&& interface.is_up() continue;
&& !interface.is_broadcast() } else if version == 6 {
&& !interface.is_loopback() fake_ethernet_frame.set_destination(MacAddr(0, 0, 0, 0, 0, 0));
&& interface.is_point_to_point() fake_ethernet_frame.set_source(MacAddr(0, 0, 0, 0, 0, 0));
{ fake_ethernet_frame.set_ethertype(EtherTypes::Ipv6);
// Maybe is TUN interface fake_ethernet_frame.set_payload(&packet);
let version = Ipv4Packet::new(&packet).unwrap().get_version(); handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx);
if version == 4 { continue;
fake_ethernet_frame.set_destination(MacAddr(0, 0, 0, 0, 0, 0)); }
fake_ethernet_frame.set_source(MacAddr(0, 0, 0, 0, 0, 0));
fake_ethernet_frame.set_ethertype(EtherTypes::Ipv4);
fake_ethernet_frame.set_payload(&packet);
handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx);
continue;
} else if version == 6 {
fake_ethernet_frame.set_destination(MacAddr(0, 0, 0, 0, 0, 0));
fake_ethernet_frame.set_source(MacAddr(0, 0, 0, 0, 0, 0));
fake_ethernet_frame.set_ethertype(EtherTypes::Ipv6);
fake_ethernet_frame.set_payload(&packet);
handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx);
continue;
} }
handle_ethernet_frame(&interface, &EthernetPacket::new(packet).unwrap(), &tx);
} }
handle_ethernet_frame(&interface, &EthernetPacket::new(packet).unwrap(), &tx); Err(e) => panic!("packetdump: unable to receive packet: {}", e),
} }
Err(e) => panic!("packetdump: unable to receive packet: {}", e),
} }
} });
}); }
} }
fn handle_ethernet_frame(interface: &NetworkInterface, ethernet: &EthernetPacket, tx: &Sender<UdpPacket>) { fn handle_ethernet_frame(interface: &NetworkInterface, ethernet: &EthernetPacket, tx: &Arc<Mutex<Sender<UdpPacket>>>) {
let interface_name = &interface.name[..]; let interface_name = &interface.name[..];
match ethernet.get_ethertype() { match ethernet.get_ethertype() {
EtherTypes::Ipv4 => handle_ipv4_packet(interface_name, ethernet, &tx), EtherTypes::Ipv4 => handle_ipv4_packet(interface_name, ethernet, &tx),
@@ -102,7 +98,7 @@ fn handle_ethernet_frame(interface: &NetworkInterface, ethernet: &EthernetPacket
} }
} }
fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Sender<UdpPacket>) { fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<Mutex<Sender<UdpPacket>>>) {
let header = Ipv4Packet::new(ethernet.payload()); let header = Ipv4Packet::new(ethernet.payload());
if let Some(header) = header { if let Some(header) = header {
handle_transport_protocol( handle_transport_protocol(
@@ -116,7 +112,7 @@ fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Send
} }
} }
fn handle_ipv6_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Sender<UdpPacket>) { fn handle_ipv6_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<Mutex<Sender<UdpPacket>>>) {
let header = Ipv6Packet::new(ethernet.payload()); let header = Ipv6Packet::new(ethernet.payload());
if let Some(header) = header { if let Some(header) = header {
handle_transport_protocol( handle_transport_protocol(
@@ -136,7 +132,7 @@ fn handle_transport_protocol(
destination: IpAddr, destination: IpAddr,
protocol: IpNextHeaderProtocol, protocol: IpNextHeaderProtocol,
packet: &[u8], packet: &[u8],
tx: &Sender<UdpPacket> tx: &Arc<Mutex<Sender<UdpPacket>>>
) { ) {
match protocol { match protocol {
IpNextHeaderProtocols::Udp => { IpNextHeaderProtocols::Udp => {
@@ -146,9 +142,9 @@ fn handle_transport_protocol(
} }
} }
fn handle_udp_packet(interface_name: &str, source: IpAddr, destination: IpAddr, packet: &[u8], tx: &Sender<UdpPacket>) { fn handle_udp_packet(interface_name: &str, source: IpAddr, destination: IpAddr, packet: &[u8], tx: &Arc<Mutex<Sender<UdpPacket>>>) {
let udp = udp::UdpPacket::new(packet); let udp = udp::UdpPacket::new(packet);
let tx = tx.lock().unwrap();
if let Some(udp) = udp { if let Some(udp) = udp {
tx.send(UdpPacket{ tx.send(UdpPacket{
interface_name: String::from(interface_name), interface_name: String::from(interface_name),