🐛 Fix parsing of log-console and server-tls (#267)

src/app.rs

@@ -39,6 +39,7 @@ impl App {
                     cfg.log_size(),
                     cfg.log_num(),
                     cfg.audit_file_mode().into(),
+                    cfg.log_config().console.unwrap_or_default(),
                 ))
             } else {
                 None

src/config/log.rs

@@ -7,6 +7,9 @@ use crate::{infra::file_mode::FileMode, third_ext::serde_opt_str};
 
 #[derive(Debug, Default, Serialize, Deserialize)]
 pub struct LogConfig {
+    /// enable output log to console
+    pub console: Option<bool>,
+
     /// set log level
     ///
     /// log-level [level], level=fatal, error, warn, notice, info, debug

src/config/parser/mod.rs

@@ -103,6 +103,7 @@ pub enum OneConfig {
     IgnoreIp(IpNet),
     Listener(ListenerConfig),
     LocalTtl(u64),
+    LogConsole(bool),
     LogNum(u64),
     LogSize(Byte),
     LogLevel(Level),
@@ -190,6 +191,7 @@ pub fn parse_config(input: &str) -> IResult<&str, OneConfig> {
         map(parse_item("domain"), OneConfig::Domain),
         map(parse_item("hosts-file"), OneConfig::HostsFile),
         map(parse_item("local-ttl"), OneConfig::LocalTtl),
+        map(parse_item("log-console"), OneConfig::LogConsole),
         map(parse_item("log-file-mode"), OneConfig::LogFileMode),
         map(parse_item("log-file"), OneConfig::LogFile),
         map(parse_item("log-filter"), OneConfig::LogFilter),

src/config/parser/nameserver.rs

@@ -29,7 +29,16 @@ impl NomParser for NameServerInfo {
                 pair(proto, take_till1(|c: char| c.is_whitespace())),
                 |(a, b)| {
                     let url: String = [a, b].concat();
-                    DnsUrl::from_str(&url)
+                    match DnsUrl::from_str(&url) {
+                        Ok(url) => Ok(url),
+                        Err(err) => {
+                            let url: String = [a, "[", b, "]"].concat();
+                            match DnsUrl::from_str(&url) {
+                                Ok(url) => Ok(url),
+                                _ => Err(err),
+                            }
+                        }
+                    }
                 },
             )
         };
@@ -240,6 +249,27 @@ mod tests {
                 }
             ))
         );
+
+        assert_eq!(
+            NameServerInfo::parse("server-tls 2606:4700:4700::1111"),
+            Ok((
+                "",
+                NameServerInfo {
+                    server: DnsUrl::from_str("tls://[2606:4700:4700::1111]").unwrap(),
+                    group: Default::default(),
+                    blacklist_ip: Default::default(),
+                    whitelist_ip: Default::default(),
+                    check_edns: Default::default(),
+                    exclude_default_group: Default::default(),
+                    proxy: None,
+                    bootstrap_dns: Default::default(),
+                    resolve_group: None,
+                    edns_client_subnet: None,
+                    so_mark: None,
+                    interface: None,
+                }
+            ))
+        );
     }
 
     #[test]

src/dns_conf.rs

@@ -772,6 +772,7 @@ impl RuntimeConfigBuilder {
                 RrTtlReplyMax(v) => self.rr_ttl_reply_max = Some(v),
                 Listener(listener) => self.listeners.push(listener),
                 LocalTtl(v) => self.local_ttl = Some(v),
+                LogConsole(v) => self.log.console = Some(v),
                 LogNum(v) => self.log.num = Some(v),
                 LogLevel(v) => self.log.level = Some(v),
                 LogFile(v) => self.log.file = Some(v),

src/log.rs

@@ -28,6 +28,7 @@ pub fn init_global_default<P: AsRef<Path>>(
     size: u64,
     num: u64,
     mode: Option<u32>,
+    to_console: bool,
 ) -> DefaultGuard {
     let file = MappedFile::open(path.as_ref(), size, Some(num as usize), mode);
 
@@ -42,7 +43,11 @@ pub fn init_global_default<P: AsRef<Path>>(
             false
         });
 
-    let console_level = *CONSOLE_LEVEL.get_or_init(|| Level::INFO);
+    let console_level = if to_console {
+        level
+    } else {
+        *CONSOLE_LEVEL.get_or_init(|| Level::INFO)
+    };
     let console_writer = io::stdout.with_max_level(console_level);
 
     let dispatch = if writable {