feat: split by lib and main

Author: jjeffcaii

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zerodns"
-version = "0.1.0-alpha.2"
+version = "0.1.0-alpha.3"
 edition = "2021"
 license = "MIT"
 readme = "README.md"
@@ -42,6 +42,7 @@ regex = "1.10.3"
 hex = "0.4.3"
 strum = { version = "0.26.1", default-features = false, features = ["strum_macros", "derive"] }
 strum_macros = "0.26.1"
+deadpool = "0.10.0"
 
 [dev-dependencies]
 hex = "0.4.3"

README.md

@@ -26,4 +26,71 @@ run an example:
 
 ```shell
 $ just r
+$ dig @127.0.0.1 -p5454 www.youtube.com
+```
+
+## Configuration
+
+Here's an example configuration file:
+
+```toml
+
+# The settings of server
+[server]
+# will listen on tcp+udp
+listen = "0.0.0.0:5454"
+# use LRU cache with 1000 capacity
+cache_size = 1000
+
+##### FILTERS BEGIN #####
+
+# alidns over udp
+[filters.alidns]
+kind = "proxyby"
+props = { servers = ["223.5.5.5", "223.6.6.6"] }
+
+# opendns over tcp
+[filters.opendns]
+kind = "proxyby"
+props = { servers = ["tcp://208.67.222.222:443", "tcp://208.67.220.220:443"] }
+
+# a chinadns filter:
+#  - use trusted dns servers for oversea domain
+#  - use mistrusted dns servers for Chinese domain
+# NOTICE: require 'geoip_database', you can download from https://git.io/GeoLite2-Country.mmdb
+[filters.chinadns]
+kind = "chinadns"
+props = { trusted = ["tcp://208.67.222.222:443", "tcp://208.67.220.220:443"], mistrusted = ["223.5.5.5", "223.6.6.6"], geoip_database = "GeoLite2-Country.mmdb" }
+
+##### FILTERS END #####
+
+##### RULES BEGIN #####
+
+# NOTICE:
+# - will check rules below one by one
+# - the 'domain' field follows the glob syntax
+
+# for domain of '*.cn', use alidns filter
+[[rules]]
+domain = "*.cn"
+filter = "alidns"
+
+# for domain of '*apple.com', use alidns filter
+[[rules]]
+domain = "*.apple.com"
+filter = "alidns"
+
+# for domain of '*google*', use opendns filter
+[[rules]]
+domain = "*google*"
+filter = "opendns"
+
+# FINAL: use chinadns for others
+[[rules]]
+domain = "*"
+filter = "chinadns"
+
+##### RULES END #####
+
+
 ```

config.toml

@@ -1,40 +1,31 @@
 [server]
 listen = "0.0.0.0:5454"
-# cache_size = 1000
+cache_size = 1000
 
-[filters.test]
-kind = "proxyby"
-props = { servers = ["tcp://223.5.5.5"] }
-
-[filters.china]
+[filters.alidns]
 kind = "proxyby"
 props = { servers = ["223.5.5.5", "223.6.6.6"] }
 
-[filters.google]
+[filters.opendns]
 kind = "proxyby"
-props = { servers = ["8.8.8.8", "8.8.4.4"] }
-
-[filters.tcpgoogle]
-kind = "proxyby"
-props = { servers = ["tcp://8.8.8.8", "tcp://8.8.4.4"] }
-
+props = { servers = ["tcp://208.67.222.222:443", "tcp://208.67.220.220:443"] }
 
 [filters.chinadns]
 kind = "chinadns"
-props = { trusted = ["tcp://8.8.8.8", "tcp://8.8.4.4"], mistrusted = ["223.5.5.5", "223.6.6.6"], geoip_database = "GeoLite2-Country.mmdb" }
+props = { trusted = ["tcp://208.67.222.222:443", "tcp://208.67.220.220:443"], mistrusted = ["223.5.5.5", "223.6.6.6"], geoip_database = "GeoLite2-Country.mmdb" }
 
-#[[rules]]
-#domain = "*bing*"
-#filter = "test"
-#
-#[[rules]]
-#domain = "*.cn"
-#filter = "china"
-#
-#[[rules]]
-#domain = "*google.com"
-#filter = "google"
+[[rules]]
+domain = "*.cn"
+filter = "alidns"
+
+[[rules]]
+domain = "*.apple.com"
+filter = "alidns"
+
+[[rules]]
+domain = "*google*"
+filter = "opendns"
 
 [[rules]]
 domain = "*"
-filter = "tcpgoogle"
+filter = "chinadns"

docker-compose.yml

@@ -12,8 +12,8 @@ services:
       - ./GeoLite2-Country.mmdb:/app/GeoLite2-Country.mmdb
       - ./config.toml:/app/config.toml
     ports:
-      - 15454:5454/udp
-      - 15454:5454/tcp
+      - 5454:5454/udp
+      - 5454:5454/tcp
     networks:
       - local
 

src/bootstrap.rs

@@ -0,0 +1,58 @@
+use std::sync::Arc;
+
+use tokio::net::{TcpListener, UdpSocket};
+use tokio::sync::Notify;
+
+use crate::cache::InMemoryCache;
+use crate::config::Config;
+use crate::handler::RuledHandler;
+use crate::server::{TcpServer, UdpServer};
+
+pub async fn run(c: Config, closer: Arc<Notify>) -> anyhow::Result<()> {
+    let mut rb = RuledHandler::builder();
+
+    for (k, v) in c.filters.iter() {
+        rb = rb.filter(k, v)?;
+    }
+
+    for next in c.rules.iter() {
+        rb = rb.rule(next)?;
+    }
+
+    let h = rb.build();
+
+    let cs = match &c.server.cache_size {
+        None => None,
+        Some(size) => {
+            if *size == 0 {
+                None
+            } else {
+                Some(Arc::new(InMemoryCache::builder().capacity(*size).build()))
+            }
+        }
+    };
+
+    let udp_server = {
+        let socket = UdpSocket::bind(&c.server.listen).await?;
+
+        UdpServer::new(
+            socket,
+            Clone::clone(&h),
+            Clone::clone(&cs),
+            Clone::clone(&closer),
+        )
+    };
+
+    let tcp_server = {
+        TcpServer::new(
+            TcpListener::bind(&c.server.listen).await?,
+            Clone::clone(&h),
+            Clone::clone(&cs),
+            Clone::clone(&closer),
+        )
+    };
+
+    let (_first, _second) = tokio::join!(udp_server.listen(), tcp_server.listen());
+
+    Ok(())
+}

src/builtin.rs

@@ -3,7 +3,7 @@ use crate::filter::{
     ProxyByFilterFactory,
 };
 
-pub(crate) fn init() {
+pub fn init() {
     register("noop", |opts: &Options| NoopFilterFactory::try_from(opts));
     register("proxyby", |opts: &Options| {
         ProxyByFilterFactory::try_from(opts)
@@ -16,9 +16,10 @@ pub(crate) fn init() {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use crate::filter::{load, Options};
 
+    use super::*;
+
     #[test]
     fn test_init() {
         pretty_env_logger::try_init_timed().ok();

src/cache.rs src/cache/memory.rs

@@ -1,29 +1,34 @@
+use super::CacheStore;
 use std::ops::Add;
 use std::time::{Duration, Instant};
 
+use async_trait::async_trait;
 use moka::future::Cache;
 
 use crate::protocol::Message;
 
 #[derive(Clone)]
-pub(crate) struct CacheStore {
+pub(crate) struct InMemoryCache {
     ttl: Duration,
     cache: Cache<Message, (Instant, Message)>,
 }
 
-impl CacheStore {
+impl InMemoryCache {
     pub(crate) fn builder() -> CacheStoreBuilder {
         CacheStoreBuilder {
             ttl: Duration::from_secs(3600),
             capacity: 1000,
         }
     }
+}
 
-    pub(crate) async fn get(&self, req: &Message) -> Option<(Instant, Message)> {
+#[async_trait]
+impl CacheStore for InMemoryCache {
+    async fn get(&self, req: &Message) -> Option<(Instant, Message)> {
         self.cache.get(req).await
     }
 
-    pub(crate) async fn set(&self, req: &Message, resp: &Message) {
+    async fn set(&self, req: &Message, resp: &Message) {
         let key = Clone::clone(req);
         let val = Clone::clone(resp);
 
@@ -54,19 +59,20 @@ impl CacheStoreBuilder {
         self
     }
 
-    pub(crate) fn build(self) -> CacheStore {
+    pub(crate) fn build(self) -> InMemoryCache {
         let Self { ttl, capacity } = self;
         let cache = Cache::builder().max_capacity(capacity as u64).build();
 
-        CacheStore { ttl, cache }
+        InMemoryCache { ttl, cache }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use tokio::time::{sleep, Duration};
 
+    use super::*;
+
     fn init() {
         pretty_env_logger::try_init_timed().ok();
     }
@@ -88,7 +94,7 @@ mod tests {
             Message::from(raw)
         };
 
-        let cs = CacheStore::builder().ttl(2).capacity(100).build();
+        let cs = InMemoryCache::builder().ttl(2).capacity(100).build();
         assert!(cs.get(&req).await.is_none());
 
         cs.set(&req, &res).await;

src/cache/mod.rs

@@ -0,0 +1,16 @@
+use std::time::Instant;
+
+use async_trait::async_trait;
+
+pub(crate) use memory::InMemoryCache;
+
+use crate::protocol::Message;
+
+mod memory;
+
+#[async_trait]
+pub trait CacheStore: Send + Sync + 'static {
+    async fn get(&self, req: &Message) -> Option<(Instant, Message)>;
+
+    async fn set(&self, req: &Message, resp: &Message);
+}

src/client/mod.rs

@@ -0,0 +1,15 @@
+mod tcp;
+mod udp;
+
+use async_trait::async_trait;
+
+use crate::protocol::Message;
+use crate::Result;
+
+#[async_trait]
+pub trait Client {
+    async fn request(&self, req: &Message) -> Result<Option<Message>>;
+}
+
+pub use tcp::{TcpClient, TcpClientBuilder};
+pub use udp::{UdpClient, UdpClientBuilder};