feat: bump 1.7.0

Reviewed-on: #14

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ipblc"
-version = "1.6.6"
+version = "1.7.0"
 edition = "2021"
 authors = ["PaulBSD <paul@paulbsd.com>"]
 description = "ipblc is a tool that search and send attacking ip addresses to ipbl"
@@ -21,6 +21,7 @@ regex = "1.10"
 reqwest = { version = "0.11", default-features = false, features = ["json", "rustls-tls"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+sd-notify = { version = "0.4" }
 tokio = { version = "1.35", features = ["full", "sync"] }
 tungstenite = { version = "0.21", features = ["handshake", "rustls-tls-native-roots"] }
 

src/config.rs

@@ -103,12 +103,12 @@ impl Context {
             .send()
             .await;
         let req = match resp {
-            Ok(re) => re,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
         let data: Discovery = match req.json().await {
-            Ok(res) => res,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
         Ok(data)
     }
@@ -127,8 +127,8 @@ impl Context {
                     }
                     break;
                 }
-                Err(err) => {
-                    println!("error loading config: {err}, retrying in {CONFIG_RETRY_INTERVAL}s");
+                Err(e) => {
+                    println!("error loading config: {e}, retrying in {CONFIG_RETRY_INTERVAL}s");
                     last_in_err = true;
                     sleep_s(CONFIG_RETRY_INTERVAL).await;
                 }
@@ -169,39 +169,41 @@ impl Context {
     }
 
     pub async fn update_blocklist(&mut self, ipevent: &IpEvent) -> Option<IpEvent> {
-        let ipdata = &ipevent.ipdata.clone().unwrap();
-        match self.cfg.sets.get(&ipdata.src) {
-            Some(set) => {
-                let starttime = DateTime::parse_from_rfc3339(ipdata.date.as_str())
-                    .unwrap()
-                    .with_timezone(&chrono::Local);
-                let blocktime = set.blocktime;
-                if ipevent.mode == "file".to_string() && gethostname(true) == ipevent.hostname {
-                    let block =
+        match &ipevent.ipdata {
+            Some(ipdata) => match self.cfg.sets.get(&ipdata.src) {
+                Some(set) => {
+                    let starttime = DateTime::parse_from_rfc3339(ipdata.date.as_str())
+                        .unwrap()
+                        .with_timezone(&chrono::Local);
+                    let blocktime = set.blocktime;
+                    if ipevent.mode == "file".to_string() && gethostname(true) == ipevent.hostname {
+                        let block =
+                            self.blocklist
+                                .entry(ipdata.ip.to_string())
+                                .or_insert(BlockIpData {
+                                    ipdata: ipdata.clone(),
+                                    tryfail: 0,
+                                    starttime,
+                                    blocktime,
+                                });
+                        block.tryfail += 1;
+                        block.blocktime = blocktime;
+                        if block.tryfail >= set.tryfail {
+                            return Some(ipevent.clone());
+                        }
+                    } else {
                         self.blocklist
                             .entry(ipdata.ip.to_string())
                             .or_insert(BlockIpData {
                                 ipdata: ipdata.clone(),
-                                tryfail: 0,
+                                tryfail: set.tryfail,
                                 starttime,
                                 blocktime,
                             });
-                    block.tryfail += 1;
-                    block.blocktime = blocktime;
-                    if block.tryfail >= set.tryfail {
-                        return Some(ipevent.clone());
                     }
-                } else {
-                    self.blocklist
-                        .entry(ipdata.ip.to_string())
-                        .or_insert(BlockIpData {
-                            ipdata: ipdata.clone(),
-                            tryfail: set.tryfail,
-                            starttime,
-                            blocktime,
-                        });
                 }
-            }
+                None => {}
+            },
             None => {}
         }
         None
@@ -363,12 +365,12 @@ impl Config {
             .send()
             .await;
         let req = match resp {
-            Ok(re) => re,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
         let data: GlobalConfigV2 = match req.json::<GlobalConfigV2>().await {
-            Ok(res) => res,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
 
         for d in data.sets {
@@ -398,13 +400,13 @@ impl Config {
             .await;
 
         let req = match resp {
-            Ok(re) => re,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
 
         let data: Vec<IpData> = match req.json::<Vec<IpData>>().await {
-            Ok(res) => res,
-            Err(err) => return Err(err),
+            Ok(o) => o,
+            Err(e) => return Err(e),
         };
 
         Ok(data)
@@ -415,8 +417,8 @@ impl Config {
         for trustnet in &self.trustnets {
             match trustnet.parse() {
                 Ok(net) => trustnets.push(net),
-                Err(err) => {
-                    println!("error parsing {trustnet}, error: {err}");
+                Err(e) => {
+                    println!("error parsing {trustnet}, error: {e}");
                 }
             };
         }

src/fw.rs

@@ -21,7 +21,6 @@ pub fn fwglobalinit<'a>() -> ((Batch, Table), (Batch, Table)) {
 
 macro_rules! initrules {
     ($batch:expr, $table:expr, $chain:ident) => {
-        let mut $chain = Chain::new(&CString::new(PKG_NAME).unwrap(), &$table);
         $chain.set_hook(nftnl::Hook::In, 1);
         $chain.set_policy(nftnl::Policy::Accept);
 
@@ -29,13 +28,11 @@ macro_rules! initrules {
         $batch.add(&Rule::new(&$chain), nftnl::MsgType::Del);
 
         let mut rule = Rule::new(&$chain);
-
         rule.add_expr(&nft_expr!(ct state));
         rule.add_expr(&nft_expr!(bitwise mask 4u32, xor 0u32));
         rule.add_expr(&nft_expr!(cmp != 0u32));
         rule.add_expr(&nft_expr!(counter));
         rule.add_expr(&nft_expr!(verdict accept));
-
         $batch.add(&rule, nftnl::MsgType::Add);
     };
 }
@@ -86,25 +83,42 @@ fn fwinit(t: FwTableType) -> (Batch, Table) {
 }
 
 pub fn fwblock(
-    ips_add: &Vec<IpData>,
+    ips_add_all: &Vec<IpData>,
     ret: &mut Vec<String>,
     fwlen: &mut usize,
 ) -> std::result::Result<(), Error> {
     let ((mut batch4, table4), (mut batch6, table6)) = fwglobalinit();
 
+    let mut chain4 = Chain::new(&CString::new(PKG_NAME).unwrap(), &table4);
+    let mut chain6 = Chain::new(&CString::new(PKG_NAME).unwrap(), &table6);
+
     initrules!(batch4, table4, chain4);
     initrules!(batch6, table6, chain6);
 
+    let mut factor = 1;
+    if ips_add_all.len() > 100 {
+        factor = (ips_add_all.len() / 10) as usize
+    }
+
+    let ips_add_tmp: Vec<IpData> = ips_add_all.clone().iter().map(|x| x.clone()).collect();
+    let mut ips_add_iter = ips_add_tmp.chunks(factor);
+    let mut ips_add: Vec<&[IpData]> = vec![];
+    while let Some(x) = ips_add_iter.next() {
+        ips_add.push(x);
+    }
+
     // build and add rules
-    for ipdata in ips_add.clone() {
-        match ipdata.t {
-            4 => {
-                createrules!(ipdata, chain4, batch4, Ipv4Addr, ipv4);
+    for ipdata_group in ips_add.clone() {
+        for ipdata in ipdata_group {
+            match ipdata.t {
+                4 => {
+                    createrules!(ipdata, chain4, batch4, Ipv4Addr, ipv4);
+                }
+                6 => {
+                    createrules!(ipdata, chain6, batch6, Ipv6Addr, ipv6);
+                }
+                _ => {}
             }
-            6 => {
-                createrules!(ipdata, chain6, batch6, Ipv6Addr, ipv6);
-            }
-            _ => {}
         }
     }
 
@@ -118,10 +132,13 @@ pub fn fwblock(
             }
         };
     }
-    if fwlen != &mut ips_add.len() {
-        ret.push(format!("{length} ip in firewall", length = ips_add.len()));
+    if fwlen != &mut ips_add_all.len() {
+        ret.push(format!(
+            "{length} ip in firewall",
+            length = ips_add_all.len()
+        ));
     }
-    *fwlen = ips_add.len();
+    *fwlen = ips_add_all.len();
     Ok(())
 }
 

src/ipblc.rs

@@ -11,6 +11,7 @@ use chrono::prelude::*;
 use chrono::prelude::{DateTime, Local};
 use chrono::Duration;
 use nix::sys::inotify::{InitFlags, Inotify, InotifyEvent};
+use sd_notify::*;
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::mpsc::{channel, Receiver, Sender};
@@ -21,6 +22,13 @@ const BL_CHAN_SIZE: usize = 32;
 const WS_CHAN_SIZE: usize = 64;
 const LOOP_MAX_WAIT: u64 = 5;
 
+macro_rules! log_with_systemd {
+    ($msg:expr) => {
+        println!("{}", $msg);
+        notify(false, &[NotifyState::Status(format!("{}", $msg).as_str())]).unwrap();
+    };
+}
+
 pub async fn run() {
     let inotify = Inotify::init(InitFlags::empty()).unwrap();
     let globalctx = Context::new(&inotify).await;
@@ -31,7 +39,7 @@ pub async fn run() {
     let pkgversion = format!("{}@{}", env!("CARGO_PKG_VERSION"), GIT_VERSION);
 
     let mut last_cfg_reload: DateTime<Local> = Local::now().trunc_subsecs(0);
-    println!("Launching {}, version {}", PKG_NAME, pkgversion);
+    log_with_systemd!(format!("Launching {}, version {}", PKG_NAME, pkgversion));
     fwglobalinit();
 
     let ctxapi = Arc::clone(&ctxarc);
@@ -60,18 +68,13 @@ pub async fn run() {
         compare_files_changes(&ctxclone, &mut blrx, &ipeventclone).await;
     });
 
+    notify(false, &[NotifyState::Ready]).unwrap();
+
     loop {
         let mut ret: Vec<String> = Vec::new();
 
         let ctxclone = Arc::clone(&ctxarc);
 
-        let ipe = ipevent!("ping", "ws", gethostname(true));
-        if !send_to_ipbl_websocket(&mut wssocketrr, &ipe).await {
-            wssocketrr.close(None).unwrap();
-            wssocketrr = websocketreqrep(&ctxwsrr).await;
-            continue;
-        }
-
         tokio::select! {
             ipevent = ipeventrx.recv() => {
                 let received_ip = ipevent.unwrap();
@@ -85,6 +88,7 @@ pub async fn run() {
                     for ip_to_send in toblock {
                         let ipe = ipevent!("init","ws",gethostname(true),Some(ip_to_send));
                         if !send_to_ipbl_websocket(&mut wssocketrr, &ipe).await {
+                            wssocketrr.close(None).unwrap();
                             wssocketrr = websocketreqrep(&ctxwsrr).await;
                             break;
                         }
@@ -100,17 +104,24 @@ pub async fn run() {
                 // send ip list to api and ws sockets
                 if let Some(ipevent) = filtered_ipevent {
                     if received_ip.msgtype != "init" {
-                        println!("sending {} to api and ws", ipevent.ipdata.clone().unwrap().ip);
+                        log_with_systemd!(format!("sending {} to api and ws", ipevent.ipdata.clone().unwrap().ip));
                         let ipe = ipevent!("add","ws",gethostname(true),ipevent.ipdata);
                         send_to_ipbl_api(&server.clone(), &ipe).await;
                         if !send_to_ipbl_websocket(&mut wssocketrr, &ipe).await {
+                            wssocketrr.close(None).unwrap();
                             wssocketrr = websocketreqrep(&ctxwsrr).await;
                             continue;
                         }
                     }
                 }
             }
-            _val = sleep_s(LOOP_MAX_WAIT) => {}
+            _val = sleep_s(LOOP_MAX_WAIT) => {
+                let ipe = ipevent!("ping", "ws", gethostname(true));
+                if !send_to_ipbl_websocket(&mut wssocketrr, &ipe).await {
+                    wssocketrr.close(None).unwrap();
+                    wssocketrr = websocketreqrep(&ctxwsrr).await;
+                }
+            }
         };
 
         let ctxclone = Arc::clone(&ctxarc);
@@ -118,7 +129,8 @@ pub async fn run() {
 
         // log lines
         if ret.len() > 0 {
-            println!("{ret}", ret = ret.join(", "));
+            let result = ret.join(", ");
+            log_with_systemd!(format!("{result}"));
         }
 
         let ctxclone = Arc::clone(&ctxarc);
@@ -177,8 +189,8 @@ async fn handle_fwblock(ctxclone: Arc<RwLock<Context>>, ret: &mut Vec<String>, f
     // apply firewall blocking
     match fwblock(&toblock, ret, fwlen) {
         Ok(_) => {}
-        Err(err) => {
-            println!("Err: {err}, unable to push firewall rules, use super user")
+        Err(e) => {
+            println!("err: {e}, unable to push firewall rules, use super user")
         }
     };
 }

src/monitoring.rs

@@ -11,9 +11,9 @@ pub async fn apiserver(ctxarc: &Arc<RwLock<Context>>) -> io::Result<()> {
     let ctxarc = ctxarc.clone();
     let addr: String = { ctxarc.read().await.cfg.api.parse().unwrap() };
     let listener = match TcpListener::bind(addr).await {
-        Ok(l) => l,
-        Err(err) => {
-            println!("Error: {err}");
+        Ok(o) => o,
+        Err(e) => {
+            println!("error: {e}");
             std::process::exit(1);
         }
     };
@@ -29,13 +29,13 @@ pub async fn apiserver(ctxarc: &Arc<RwLock<Context>>) -> io::Result<()> {
                             match socket.try_read(&mut buf) {
                                 Ok(_) => {}
                                 Err(e) => {
-                                    println!("{e}");
+                                    println!("error: {e}");
                                     continue;
                                 }
                             };
                         }
                         Err(e) => {
-                            println!("{e}");
+                            println!("error: {e}");
                             continue;
                         }
                     }
@@ -49,8 +49,8 @@ pub async fn apiserver(ctxarc: &Arc<RwLock<Context>>) -> io::Result<()> {
 
                     match socket.write_all(res.as_bytes()).await {
                         Ok(_) => {}
-                        Err(err) => {
-                            println!("ee {err}");
+                        Err(e) => {
+                            println!("error: {e}");
                         }
                     }
                 }

src/utils.rs

@@ -6,9 +6,9 @@ use tokio::time::{sleep, Duration};
 
 pub fn read_lines(filename: &String, offset: u64) -> Option<Box<dyn Read>> {
     let mut file = match File::open(filename) {
-        Ok(f) => f,
-        Err(err) => {
-            println!("{err}");
+        Ok(o) => o,
+        Err(e) => {
+            println!("error: {e}");
             return None;
         }
     };
@@ -21,6 +21,11 @@ pub async fn sleep_s(s: u64) {
     sleep(Duration::from_secs(s)).await;
 }
 
+#[allow(dead_code)]
+pub async fn sleep_ms(m: u64) {
+    sleep(Duration::from_millis(m)).await;
+}
+
 pub fn gethostname(show_fqdn: bool) -> String {
     let hostname_cstr = unistd::gethostname().expect("Failed getting hostname");
     let fqdn = hostname_cstr

src/webservice.rs

@@ -15,8 +15,8 @@ pub async fn send_to_ipbl_api(server: &str, ip: &IpEvent) {
             Ok(_) => {
                 break;
             }
-            Err(err) => {
-                println!("{err}");
+            Err(e) => {
+                println!("error: {e}");
                 sleep_s(1).await;
                 if try_req == MAX_FAILED_API_RATE {
                     break;

src/websocket.rs

@@ -59,7 +59,10 @@ pub async fn websocketpubsub(
                                 txps.send(tosend).await.unwrap();
                             }
                         }
-                        None => {}
+                        None => {
+                            let txps = txpubsub.read().await;
+                            txps.send(tosend.clone()).await.unwrap();
+                        }
                     }
                 }
                 Err(e) => {
@@ -111,14 +114,11 @@ pub async fn send_to_ipbl_websocket(
             Ok(_) => {}
             Err(e) => {
                 println!("err send read: {e:?}");
-                ws.close(None).unwrap_or(());
                 return false;
             }
         };
     } else {
         println!("can't write to socket");
-        ws.close(None).unwrap_or(());
-        sleep_s(1);
         return false;
     };
 
@@ -127,15 +127,13 @@ pub async fn send_to_ipbl_websocket(
             Ok(_) => {}
             Err(e) => {
                 println!("err send read: {e:?}");
-                ws.close(None).unwrap_or(());
                 return false;
             }
         };
     } else {
         println!("can't read from socket");
-        sleep_s(1);
-        ws.close(None).unwrap_or(());
         return false;
     };
+
     true
 }