Missing npcap message prompt

This commit is contained in:
Wiktor Mazur
2019-11-11 16:54:41 +01:00
parent b0c8340b9f
commit ea72a56a20
8 changed files with 135 additions and 59 deletions
+7 -1
View File
@@ -8,4 +8,10 @@ edition = "2018"
[dependencies] [dependencies]
pnet = "0.22.0" pnet = "0.22.0"
log = { version = "0.4", features = ["std"] } log = { version = "0.4", features = ["std"] }
[profile.dev]
panic = "unwind"
[profile.release]
panic = "unwind"
+69 -29
View File
@@ -1,9 +1,9 @@
extern crate pnet; extern crate pnet;
use std::sync::{Arc, Mutex};
use std::net::IpAddr; use std::net::IpAddr;
use std::panic;
use std::sync::mpsc::Sender; use std::sync::mpsc::Sender;
use std::sync::{Arc, Mutex};
use std::thread; use std::thread;
use pnet::datalink::{self, NetworkInterface}; use pnet::datalink::{self, NetworkInterface};
@@ -25,23 +25,32 @@ pub struct UdpPacket {
pub destination_address: IpAddr, pub destination_address: IpAddr,
pub destination_port: u16, pub destination_port: u16,
pub length: u16, pub length: u16,
pub payload: Vec<u8> pub payload: Vec<u8>,
} }
pub fn receive(tx: Sender<UdpPacket>) { pub type NetworkInterfaces = Vec<pnet::datalink::NetworkInterface>;
pub fn network_interfaces() -> Result<NetworkInterfaces, &'static str> {
let result = panic::catch_unwind(|| {
datalink::interfaces()
.into_iter()
.filter(|i| !i.is_loopback())
.collect::<NetworkInterfaces>()
});
match result {
Ok(interfaces) => Ok(interfaces),
Err(_) => Err("Unable to get interface list"),
}
}
pub fn receive(interfaces: NetworkInterfaces, tx: Sender<UdpPacket>) {
let shared_tx = Arc::new(Mutex::new(tx)); let shared_tx = Arc::new(Mutex::new(tx));
use pnet::datalink::Channel::Ethernet;
let interfaces = datalink::interfaces()
.into_iter()
.filter(|i| !i.is_loopback());
info!("Found interfaces: {:?}", interfaces); info!("Found interfaces: {:?}", interfaces);
for interface in interfaces { for interface in interfaces {
let tx = shared_tx.clone(); let tx = shared_tx.clone();
let config = pnet::datalink::Config{ let config = pnet::datalink::Config {
write_buffer_size: 65536, write_buffer_size: 65536,
read_buffer_size: 65536, read_buffer_size: 65536,
..Default::default() ..Default::default()
@@ -49,15 +58,15 @@ pub fn receive(tx: Sender<UdpPacket>) {
// Create a channel to receive on // Create a channel to receive on
let (_, mut rx) = match datalink::channel(&interface, config) { let (_, mut rx) = match datalink::channel(&interface, config) {
Ok(Ethernet(tx, rx)) => (tx, rx), Ok(pnet::datalink::Channel::Ethernet(tx, rx)) => (tx, rx),
Ok(_) => { Ok(_) => {
warn!("packetdump: unhandled channel type"); warn!("packetdump: unhandled channel type");
continue; continue;
}, }
Err(e) => { Err(e) => {
warn!("packetdump: unable to create channel: {}", e); warn!("packetdump: unable to create channel: {}", e);
continue; continue;
}, }
}; };
thread::spawn(move || { thread::spawn(move || {
@@ -79,18 +88,30 @@ pub fn receive(tx: Sender<UdpPacket>) {
fake_ethernet_frame.set_source(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_ethertype(EtherTypes::Ipv4);
fake_ethernet_frame.set_payload(&packet); fake_ethernet_frame.set_payload(&packet);
handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx); handle_ethernet_frame(
&interface,
&fake_ethernet_frame.to_immutable(),
&tx,
);
continue; continue;
} else if version == 6 { } else if version == 6 {
fake_ethernet_frame.set_destination(MacAddr(0, 0, 0, 0, 0, 0)); 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_source(MacAddr(0, 0, 0, 0, 0, 0));
fake_ethernet_frame.set_ethertype(EtherTypes::Ipv6); fake_ethernet_frame.set_ethertype(EtherTypes::Ipv6);
fake_ethernet_frame.set_payload(&packet); fake_ethernet_frame.set_payload(&packet);
handle_ethernet_frame(&interface, &fake_ethernet_frame.to_immutable(), &tx); handle_ethernet_frame(
&interface,
&fake_ethernet_frame.to_immutable(),
&tx,
);
continue; continue;
} }
} }
handle_ethernet_frame(&interface, &EthernetPacket::new(packet).unwrap(), &tx); handle_ethernet_frame(
&interface,
&EthernetPacket::new(packet).unwrap(),
&tx,
);
} }
Err(e) => warn!("packetdump: unable to receive packet: {}", e), Err(e) => warn!("packetdump: unable to receive packet: {}", e),
} }
@@ -99,7 +120,11 @@ pub fn receive(tx: Sender<UdpPacket>) {
} }
} }
fn handle_ethernet_frame(interface: &NetworkInterface, ethernet: &EthernetPacket, tx: &Arc<Mutex<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),
@@ -108,7 +133,11 @@ fn handle_ethernet_frame(interface: &NetworkInterface, ethernet: &EthernetPacket
} }
} }
fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<Mutex<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(
@@ -117,12 +146,16 @@ fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<
IpAddr::V4(header.get_destination()), IpAddr::V4(header.get_destination()),
header.get_next_level_protocol(), header.get_next_level_protocol(),
header.payload(), header.payload(),
&tx &tx,
); );
} }
} }
fn handle_ipv6_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<Mutex<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(
@@ -131,7 +164,7 @@ fn handle_ipv6_packet(interface_name: &str, ethernet: &EthernetPacket, tx: &Arc<
IpAddr::V6(header.get_destination()), IpAddr::V6(header.get_destination()),
header.get_next_header(), header.get_next_header(),
header.payload(), header.payload(),
&tx &tx,
); );
} }
} }
@@ -142,7 +175,7 @@ fn handle_transport_protocol(
destination: IpAddr, destination: IpAddr,
protocol: IpNextHeaderProtocol, protocol: IpNextHeaderProtocol,
packet: &[u8], packet: &[u8],
tx: &Arc<Mutex<Sender<UdpPacket>>> tx: &Arc<Mutex<Sender<UdpPacket>>>,
) { ) {
match protocol { match protocol {
IpNextHeaderProtocols::Udp => { IpNextHeaderProtocols::Udp => {
@@ -152,18 +185,25 @@ fn handle_transport_protocol(
} }
} }
fn handle_udp_packet(interface_name: &str, source: IpAddr, destination: IpAddr, packet: &[u8], tx: &Arc<Mutex<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(); 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),
source_address: source, source_address: source,
source_port: udp.get_source(), source_port: udp.get_source(),
destination_address: destination, destination_address: destination,
destination_port: udp.get_destination(), destination_port: udp.get_destination(),
length: udp.get_length(), length: udp.get_length(),
payload: Vec::from(udp.payload()) payload: Vec::from(udp.payload()),
}).unwrap(); })
.unwrap();
} }
} }
+27 -18
View File
@@ -25,6 +25,10 @@ pub use meter::PlayerStatisticsVec;
pub use meter::StatType; pub use meter::StatType;
pub enum InitializationError {
NetworkInterfaceListMissing
}
lazy_static! { lazy_static! {
static ref METER: Mutex<meter::Meter> = Mutex::new(meter::Meter::new()); static ref METER: Mutex<meter::Meter> = Mutex::new(meter::Meter::new());
} }
@@ -66,7 +70,7 @@ pub fn get_players_in_party(meter: &meter::Meter) -> Vec<String> {
meter.get_players_in_party().unwrap_or(vec![]) meter.get_players_in_party().unwrap_or(vec![])
} }
pub fn initialize() -> Arc<Mutex<meter::Meter>> { pub fn initialize() -> Result<Arc<Mutex<meter::Meter>>, InitializationError> {
CombinedLogger::init(vec![WriteLogger::new( CombinedLogger::init(vec![WriteLogger::new(
LevelFilter::Info, LevelFilter::Info,
Config::default(), Config::default(),
@@ -78,28 +82,33 @@ pub fn initialize() -> Arc<Mutex<meter::Meter>> {
let meter = Arc::new(Mutex::new(meter)); let meter = Arc::new(Mutex::new(meter));
let cloned_meter = meter.clone(); let cloned_meter = meter.clone();
thread::spawn(move || {
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
let mut photon = Photon::new(); if let Ok(interfaces) = packet_sniffer::network_interfaces() {
thread::spawn(move || {
let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
packet_sniffer::receive(tx); let mut photon = Photon::new();
info!("Listening to network packets...");
loop { packet_sniffer::receive(interfaces, tx);
if let Ok(packet) = rx.recv() { info!("Listening to network packets...");
if packet.destination_port != 5056 && packet.source_port != 5056 { loop {
continue; if let Ok(packet) = rx.recv() {
} if packet.destination_port != 5056 && packet.source_port != 5056 {
if let Ok(ref mut meter) = cloned_meter.lock() { continue;
let game_messages = photon.decode(&packet.payload) }
.into_iter().filter_map(into_game_message).collect(); if let Ok(ref mut meter) = cloned_meter.lock() {
register_messages(meter, &game_messages); let game_messages = photon.decode(&packet.payload)
.into_iter().filter_map(into_game_message).collect();
register_messages(meter, &game_messages);
}
} }
} }
} });
}); } else {
return Err(InitializationError::NetworkInterfaceListMissing);
}
meter Ok(meter)
} }
pub fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_protocol::Message>) { pub fn register_messages(meter: &mut meter::Meter, messages: &Vec<game_protocol::Message>) {
+6 -1
View File
@@ -22,6 +22,7 @@ use cpython::FromPyObject;
use cpython::PyDict; use cpython::PyDict;
use crate::core::StatType; use crate::core::StatType;
use crate::core::InitializationError;
struct PyMeter struct PyMeter
@@ -150,7 +151,11 @@ pub fn get_players_in_party(py: Python) -> PyResult<PyList> {
fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult<u32> { fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult<u32> {
if let Ok(ref mut py_meter) = METER.lock() { if let Ok(ref mut py_meter) = METER.lock() {
py_meter.initialize(core::initialize()); match core::initialize() {
Ok(core_meter) => py_meter.initialize(core_meter),
Err(InitializationError::NetworkInterfaceListMissing) => return Ok(2)
};
if let Some(m) = py_meter.get() { if let Some(m) = py_meter.get() {
if let Ok(ref mut meter) = m.lock() { if let Ok(ref mut meter) = m.lock() {
meter.configure(core::MeterConfig { meter.configure(core::MeterConfig {
-6
View File
@@ -1,13 +1,7 @@
use std::fmt;
use std::sync::{Arc, Mutex};
#[cfg(test)] #[cfg(test)]
use fake_clock::FakeClock as Instant; use fake_clock::FakeClock as Instant;
#[cfg(not(test))] #[cfg(not(test))]
use std::time::Instant; use std::time::Instant;
use log::*;
use timer;
use super::traits::CombatState; use super::traits::CombatState;
use super::traits::DamageDealer; use super::traits::DamageDealer;
+13 -1
View File
@@ -10,13 +10,15 @@ from PySide2.QtWidgets import QMessageBox
from .config import config from .config import config
from .main import MainWidget from .main import MainWidget
from .engine import initialize from .engine import initialize
from .engine import InitializationResult
from .styling import style from .styling import style
from .version import current_version as get_current_version from .version import current_version as get_current_version
from .version import latest_version as get_latest_version from .version import latest_version as get_latest_version
from .version import latest_url from .version import latest_url
def run(): def run():
initialize() initialization_result = initialize()
conf = config() conf = config()
window_config = conf['window'] window_config = conf['window']
@@ -53,4 +55,14 @@ def run():
msg.setStandardButtons(QMessageBox.Ok) msg.setStandardButtons(QMessageBox.Ok)
msg.show() msg.show()
if initialization_result == InitializationResult.NetworkInterfaceListMissing:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setWindowTitle("Unable to track network traffic data!")
msg.setText("On windows make sure that WinPcap is installed in your system.")
msg.setInformativeText("WinPcap can be installed from <a href='{}'>here</a> <br> <b>Make sure to install with the \"Install Npcap in WinPcap API-compatible Mode\"<b> option"
.format('https://nmap.org/npcap/dist/npcap-0.9983.exe'))
msg.setStandardButtons(QMessageBox.Ok)
msg.show()
sys.exit(app.exec_()) sys.exit(app.exec_())
+12 -2
View File
@@ -14,6 +14,16 @@ class StatType:
Zone = 2 Zone = 2
Overall = 3 Overall = 3
class InitializationResult:
Ok = 0
UnknownFailure = 1
NetworkInterfaceListMissing = 2
INITIALIZATION_RESULT = {
0: InitializationResult.Ok,
1: InitializationResult.UnknownFailure,
2: InitializationResult.NetworkInterfaceListMissing
}
class DamageStat: class DamageStat:
def __init__(self, name, damage, time_in_combat, dps, percentage, best_damage): def __init__(self, name, damage, time_in_combat, dps, percentage, best_damage):
@@ -136,9 +146,9 @@ def reset_stats():
def initialize(): def initialize():
if TESTING_ENABLED: if TESTING_ENABLED:
return return InitializationResult.Ok
cfg = config() cfg = config()
try: try:
aostats.initialize(cfg['app']['skip_non_party_players']) return INITIALIZATION_RESULT[aostats.initialize(cfg['app']['skip_non_party_players'])]
except: except:
pass pass
+1 -1
View File
@@ -1,7 +1,7 @@
import os import os
import requests import requests
_version = "0.6.1" _version = "0.6.2"
latest_url = "https://github.com/mazurwiktor/albion-online-stats/releases/latest" latest_url = "https://github.com/mazurwiktor/albion-online-stats/releases/latest"