ReadMe: Update package list information

BugFix: fix install script issue, and change openwrt script default port for seconddns
luci-app-smartdns: Service redirect status is not displayed when smartdns is disabled
2020-02-19 23:17:34 +08:00 · 2020-02-18 19:39:01 +08:00 · 2020-02-15 14:48:56 +08:00 · 2020-02-15 14:35:51 +08:00 · 2020-02-14 13:14:03 +08:00 · 2020-02-14 13:13:47 +08:00
90 changed files with 18176 additions and 12869 deletions
--- a/.github/ISSUE_TEMPLATE/feature.md
+++ b/.github/ISSUE_TEMPLATE/feature.md
@@ -0,0 +1,20 @@
+---
+name: 需求建议
+about: 需求建议描述
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**需求应用场景**
+请描述需求应用的场景和方式。
+
+**建议的方案**
+实现上述场景建议的方案。
+
+**设备信息**
+1. 设备信息（CPU，厂家）  
+
+2. 固件信息
+
--- a/.github/ISSUE_TEMPLATE/issue.md
+++ b/.github/ISSUE_TEMPLATE/issue.md
@@ -0,0 +1,29 @@
+---
+name: 问题报告
+about: 问题现象描述
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**问题现象**  
+简要描述问题出现的现象
+
+**运行环境**
+1. 固件型号  
+
+2. 运营商  
+
+**重现步骤**
+1. 上游DNS配置。  
+
+2. 访问的域名。  
+
+
+**信息收集**  
+1. 将/var/log/smrtdns.log日志作为附件上传。  
+2. 如进程异常，请将coredump功能开启，上传coredump信息文件。  
+在自定义界面，开启设置->自定义设置->生成coredump配置，重现问题后提交coredump文件
+coredump文件在/tmp目录下
+
--- a/ReadMe.md
+++ b/ReadMe.md
@@ -23,7 +23,6 @@ SmartDNS是一个运行在本地的DNS服务器，SmartDNS接受本地客户端
    1. [Windows 10 WSL安装/WSL ubuntu](#windows-10-wsl安装wsl-ubuntu)
 1. [配置参数](#配置参数)
 1. [捐助](#donate)
-1. [声明](#声明)
 1. [FAQ](#faq)

 ## 软件效果展示
@@ -135,66 +134,22 @@ rtt min/avg/max/mdev = 5.954/6.133/6.313/0.195 ms

 |系统 |安装包|说明
 |-----|-----|-----
-|标准Linux系统(树莓派)| smartdns.xxxxxxxx.armhf.deb|支持树莓派Raspbian stretch，Debian 9系统。
-|标准Linux系统(Armbian arm64)| smartdns.xxxxxxxx.arm64.deb|支持ARM64的Debian stretch，Debian 9系统。
-|标准Linux系统(x86_64)| smartdns.xxxxxxxx.x86_64.tar.gz|支持x86_64 Linux 系统。
-|Windows 10 WSL (ubuntu)| smartdns.xxxxxxxx.x86_64.tar.gz|支持Windows 10 WSL ubuntu系统。
-|标准Linux系统(x86)| smartdns.xxxxxxxx.x86.tar.gz|支持x86系统。
-|华硕原生固件(optware)|smartdns.xxxxxxx.mipsbig.ipk|支持MIPS大端架构的系统，如RT-AC55U, RT-AC66U.
-|华硕原生固件(optware)|smartdns.xxxxxxx.mipsel.ipk|支持MIPS小端架构的系统。
-|华硕原生固件(optware)|smartdns.xxxxxxx.arm.ipk|支持arm小端架构的系统，如RT-AC68U。
-|Padavan|smartdns.xxxxxxx.mipselsf.ipk|padavan固件。
-|openwrt 15.01|smartdns.xxxxxxxx.ar71xx.ipk|支持AR71XX MIPS系统。
-|openwrt 15.01|smartdns.xxxxxxxx.ramips_24kec.ipk|支持MT762X等小端路由器
-|openwrt 15.01(潘多拉)|smartdns.xxxxxxxx.mipsel_24kec_dsp.ipk|支持MT7620系列的潘多拉固件
-|openwrt 15.01(潘多拉)|smartdns.xxxxxxxx.mips_74kc_dsp2.ipk|支持AR71xx系列的潘多拉固件
-|openwrt 18.06|smartdns.xxxxxxxx.mips_24kc.ipk|支持AR71XX MIPS系统。
-|openwrt 18.06|smartdns.xxxxxxxx.mipsel_24kc.ipk|支持MT726X等小端路由器
-|openwrt 18.06|smartdns.xxxxxxxx.x86_64.ipk|支持x86_64路由器
-|openwrt 18.06|smartdns.xxxxxxxx.i386_pentium4.ipk|支持x86路由器
-|openwrt 18.06|smartdns.xxxxxxxxxxx.arm_cortex-a9.ipk|支持arm A9核心CPU的路由器
-|openwrt 18.06|smartdns.xxxxxxxxx.arm_cortex-a7_neon-vfpv4.ipk|支持arm A7核心CPU的路由器
-|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.xxxx.all.ipk|openwrt管理统一界面
+|标准Linux系统(树莓派)| smartdns.xxxxxxxx.arm-debian-all.deb|支持树莓派Raspbian stretch，Debian 9系统。
+|标准Linux系统(Armbian arm64)| smartdns.xxxxxxxx.aarch64-debian-all.deb|支持ARM64的Debian stretch，Debian 9系统。
+|标准Linux系统(x86_64)| smartdns.xxxxxxxx.x86_64-linux-all.tar.gz|支持x86_64 Linux 系统。
+|Windows 10 WSL (ubuntu)| smartdns.xxxxxxxx.x86_64-linux-all.tar.gz|支持Windows 10 WSL ubuntu系统。
+|标准Linux系统(x86)| smartdns.xxxxxxxx.x86-linux-all.tar.gz|支持x86系统。
+|optware|smartdns.xxxxxxxx.mips-optware-all.ipk|支持MIPS大端架构的optware系统。
+|optware|smartdns.xxxxxxxx.mipsel-optware-all.ipk|支持MIPS小端架构的optware系统。
+|optware|smartdns.xxxxxxxx.arm-optware-all.ipk|支持arm小端架构的optware系统。
+|openwrt|smartdns.xxxxxxxx.mips-openwrt-all.ipk|支持MIPS大端架构的openwrt系统。
+|openwrt|smartdns.xxxxxxxx.mipsel-openwrt-all.ipk|支持MIPS小端架构的openwrt系统。
+|openwrt|smartdns.xxxxxxxx.arm-openwrt-all.ipk|支持arm小端架构的openwrt系统。
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all.ipk|openwrt管理界面。
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all-luci-compat-all|兼容版本openwrt管理界面, openwrt 18.xx及之前版本安装。

-* openwrt系统CPU架构比较多，上述表格未列出所有支持系统，请查看CPU架构后下载。
-* merlin梅林固件理论和华硕固件一致，所以根据硬件类型安装相应的ipk包即可。（梅林暂时未验证，有问题提交issue）
-* CPU架构可在路由器管理界面找到，查看方法：
-    登录路由器，点击`System`->`Software`，点击`Configuration` Tab页面，在opkg安装源中可找到对应软件架构，下载路径中可找到，如下，架构为ar71xx
-
-    ```shell
-    src/gz chaos_calmer_base http://downloads.openwrt.org/chaos_calmer/15.05/ar71xx/generic/packages/base
-    ```
-
-* 或ssh登录系统后通过如下命令查询软件架构：
-
-  * **openwrt系列命令**
-
-    ```shell
-    opkg print_architecture
-    ```
-
-  * **optware系列命令**
-
-    ```shell
-    ipkg print_architecture
-    ```
-
-  * **debian系列命令**
-
-    ```shell
-    dpkg --print-architecture
-    ```
-
-  * **例如**
-
-    下面的查询结果`arch ar71xx 10`表示ar71xx系列架构，选择`smartdns.xxxxxxxx.ar71xx.ipk`安装包
-
-    ```shell
-    root@OpenWrt:~# opkg print_architecture
-    arch all 1
-    arch noarch 1
-    arch ar71xx 10
-    ```
+* 单独release的软件包为静态编译软件包，无外部依赖，但体积大。若需要小体积软件包，请自行编译或从openwrt/entware仓库获取。
+* 因静态编译，软件包未强制判断CPU架构，安装不正确的软件包将会导致服务无法启动，请获取正确的软件包。

 * **请在Release页面下载：[点击此处下载](https://github.com/pymumu/smartdns/releases)**

@@ -210,16 +165,16 @@ https://github.com/pymumu/smartdns/releases

 1. 安装

-    下载配套安装包`smartdns.xxxxxxxx.armhf.deb`，并上传到Linux系统中。 执行如下命令安装
+    下载配套安装包`smartdns.xxxxxxxx.arm-debian-all.deb`，并上传到Linux系统中。 执行如下命令安装

    ```shell
-    dpkg -i smartdns.xxxxxxxx.armhf.deb
+    dpkg -i smartdns.xxxxxxxx.arm-debian-all.deb
    ```

-    x86系统下载配套安装包`smartdns.xxxxxxxx.x86-64.tar.gz`, 并上传到Linux系统中。 执行如下命令安装
+    x86系统下载配套安装包`smartdns.xxxxxxxx.x86_64-linux-all.tar.gz`, 并上传到Linux系统中。 执行如下命令安装

    ```shell
-    tar zxf smartdns.xxxxxxxx.x86-64.tar.gz
+    tar zxf smartdns.xxxxxxxx.x86_64-linux-all.tar.gz
    cd smartdns
    chmod +x ./install
    ./install -i
@@ -253,19 +208,19 @@ https://github.com/pymumu/smartdns/releases

 1. 检测服务是否配置成功。

-    使用`nslookup -querytype=ptr 0.0.0.0`查询域名  
+    使用`nslookup -querytype=ptr smartdns`查询域名  
    看命令结果中的`name`项目是否显示为`smartdns`或`主机名`，如`smartdns`则表示生效  

    ```shell
-    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server:         192.168.1.1
    Address:        192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa  name = smartdns.
+    smartdns        name = smartdns.
    ```

-### openwrt/LEDE
+### openwrt

 --------------

@@ -278,6 +233,8 @@ https://github.com/pymumu/smartdns/releases
    opkg install luci-app-smartdns.xxxxxxxx.xxxx.all.ipk
    ```

+    * 注意： 19.07之前的版本，请安装`luci-app-smartdns.xxxxxxxxx.all-luci-compat-all`界面。
+
 1. 修改配置

    登录openwrt管理页面，打开`Services`->`SmartDNS`进行配置。
@@ -297,16 +254,16 @@ https://github.com/pymumu/smartdns/releases

    * **检测转发服务是否配置成功**

-        使用`nslookup -querytype=ptr 0.0.0.0`查询域名  
+        使用`nslookup -querytype=ptr smartdns`查询域名  
        看命令结果中的`name`项目是否显示为`smartdns`或`主机名`，如`smartdns`则表示生效  

        ```shell
-        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
        Server:         192.168.1.1
        Address:        192.168.1.1#53

        Non-authoritative answer:
-        0.0.0.0.in-addr.arpa  name = smartdns.
+        smartdns        name = smartdns.
        ```

    * **界面提示重定向失败**
@@ -330,16 +287,16 @@ https://github.com/pymumu/smartdns/releases

    * **检测上游服务是否配置成功**

-        * 方法一：使用`nslookup -querytype=ptr 0.0.0.0`查询域名  
+        * 方法一：使用`nslookup -querytype=ptr smartdns`查询域名  
        看命令结果中的`name`项目是否显示为`smartdns`或`主机名`，如`smartdns`则表示生效  

        ```shell
-        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
        Server:         192.168.1.1
        Address:        192.168.1.1#53

        Non-authoritative answer:
-        0.0.0.0.in-addr.arpa  name = smartdns.
+        smartdns        name = smartdns.
        ```

        * 方法二：使用`nslookup`查询`www.baidu.com`域名，查看结果中百度的IP地址是否`只有一个`，如有多个IP地址返回，则表示未生效，请多尝试几个域名检查。
@@ -394,16 +351,16 @@ https://github.com/pymumu/smartdns/releases

 1. 重启路由器生效服务

-    待路由器启动后，使用`nslookup -querytype=ptr 0.0.0.0`查询域名  
+    待路由器启动后，使用`nslookup -querytype=ptr smartdns`查询域名  
    看命令结果中的`name`项目是否显示为`smartdns`或`主机名`，如`smartdns`则表示生效  

    ```shell
-    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server:         192.168.1.1
    Address:        192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa  name = smartdns.
+    smartdns        name = smartdns.
    ```

 1. 额外说明
@@ -470,16 +427,16 @@ https://github.com/pymumu/smartdns/releases

 1. 重启路由器生效服务

-    待路由器启动后，使用`nslookup -querytype=ptr 0.0.0.0`查询域名  
+    待路由器启动后，使用`nslookup -querytype=ptr smartdns`查询域名  
    看命令结果中的`name`项目是否显示为`smartdns`或`主机名`，如`smartdns`则表示生效  

    ```shell
-    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server:         192.168.1.1
    Address:        192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa  name = smartdns.
+    smartdns        name = smartdns.
    ```

    注意：若服务没有自动启动，则需要设置optwre/entware自动启动，具体方法参考optware/entware的文档。
@@ -494,7 +451,7 @@ https://github.com/pymumu/smartdns/releases

 1. 安装smartdns

-    下载安装包`smartdns.xxxxxxxx.x86_64.tar.gz`，并解压到D盘根目录。解压后目录如下：
+    下载安装包`smartdns.xxxxxxxx.x86-linux-all.tar.gz`，并解压到D盘根目录。解压后目录如下：

    ```shell
    D:\SMARTDNS
@@ -527,16 +484,16 @@ https://github.com/pymumu/smartdns/releases

 1. 检测服务是否配置成功。

-    使用`nslookup -querytype=ptr 0.0.0.0`查询域名  
+    使用`nslookup -querytype=ptr smartdns`查询域名  
    看命令结果中的`name`项目是否显示为`smartdns`或`主机名`，如`smartdns`则表示生效  

    ```shell
-    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server:         192.168.1.1
    Address:        192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa  name = smartdns.
+    smartdns  name = smartdns.
    ```

 ## 配置参数
@@ -544,8 +501,8 @@ https://github.com/pymumu/smartdns/releases
 |参数|  功能  |默认值|配置值|例子|
 |--|--|--|--|--|
 |server-name|DNS服务器名称|操作系统主机名/smartdns|符合主机名规格的字符串|server-name smartdns
-|bind|DNS监听端口号|[::]:53|IP:PORT|bind 192.168.1.1:53
-|bind-tcp|TCP模式DNS监听端口号|[::]:53|IP:PORT|bind-tcp 192.168.1.1:53
+|bind|DNS监听端口号|[::]:53|可绑定多个端口<br>`IP:PORT`: 服务器IP，端口号。<br>`[-group]`: 请求时使用的DNS服务器组。<br>`[-no-rule-addr]`：跳过address规则。<br>`[-no-rule-nameserver]`：跳过Nameserver规则。<br>`[-no-rule-ipset]`：跳过Ipset规则。<br>`[no-rule-soa]`：跳过SOA(#)规则.<br>`[no-dualstack-selection]`：停用双栈测速。<br>`[-no-speed-check]`：停用测速。<br>`[-no-cache]`：停止缓存|bind :53
+|bind-tcp|TCP DNS监听端口号|[::]:53|可绑定多个端口<br>`IP:PORT`: 服务器IP，端口号。<br>`[-group]`: 请求时使用的DNS服务器组。<br>`[-no-rule-addr]`：跳过address规则。<br>`[-no-rule-nameserver]`：跳过Nameserver规则。<br>`[-no-rule-ipset]`：跳过Ipset规则。<br>`[no-rule-soa]`：跳过SOA(#)规则.<br>`[no-dualstack-selection]`：停用双栈测速。<br>`[-no-speed-check]`：停用测速。<br>`[-no-cache]`：停止缓存|bind-tcp :53
 |cache-size|域名结果缓存个数|512|数字|cache-size 512
 |tcp-idle-time|TCP链接空闲超时时间|120|数字|tcp-idle-time 120
 |rr-ttl|域名结果TTL|远程查询结果|大于0的数字|rr-ttl 600
@@ -560,19 +517,24 @@ https://github.com/pymumu/smartdns/releases
 |audit-size|审计大小|128K|数字+K,M,G|audit-size 128K
 |audit-num|审计归档个数|2|数字|audit-num 2
 |conf-file|附加配置文件|无|文件路径|conf-file /etc/smartdns/smartdns.more.conf
-|server|上游UDP DNS|无|可重复<br>`[ip][:port]`：服务器IP，端口可选。<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server 8.8.8.8:53 -blacklist-ip -group g1
-|server-tcp|上游TCP DNS|无|可重复<br>`[ip][:port]`：服务器IP，端口可选。<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server-tcp 8.8.8.8:53
-|server-tls|上游TLS DNS|无|可重复<br>`[ip][:port]`：服务器IP，端口可选。<br>`[-spki-pin [sha256-pin]]`: TLS合法性校验SPKI值，base64编码的sha256 SPKI pin值<br>`[host-name]`：TLS SNI名称<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server-tls 8.8.8.8:853
-|server-https|上游HTTPS DNS|无|可重复<br>`https://[host][:port]/path`：服务器IP，端口可选。<br>`[-spki-pin [sha256-pin]]`: TLS合法性校验SPKI值，base64编码的sha256 SPKI pin值<br>`[host-name]`：TLS SNI名称<br>`[http-host]`：http协议头主机名<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server-https https://cloudflare-dns.com/dns-query
+|server|上游UDP DNS|无|可重复<br>`[ip][:port]`：服务器IP，端口可选。<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-whitelist-ip]`：whitelist-ip参数指定仅接受whitelist-ip中配置IP范围。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server 8.8.8.8:53 -blacklist-ip -group g1
+|server-tcp|上游TCP DNS|无|可重复<br>`[ip][:port]`：服务器IP，端口可选。<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-whitelist-ip]`：whitelist-ip参数指定仅接受whitelist-ip中配置IP范围。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server-tcp 8.8.8.8:53
+|server-tls|上游TLS DNS|无|可重复<br>`[ip][:port]`：服务器IP，端口可选。<br>`[-spki-pin [sha256-pin]]`: TLS合法性校验SPKI值，base64编码的sha256 SPKI pin值<br>`[-host-name]`：TLS SNI名称。<br>`[-tls-host-verify]`: TLS证书主机名校验。<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-whitelist-ip]`：whitelist-ip参数指定仅接受whitelist-ip中配置IP范围。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server-tls 8.8.8.8:853
+|server-https|上游HTTPS DNS|无|可重复<br>`https://[host][:port]/path`：服务器IP，端口可选。<br>`[-spki-pin [sha256-pin]]`: TLS合法性校验SPKI值，base64编码的sha256 SPKI pin值<br>`[-host-name]`：TLS SNI名称<br>`[-http-host]`：http协议头主机名。<br>`[-tls-host-verify]`: TLS证书主机名校验。<br>`[-blacklist-ip]`：blacklist-ip参数指定使用blacklist-ip配置IP过滤结果。<br>`[-whitelist-ip]`：whitelist-ip参数指定仅接受whitelist-ip中配置IP范围。<br>`[-group [group] ...]`：DNS服务器所属组，比如office, foreign，和nameserver配套使用。<br>`[-exclude-default-group]`：将DNS服务器从默认组中排除| server-https https://cloudflare-dns.com/dns-query
+|speed-check-mode|测速模式选择|无|[ping\|tcp:[80]\|none]|speed-check-mode ping,tcp:80
 |address|指定域名IP地址|无|address /domain/[ip\|-\|-4\|-6\|#\|#4\|#6] <br>`-`表示忽略 <br>`#`表示返回SOA <br>`4`表示IPV4 <br>`6`表示IPV6| address /www.example.com/1.2.3.4
 |nameserver|指定域名使用server组解析|无|nameserver /domain/[group\|-], `group`为组名，`-`表示忽略此规则，配套server中的`-group`参数使用| nameserver /www.example.com/office
 |ipset|域名IPSET|None|ipset /domain/[ipset\|-], `-`表示忽略|ipset /www.example.com/pass
 |ipset-timeout|设置IPSET超时功能启用|auto|[yes]|ipset-timeout yes
+|domain-rules|设置域名规则|无|domain-rules /domain/ [-rules...]<br>`[-speed-check-mode]`: 测速模式，参考`speed-check-mode`配置<br>`[-address]`: 参考`address`配置<br>`[-nameserver]`: 参考`nameserver`配置<br>`[-ipset]`:参考`ipset`配置|domain-rules /www.example.com/ -speed-check-mode none
 |bogus-nxdomain|假冒IP地址过滤|无|[ip/subnet]，可重复| bogus-nxdomain 1.2.3.4/16
 |ignore-ip|忽略IP地址|无|[ip/subnet]，可重复| ignore-ip 1.2.3.4/16
+|whitelist-ip|白名单IP地址|无|[ip/subnet]，可重复| whitelist-ip 1.2.3.4/16
 |blacklist-ip|黑名单IP地址|无|[ip/subnet]，可重复| blacklist-ip 1.2.3.4/16
 |force-AAAA-SOA|强制AAAA地址返回SOA|no|[yes\|no]|force-AAAA-SOA yes
 |prefetch-domain|域名预先获取功能|no|[yes\|no]|prefetch-domain yes
+|serve-expired|过期缓存服务功能|no|[yes\|no]，开启此功能后，如果有请求时尝试回应TTL为0的过期记录，并并发查询记录，以避免查询等待|serve-expired yes
+|serve-expired-ttl|过期缓存服务最长超时时间|0|秒，0：表示停用超时，> 0表示指定的超时的秒数|serve-expired-ttl 0
 |dualstack-ip-selection|双栈IP优选|no|[yes\|no]|dualstack-ip-selection yes
 |dualstack-ip-selection-threshold|双栈IP优选阈值|30ms|毫秒|dualstack-ip-selection-threshold [0-1000]

@@ -593,6 +555,7 @@ https://github.com/pymumu/smartdns/releases
    * 高速缓存机制，使访问更快速。
    * 异步日志，审计机制，在记录信息的同时不影响DNS查询性能。
    * 域名组（group）机制，特定域名使用特定上游服务器组查询，避免隐私泄漏。
+    * 第二DNS支持自定义更多行为。

 1. 如何配置上游服务器最佳。  
    smartdns有测速机制，在配置上游服务器时，建议配置多个上游DNS服务器，包含多个不同区域的服务器，但总数建议在10个左右。推荐配置  
@@ -646,7 +609,12 @@ https://github.com/pymumu/smartdns/releases
    nameserver /.office/office
    ```

-    通过上述配置即可实现DNS解析分流
+    通过上述配置即可实现DNS解析分流，如果需要实现按请求端端口分流，可以配置第二DNS服务器，bind配置增加--group参数指定分流名称。
+
+    ```sh
+    bind :7053 -group office
+    bind :8053 -group home
+    ```

 1. IPV4, IPV6双栈IP优选功能如何使用  
    目前IPV6已经开始普及，但IPV6网络在速度上，某些情况下还不如IPV4，为在双栈网络下获得较好的体验，smartdns提供来双栈IP优选机制，同一个域名，若IPV4的速度远快与IPV6，那么smartdns就会阻止IPV6的解析，让PC使用IPV4访问，具体配置文件通过`dualstack-ip-selection yes`启用此功能，通过`dualstack-ip-selection-threshold [time]`来修改阈值。如果要完全禁止IPV6 AAAA记录解析，可设置`force-AAAA-SOA yes`。
@@ -665,6 +633,22 @@ https://github.com/pymumu/smartdns/releases
    通过`prefetch-domain yes`来启用域名预先获取功能，提高查询命中率。  
    配合上述ttl超时时间，smartdns将在域名ttl即将超时使，再次发送查询请求，并缓存查询结果供后续使用。频繁访问的域名将会持续缓存。此功能将在空闲时消耗更多的CPU。

+    * 过期缓存服务功能  
+    通过`serve-expired`来启用过期缓存服务功能，可提高缓存命中率的同时，降低CPU占用。  
+    此功能会在TTL超时后，将返回TTL=0给客户端，并且同时再次发送查询请求，并缓存新的结果给后续使用。
+
+1. 第二DNS如何自定义更多行为  
+    第二DNS可以作为其他DNS服务器的上游，提供更多的查询行为，通过bind配置支持可以绑定多个端口，不同端口可设置不同的标志，实现不同的功能，如
+
+    ```sh
+    # 绑定 6053端口，6053端口的请求将采用配置office组的上游查询，且不对结果进行测速，忽略address的配置地址。
+    bind [::]:6053 -no-speed-check -group office -no-rule-addr
+    ```
+
+## 编译
+
+smartdns包含了编译软件包的脚本，支持编译luci，debian，openwrt，optare安装包，可执行`package/build-pkg.sh`编译。
+
 ## Donate

 如果你觉得此项目对你有帮助，请捐助我们，以使项目能持续发展，更加完善。
@@ -681,14 +665,6 @@ https://github.com/pymumu/smartdns/releases
  
 ![wechat](doc/wechat_donate.jpg)

-## 声明
+## 开源声明

-* `SmartDNS`著作权归属Nick Peng (pymumu at gmail.com)。
-* `SmartDNS`为免费软件，用户可以非商业性地复制和使用`SmartDNS`。
-* 禁止将 `SmartDNS` 用于商业用途。
-* 使用本软件的风险由用户自行承担，在适用法律允许的最大范围内，对因使用本产品所产生的损害及风险，包括但不限于直接或间接的个人损害、商业赢利的丧失、贸易中断、商业信息的丢失或任何其它经济损失，不承担任何责任。
-* 本软件不会未经用户同意收集任何用户信息。
-
-## 说明
-
-目前代码未开源，后续根据情况开源。
+Smartdns 基于GPL V3协议开源。
--- a/ReadMe_en.md
+++ b/ReadMe_en.md
@@ -21,7 +21,6 @@ Support Raspberry Pi, openwrt, ASUS router, Windows and other devices.
    1. [Windows 10 WSL Installation/WSL ubuntu](#windows-10-wsl-installation/wsl-ubuntu)
 1. [Configuration parameter](#configuration-parameter)
 1. [Donate](#Donate)
-1. [Statement](#Statement)
 1. [FAQ](#FAQ)

 ## Software Show
@@ -130,71 +129,26 @@ Download the matching version of the SmartDNS installation package. The correspo

 |system |package|Description
 |-----|-----|-----
-|Standard Linux system (Raspberry Pi)| smartdns.xxxxxxxx.armhf.deb|Support Raspberry Pi Raspbian stretch, Debian 9 system.
-|Standard Linux system (Armbian arm64)| smartdns.xxxxxxxx.arm64.deb|Support Armbian debian stretch, Debian 9 system.
-|Standard Linux system (x86_64)| smartdns.xxxxxxxx.x86_64.tar.gz|Support for x86_64 Linux systems.
-|Windows 10 WSL (Ubuntu)| smartdns.xxxxxxxx.x86_64.tar.gz|Windows 10 WSL ubuntu.
-|Standard Linux system (x86)| smartdns.xxxxxxxx.x86.tar.gz|Support for x86_64 systems.
-|ASUS native firmware (optware)|smartdns.xxxxxxx.mipsbig.ipk|Systems that support the MIPS big-end architecture, such as RT-AC55U, RT-AC66U.
-|ASUS native firmware (optware)|smartdns.xxxxxxx.mipsel.ipk|System that supports the MIPS little endian architecture.
-|ASUS native firmware (optware)|smartdns.xxxxxxx.arm.ipk|System that supports the ARM small endian architecture, such as the RT-AC88U, RT-AC68U.
-|Padavan|smartdns.xxxxxxx.mipselsf.ipk|padavan Firmware.
-|openwrt 15.01|smartdns.xxxxxxxx.ar71xx.ipk|Support AR71XX MIPS system.
-|openwrt 15.01|smartdns.xxxxxxxx.ramips_24kec.ipk|Support small-end routers such as MT762X
-|openwrt 15.01(Pandora)|smartdns.xxxxxxxx.mipsel_24kec_dsp.ipk|Support for Pandora firmware of MT7620 series
-|openwrt 15.01(Pandora)|smartdns.xxxxxxxx.mips_74kc_dsp2.ipk|Support for Pandora firmware of AR71xx series
-|openwrt 18.06|smartdns.xxxxxxxx.mips_24kc.ipk|Support AR71XX MIPS system.
-|openwrt 18.06|smartdns.xxxxxxxx.mipsel_24kc.ipk|Support small-end routers such as MT726X
-|openwrt 18.06|smartdns.xxxxxxxx.x86_64.ipk|Support x86_64 router
-|openwrt 18.06|smartdns.xxxxxxxx.i386_pentium4.ipk|Support x86_64 router
-|openwrt 18.06|smartdns.xxxxxxxxxxx.arm_cortex-a9.ipk|Router supporting arm A9 core CPU
-|openwrt 18.06|smartdns.xxxxxxxxx.arm_cortex-a7_neon-vfpv4.ipk|Router supporting arm A7 core CPU
-|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.xxxx.all.ipk|Openwrt management interface
+|Standard Linux system (Raspberry Pi)| smartdns.xxxxxxxx.arm-debian-all.deb|Support Raspberry Pi Raspbian stretch, Debian 9 system.
+|Standard Linux system (Armbian arm64)| smartdns.xxxxxxxx.aarch64-debian-all.deb|Support Armbian debian stretch, Debian 9 system.
+|Standard Linux system (x86_64)| smartdns.xxxxxxxx.x86_64-linux-all.tar.gz|Support for x86_64 Linux systems.
+|Windows 10 WSL (ubuntu)| smartdns.xxxxxxxx.x86_64-linux-all.tar.gz|Windows 10 WSL ubuntu.
+|Standard Linux system (x86)| smartdns.xxxxxxxx.x86-linux-all.tar.gz|Support for x86_64 systems.
+|optware|smartdns.xxxxxxxx.mips-optware-all.ipk|Support the MIPS big-endian architecture for optware。
+|optware|smartdns.xxxxxxxx.mipsel-optware-all.ipk|Support the MIPS little-endian architecture for optware。
+|optware|smartdns.xxxxxxxx.arm-optware-all.ipk|Support the arm architecture for optware。
+|openwrt|smartdns.xxxxxxxx.mips-openwrt-all.ipk|Support the MIPS big-endian architecture for openwrt。
+|openwrt|smartdns.xxxxxxxx.mipsel-openwrt-all.ipk|Support the MIPS little-endian architecture for openwrt。
+|openwrt|smartdns.xxxxxxxx.arm-openwrt-all.ipk|Support the arm architecture for openwrt。
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all.ipk|Openwrt management interface.
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all-luci-compat-all|Compat Openwrt management interface for early openwrt.

-* The openwrt system supports a lot of CPU architecture. The above table does not list all the supported systems. Please check the CPU architecture and download it.
-* The merlin Merlin firmware theory is the same as the ASUS firmware, so install the corresponding ipk package according to the hardware type. (Merlin is not verified yet, and has a problem to submit an issue)
-* The CPU architecture can be found in the router management interface:  
-    Log in to the router, click `System`->`Software`, click the `Configuration` tab page, and find the corresponding software architecture in the opkg installation source. The download path can be found, as follows, the architecture is ar71xx
-
-    ```shell
-    src/gz chaos_calmer_base http://downloads.openwrt.org/chaos_calmer/15.05/ar71xx/generic/packages/base
-    ```
-
-* Or after login to the system, you can query the architecture with the following commands:
-
-  * **Openwrt series commands**
-
-    ```shell
-    opkg print_architecture
-    ```
-
-  * **Optiware series commands**
-
-    ```shell
-    ipkg print_architecture
-    ```
-
-  * **Dedebian Series Order**
-
-    ```shell
-    dpkg -- print-architecture
-    ```
-
-  * **for example**
-
-    The following query result `arch ar71xx 10` represents the ar71xx series architecture, so select the `smartdns.xxxxxxx.ar71xx.ipk` installation package.
-
-    ```shell
-    Root@OpenWrt:# opkg print_architecture
-    Arch all 1
-    Arch noarch 1
-    Arch ar71xx 10
-    ```
+* The released packages are statically compiled. If you need a small size package, please compile it yourself or obtain it from the openwrt / entware repository.

 * **Please download from the Release page: [Download here](https://github.com/pymu/smartdns/releases)**

 ```shell
-https://github.com/pymu/smartdns/releases
+https://github.com/pymumu/smartdns/releases
 ```

 * For the installation procedure, please refer to the following sections.
@@ -205,16 +159,16 @@ https://github.com/pymu/smartdns/releases

 1. Installation

-    Download the installation package like `smartdns.xxxxxxxx.armhf.deb` and upload it to the Linux system. Run the following command to install
+    Download the installation package like `smartdns.xxxxxxxx.arm-debian-all.deb` and upload it to the Linux system. Run the following command to install

    ```shell
-    dpkg -i smartdns.xxxxxxxx.armhf.deb
+    dpkg -i smartdns.xxxxxxxx.arm-debian-all.deb
    ```

-    For X86-64 system, download the installation package like `smartdns.xxxxxxxx.x86-64.tar.gz` and upload it to the Linux system. Run the following command to install
+    For X86-64 system, download the installation package like `smartdns.xxxxxxxx.x86_64-linux-all.tar.gz` and upload it to the Linux system. Run the following command to install

    ```shell
-    tar zxf smartdns.xxxxxxxx.x86-64.tar.gz
+    tar zxf smartdns.xxxxxxxx.x86_64-linux-all.tar.gz
    cd smartdns
    chmod +x ./install
    ./install -i
@@ -248,19 +202,19 @@ https://github.com/pymu/smartdns/releases

 1. Check if the service is configured successfully

-    Query domain name with `nslookup -querytype=ptr 0.0.0.0`  
+    Query domain name with `nslookup -querytype=ptr smartdns`  
    Check if the `name` item in the command result is displayed as `smartdns` or `hostname`, such as `smartdns`

    ```shell
-    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server:         192.168.1.1
    Address:        192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa  name = smartdns.
+    smartdns         name = smartdns.
    ```

-### openwrt/LEDE
+### openwrt

 --------------

@@ -273,6 +227,8 @@ https://github.com/pymu/smartdns/releases
    opkg install luci-app-smartdns.xxxxxxxx.xxxx.all.ipk
    ```

+    * Note: For versions before openwrt 19.07, please install `luci-app-smartdns.xxxxxxxxx.all-luci-compat-all` package.
+
 1. Configuration

    Log in to the openwrt management page and open `Services`->`SmartDNS` to configure SmartDNS.
@@ -292,16 +248,16 @@ https://github.com/pymu/smartdns/releases

    * **Check if the service is configured successfully**

-        Query domain name with `nslookup -querytype=ptr 0.0.0.0`
+        Query domain name with `nslookup -querytype=ptr smartdns`
        See if the `name` item in the command result is displayed as `smartdns` or `hostname`, such as `smartdns`

        ```shell
-        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
        Server:         192.168.1.1
        Address:        192.168.1.1#53

        Non-authoritative answer:
-        0.0.0.0.in-addr.arpa  name = smartdns.
+        smartdns         name = smartdns.
        ```

    * **The interface prompts that the redirect failed**
@@ -329,12 +285,12 @@ https://github.com/pymu/smartdns/releases
        See if the `name` item in the command result is displayed as `smartdns` or `hostname`, such as `smartdns`

        ```shell
-        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+        pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
        Server:         192.168.1.1
        Address:        192.168.1.1#53

        Non-authoritative answer:
-        0.0.0.0.in-addr.arpa  name = smartdns.
+        smartdns         name = smartdns.
        ```

        * Method 2: Use `nslookup` to query the `www.baidu.com` domain name to see if the IP address of Baidu in the result is `only one. If there are multiple IP addresses returned, it means that it is not valid. Please try to check several domain names.
@@ -389,16 +345,16 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use

 1. Restart router

-    After the router is started, use `nslookup -querytype=ptr 0.0.0.0` to query the domain name.  
+    After the router is started, use `nslookup -querytype=ptr smartdns` to query the domain name.  
    See if the `name` item in the command result is displayed as `smartdns` or `hostname`, such as `smartdns`

    ```shell
-    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server:         192.168.1.1
    Address:        192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa  name = smartdns.
+    smartdns         name = smartdns.
    ```

 1. Note
@@ -465,16 +421,16 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use

 1. Restart the router to take effect

-    After the router is started, use `nslookup -querytype=ptr 0.0.0.0` to query the domain name.
+    After the router is started, use `nslookup -querytype=ptr smartdns` to query the domain name.
    See if the `name` item in the command result is displayed as `smartdns` or `hostname`, such as `smartdns`

    ```shell
-    Pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    Pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server: 192.168.1.1
    Address: 192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa name = smartdns.
+    smartdns        name = smartdns.
    ```

    Note: If the service does not start automatically, you need to set optwre/entware to start automatically. For details, see the optware/entware documentation.
@@ -489,7 +445,7 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use

 1. Install smartdns

-    download install package `smartdns.xxxxxxxx.x86_64.tar.gz`，and unzip to the `D:\` directory, after decompression, the directory is as follows: 
+    download install package `smartdns.xxxxxxxx.x86_64-linux-all.tar.gz`，and unzip to the `D:\` directory, after decompression, the directory is as follows: 

    ```shell
    D:\SMARTDNS
@@ -522,16 +478,16 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use

 1. Check if the service is configured successfully

-    Query domain name with `nslookup -querytype=ptr 0.0.0.0`  
+    Query domain name with `nslookup -querytype=ptr smartdns`  
    Check if the `name` item in the command result is displayed as `smartdns` or `hostname`, such as `smartdns`

    ```shell
-    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr 0.0.0.0
+    pi@raspberrypi:~/code/smartdns_build $ nslookup -querytype=ptr smartdns
    Server:         192.168.1.1
    Address:        192.168.1.1#53

    Non-authoritative answer:
-    0.0.0.0.in-addr.arpa  name = smartdns.
+    smartdns         name = smartdns.
    ```

 ## Configuration parameter
@@ -539,8 +495,8 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use
 |parameter|Parameter function|Default value|Value type|Example|
 |--|--|--|--|--|
 |server-name|DNS name|host name/smartdns|any string like hosname|server-name smartdns
-|bind|DNS bind port|[::]:53|IP:PORT|bind 192.168.1.1:53
-|bind-tcp|TCP mode DNS bind port|[::]:53|IP:PORT|bind-tcp 192.168.1.1:53
+|bind|DNS listening port number|[::]:53|Support binding multiple ports<br>`IP:PORT`: server IP, port number. <br>`[-group]`: The DNS server group used when requesting. <br>`[-no-rule-addr]`: Skip the address rule. <br>`[-no-rule-nameserver]`: Skip the Nameserver rule. <br>`[-no-rule-ipset]`: Skip the Ipset rule. <br>`[-no-rule-soa]`: Skip address SOA(#) rules.<br>`[-no-dualstack-selection]`: Disable dualstack ip selection.<br>`[-no-speed-check]`: Disable speed measurement. <br>`[-no-cache]`: stop caching |bind :53
+|bind-tcp|TCP mode DNS listening port number|[::]:53|Support binding multiple ports<br>`IP:PORT`: server IP, port number. <br>`[-group]`: The DNS server group used when requesting. <br>`[-no-rule-addr]`: Skip the address rule. <br>`[-no-rule-nameserver]`: Skip the Nameserver rule. <br>`[-no-rule-ipset]`: Skip the Ipset rule. <br>`[-no-rule-soa]`: Skip address SOA(#) rules.<br>`[-no-dualstack-selection]`: Disable dualstack ip selection.<br>`[-no-speed-check]`: Disable speed measurement. <br>`[-no-cache]`: stop caching |bind-tcp :53
 |cache-size|Domain name result cache number|512|integer|cache-size 512
 |tcp-idle-time|TCP connection idle timeout|120|integer|tcp-idle-time 120
 |rr-ttl|Domain name TTL|Remote query result|number greater than 0|rr-ttl 600
@@ -555,19 +511,24 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use
 |audit-size|audit log size|128K|number+K,M,G|audit-size 128K
 |audit-num|archived audit log number|2|Integer|audit-num 2
 |conf-file|additional conf file|None|File path|conf-file /etc/smartdns/smartdns.more.conf
-|server|Upstream UDP DNS server|None|Repeatable <br>`[ip][:port]`: Server IP, port optional. <br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server 8.8.8.8:53 -blacklist-ip 
-|server-tcp|Upstream TCP DNS server|None|Repeatable <br>`[ip][:port]`: Server IP, port optional. <br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server-tcp 8.8.8.8:53
-|server-tls|Upstream TLS DNS server|None|Repeatable <br>`[ip][:port]`: Server IP, port optional. <br>`[-spki-pin [sha256-pin]]`: TLS verify SPKI value, a base64 encoded SHA256 hash<br>`[host-name]`:TLS Server name<br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server-tls 8.8.8.8:853
-|server-https|Upstream HTTPS DNS server|None|Repeatable <br>`https://[host][:port]/path`: Server IP, port optional. <br>`[-spki-pin [sha256-pin]]`: TLS verify SPKI value, a base64 encoded SHA256 hash<br>`[host-name]`:TLS Server name<br>`[http-host]`：http header host<br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server-https https://cloudflare-dns.com/dns-query
+|server|Upstream UDP DNS server|None|Repeatable <br>`[ip][:port]`: Server IP, port optional. <br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-whitelist-ip]`: whitelist-ip parameter specifies that only the IP range configured in whitelist-ip is accepted. <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server 8.8.8.8:53 -blacklist-ip
+|server-tcp|Upstream TCP DNS server|None|Repeatable <br>`[ip][:port]`: Server IP, port optional. <br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-whitelist-ip]`: whitelist-ip parameter specifies that only the IP range configured in whitelist-ip is accepted. <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server-tcp 8.8.8.8:53
+|server-tls|Upstream TLS DNS server|None|Repeatable <br>`[ip][:port]`: Server IP, port optional. <br>`[-spki-pin [sha256-pin]]`: TLS verify SPKI value, a base64 encoded SHA256 hash<br>`[-host-name]`:TLS Server name. <br>`[-tls-host-verify]`: TLS cert hostname to verify.<br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-whitelist-ip]`: whitelist-ip parameter specifies that only the IP range configured in whitelist-ip is accepted. <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server-tls 8.8.8.8:853
+|server-https|Upstream HTTPS DNS server|None|Repeatable <br>`https://[host][:port]/path`: Server IP, port optional. <br>`[-spki-pin [sha256-pin]]`: TLS verify SPKI value, a base64 encoded SHA256 hash<br>`[-host-name]`:TLS Server name<br>`[-http-host]`：http header host. <br>`[-tls-host-verify]`: TLS cert hostname to verify.<br>`[-blacklist-ip]`: The "-blacklist-ip" parameter is to filtering IPs which is configured by "blacklist-ip". <br>`[-whitelist-ip]`: whitelist-ip parameter specifies that only the IP range configured in whitelist-ip is accepted. <br>`[-group [group] ...]`: The group to which the DNS server belongs, such as office, foreign, use with nameserver. <br>`[-exclude-default-group]`: Exclude DNS servers from the default group| server-https https://cloudflare-dns.com/dns-query
+|speed-check-mode|Speed mode|None|[ping\|tcp:[80]\|none]|speed-check-mode ping,tcp:443
 |address|Domain IP address|None|address /domain/[ip\|-\|-4\|-6\|#\|#4\|#6], `-` for ignore, `#` for return SOA, `4` for IPV4, `6` for IPV6| address /www.example.com/1.2.3.4
 |nameserver|To query domain with specific server group|None|nameserver /domain/[group\|-], `group` is the group name, `-` means ignore this rule, use the `-group` parameter in the related server|nameserver /www.example.com/office
 |ipset|Domain IPSet|None|ipset /domain/[ipset\|-], `-` for ignore|ipset /www.example.com/pass
 |ipset-timeout|ipset timeout enable|auto|[yes]|ipset-timeout yes
+|domain-rules|set domain rules|None|domain-rules /domain/ [-rules...]<br>`[-speed-check-mode]`: set speed check mode，same as parameter `speed-check-mode`<br>`[-address]`: same as  parameter `address` <br>`[-nameserver]`: same as parameter `nameserver`<br>`[-ipset]`: same as parameter `ipset`|domain-rules /www.example.com/ -speed-check-mode none
 |bogus-nxdomain|bogus IP address|None|[IP/subnet], Repeatable| bogus-nxdomain 1.2.3.4/16
 |ignore-ip|ignore ip address|None|[ip/subnet], Repeatable| ignore-ip 1.2.3.4/16
+|whitelist-ip|ip whitelist|None|[ip/subnet], Repeatable，When the filtering server responds IPs in the IP whitelist, only result in whitelist will be accepted| whitelist-ip 1.2.3.4/16
 |blacklist-ip|ip blacklist|None|[ip/subnet], Repeatable，When the filtering server responds IPs in the IP blacklist, The result will be discarded directly| blacklist-ip 1.2.3.4/16
 |force-AAAA-SOA|force AAAA query return SOA|no|[yes\|no]|force-AAAA-SOA yes
 |prefetch-domain|domain prefetch feature|no|[yes\|no]|prefetch-domain yes
+|serve-expired|Cache serve expired feature|no|[yes\|no], Attempts to serve old responses from cache with a TTL of 0 in the response without waiting for the actual resolution to finish.|serve-expired yes
+|serve-expired-ttl|Cache serve expired limite TTL|0|second，0：disable，> 0  seconds after expiration|serve-expired-ttl 0
 |dualstack-ip-selection|Dualstack ip selection|no|[yes\|no]|dualstack-ip-selection yes
 |dualstack-ip-selection-threshold|Dualstack ip select threadhold|30ms|millisecond|dualstack-ip-selection-threshold [0-1000]

@@ -589,6 +550,7 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use
    * Cache mechanism to make access faster.
    * Asynchronous log, audit log mechanism, does not affect DNS query performance while recording information.
    * Domain group mechanism, specific domain names use specific upstream server group queries to avoid privacy leakage.
+    * The second DNS supports customizing more behavior.

 1. What is the best practices for upstream server configuration?  
    Smartdns has a speed measurement mechanism. When configuring an upstream server, it is recommended to configure multiple upstream DNS servers, including servers in different regions, but the total number is recommended to be around 10. Recommended configuration
@@ -643,6 +605,13 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use
    Nameserver /.office/office
    ```

+    You can use the above configuration to implement DNS resolution and offload. If you need to implement traffic distribution on the requesting port, you can configure the second DNS server. The bind configuration is added. The group parameter specifies the traffic distribution name.
+
+    ```sh
+    Bind :7053 -group office
+    Bind :8053 -group home
+    ```
+
 1. How to use the IPV4, IPV6 dual stack IP optimization feature  
    At present, IPV6 network is not as fast as IPV4 in some cases. In order to get a better experience in the dual-stack network, SmartDNS provides a dual-stack IP optimization mechanism, the same domain name, and the speed of IPV4. Far faster than IPV6, then SmartDNS will block the resolution of IPV6, let the PC use IPV4, the feature is enabled by `dualstack-ip-selection yes`, `dualstack-ip-selection-threshold [time]` is for threshold. if you want to disable IPV6 AAAA record complete, please try `force-AAAA-SOA yes`.

@@ -660,6 +629,22 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use
    Enable pre-fetching of domain names with `prefetch-domain yes` to improve query hit rate.
    by default, Smartdns will send domain query request again before cache expire, and cache the result for the next query. Frequently accessed domain names will continue to be cached. This feature will consume more CPU when idle.

+    * Cache serve expired feature  
+    Enable cache serve expired feature with `serve-expired yes` to improve the cache hit rate and reduce the CPU consumption.
+    This feature will return TTL = 0 to the client after the TTL timeout, and send a new query request again at the same time, and cache the new results for later query.
+
+1. How does the second DNS customize more behavior?
+    The second DNS can be used as the upstream of other DNS servers to provide more query behaviors. Bind configuration support can bind multiple ports. Different ports can be set with different flags to implement different functions, such as
+
+    ```sh
+    # Binding 6053 port, request for port 6053 will be configured with the upstream query of the office group, and the result will not be measured. The address configuration address is ignored.
+    bind [::]:6053 -no-speed-check -group office -no-rule-addr
+    ```
+
+## Compile
+
+smartdns contains scripts for compiling packages, supports compiling luci, debian, openwrt, opare installation packages, and can execute `package/build-pkg.sh` compilation.
+
 ## [Donate](#Donate)  

 If you feel that this project is helpful to you, please donate to us so that the project can continue to develop and be more perfect.
@@ -676,14 +661,6 @@ If you feel that this project is helpful to you, please donate to us so that the
  
 ![wechat](doc/wechat_donate.jpg)

-## Statement
+## Open Source License

-* `SmartDNS` copyright belongs to Nick Peng (pymumu at gmail.com).
-* `SmartDNS` is free software, users can copy and use `SmartDNS` non-commercially.
-* It is forbidden to use `SmartDNS` for commercial purposes.
-* The use of the software is at the user's own risk and, to the fullest extent permitted by applicable law, damages and risks resulting from the use of this product, including but not limited to direct or indirect personal damage, loss of commercial profit, trade disruption No loss of business information or any other financial loss.
-* This software does not collect any user information without the user's consent.
-
-## Additional information
-
-Currently the code is not open source, and subsequent open source according to the situation.
+Smartdns is licensed to the public under the GPL V3 License.
--- a/etc/init.d/smartdns
+++ b/etc/init.d/smartdns
@@ -1,4 +1,19 @@
 #!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 ### BEGIN INIT INFO
 # Provides:        smartdns
@@ -19,14 +34,14 @@ test -x $SMARTDNS || exit 5

 case $1 in
 	start)
-		$SMARTDNS $SMART_DNS_OPTS
+		$SMARTDNS "$SMART_DNS_OPTS"
 		while true; do
 			if [ -e "$PIDFILE" ]; then
 				break;
 			fi
 			sleep .5
 		done
-		PID="`cat $PIDFILE 2>/dev/null`"
+		PID="$(cat $PIDFILE 2>/dev/null)"
 		if [ -z "$PID" ]; then
 			echo "start smartdns server failed."
 			exit 1
@@ -42,25 +57,25 @@ case $1 in
 			echo "smartdns server is stopped."
 			exit 0
 		fi
-		PID="`cat $PIDFILE 2>/dev/null`"
+		PID="$(cat $PIDFILE 2>/dev/null)"
 		if [ ! -e "/proc/$PID" ] || [ -z "$PID" ]; then
 			echo "smartdns server is stopped"
 			exit 0
 		fi

-		kill -TERM $PID
+		kill -TERM "$PID"
 		if [ $? -ne 0 ]; then
 			echo "Stop smartdns server failed."
 			exit 1;
 		fi
-		rm -f $PIDFILE
+		rm -f "$PIDFILE"
 		echo "Stop smartdns server success."
 		;;
 	restart)
-		$0 stop && sleep 1 && $0 start
+		"$0" stop && sleep 1 && "$0" start
 		;;
 	status)
-		PID="`cat $PIDFILE 2>/dev/null`"
+		PID="$(cat "$PIDFILE" 2>/dev/null)"
 		if [ ! -e "/proc/$PID" ] || [ -z "$PID" ]; then
 			echo "smartdns server is not running."
 			exit 1
--- a/etc/smartdns/smartdns.conf
+++ b/etc/smartdns/smartdns.conf
@@ -1,4 +1,4 @@
-# dns server name, defaut is host name
+# dns server name, default is host name
 # server-name, 
 # example:
 #   server-name smartdns
@@ -8,14 +8,28 @@
 # conf-file [file]
 # conf-file blacklist-ip.conf

-# dns server bind ip and port, default dns server port is 53.
-# bind [IP]:port, udp server
-# bind-tcp [IP]:port, tcp server
+# dns server bind ip and port, default dns server port is 53, support binding multi ip and port
+# bind udp server
+#   bind [IP]:[port] [-group [group]] [-no-rule-addr] [-no-rule-nameserver] [-no-rule-ipset] [-no-speed-check] [-no-cache] [-no-rule-soa] [-no-dualstack-selection]
+# bind tcp server
+#   bind-tcp [IP]:[port] [-group [group]] [-no-rule-addr] [-no-rule-nameserver] [-no-rule-ipset] [-no-speed-check] [-no-cache] [-no-rule-soa] [-no-dualstack-selection]
+# option:
+#   -group: set domain request to use the appropriate server group.
+#   -no-rule-addr: skip address rule.
+#   -no-rule-nameserver: skip nameserver rule.
+#   -no-rule-ipset: skip ipset rule.
+#   -no-speed-check: do not check speed.
+#   -no-cache: skip cache.
+#   -no-rule-soa: Skip address SOA(#) rules.
+#   -no-dualstack-selection: Disable dualstack ip selection.
+#   -force-aaaa-soa: force AAAA query return SOA.
 # example: 
-#   IPV4: :53
-#   IPV6  [::]:53
-# bind-tcp [::]:53
-
+#  IPV4: 
+#    bind :53
+#    bind :6053 -group office -no-speed-check
+#  IPV6:
+#    bind [::]:53
+#    bind-tcp [::]:53
 bind [::]:53

 # tcp connection idle timeout
@@ -30,15 +44,33 @@ cache-size 512
 # prefetch-domain [yes|no]
 # prefetch-domain yes

+# cache serve expired 
+# serve-expired [yes|no]
+# serve-expired yes
+
+# cache serve expired TTL
+# serve-expired-ttl [num]
+# serve-expired-ttl 0
+
 # List of hosts that supply bogus NX domain results 
 # bogus-nxdomain [ip/subnet]

 # List of IPs that will be filtered when nameserver is configured -blacklist-ip parameter
 # blacklist-ip [ip/subnet]

+# List of IPs that will be accepted when nameserver is configured -whitelist-ip parameter
+# whitelist-ip [ip/subnet]
+
 # List of IPs that will be ignored
 # ignore-ip [ip/subnet]

+# speed check mode
+# speed-check-mode [ping|tcp:port|none|,]
+# example:
+#   speed-check-mode ping,tcp:80
+#   speed-check-mode tcp:443,ping
+#   speed-check-mode none
+
 # force AAAA query return SOA
 # force-AAAA-SOA [yes|no]

@@ -72,39 +104,46 @@ log-level info
 # log-num 2

 # dns audit
-# audit-enable: enable or disable audit [yes|no]
+# audit-enable [yes|no]: enable or disable audit.
 # audit-enable yes
+# audit-SOA [yes|no]: enable or disable log soa result.
 # audit-size size of each audit file, support k,m,g
 # audit-file /var/log/smartdns-audit.log
 # audit-size 128k
 # audit-num 2

 # remote udp dns server list
-# server [IP]:[PORT] [-blacklist-ip] [-check-edns] [-group [group] ...] [-exclude-default-group]
+# server [IP]:[PORT] [-blacklist-ip] [-whitelist-ip] [-check-edns] [-group [group] ...] [-exclude-default-group]
 # default port is 53
 #   -blacklist-ip: filter result with blacklist ip
+#   -whitelist-ip: filter result whth whitelist ip,  result in whitelist-ip will be accepted.
 #   -check-edns: result must exist edns RR, or discard result.
 #   -group [group]: set server to group, use with nameserver /domain/group.
 #   -exclude-default-group: exclude this server from default group.
 # server 8.8.8.8 -blacklist-ip -check-edns -group g1 -group g2

 # remote tcp dns server list
-# server-tcp [IP]:[PORT] [-blacklist-ip] [-group [group] ...] [-exclude-default-group]
+# server-tcp [IP]:[PORT] [-blacklist-ip] [-whitelist-ip] [-group [group] ...] [-exclude-default-group]
 # default port is 53
 # server-tcp 8.8.8.8

 # remote tls dns server list
-# server-tls [IP]:[PORT] [-blacklist-ip] [-spki-pin [sha256-pin]] [-group [group] ...] [-exclude-default-group]
+# server-tls [IP]:[PORT] [-blacklist-ip] [-whitelist-ip] [-spki-pin [sha256-pin]] [-group [group] ...] [-exclude-default-group]
 #   -spki-pin: TLS spki pin to verify.
-# Get SKPI with this command:
+#   -tls-host-check: cert hostname to verify.
+#   -hostname: TLS sni hostname.
+# Get SPKI with this command:
 #    echo | openssl s_client -connect '[ip]:853' | openssl x509 -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | openssl enc -base64
 # default port is 853
 # server-tls 8.8.8.8
 # server-tls 1.0.0.1

 # remote https dns server list
-# server-https https://[host]:[port]/path [-blacklist-ip] [-spki-pin [sha256-pin]] [-group [group] ...] [-exclude-default-group]
+# server-https https://[host]:[port]/path [-blacklist-ip] [-whitelist-ip] [-spki-pin [sha256-pin]] [-group [group] ...] [-exclude-default-group]
 #   -spki-pin: TLS spki pin to verify.
+#   -tls-host-check: cert hostname to verify.
+#   -hostname: TLS sni hostname.
+#   -http-host: http host.
 # default port is 443
 # server-https https://cloudflare-dns.com/dns-query

@@ -127,3 +166,11 @@ log-level info
 # ipset /www.example.com/block, set ipset with ipset name of block 
 # ipset /www.example.com/-, ignore this domain

+# set domain rules
+# domain-rules /domain/ [-speed-check-mode [...]]
+# rules:
+#   -speed-check-mode [mode]: speed check mode
+#                             speed-check-mode [ping|tcp:port|none|,]
+#   -address [address|-]: same as address option
+#   -nameserver [group|-]: same as nameserver option
+#   -ipset [ipset|-]: same as ipset option
--- a/20
+++ b/20
@@ -1,7 +1,19 @@
 #!/bin/sh
 #
-# Copyright (C) 2018 Ruilin Peng (Nick) <pymumu@gmail.com>
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
 #
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 INST_DIR=$(cd $(dirname $0);pwd)
 ISWSL=1 # 1 means not WSL, 0 means wsl 
@@ -53,7 +65,7 @@ clean_service()

 get_systemd_path()
 {
-	service="`systemctl --no-legend| grep .service | head -n 1 | awk '{print $1}'`"
+	service="`systemctl --no-legend| grep '\.service' | head -n 1 | awk '{print $1}'`"
 	SERVICE_PATH="`systemctl show $service | grep FragmentPath | awk -F'=' '{print $2}'`"
 	dirname $SERVICE_PATH
 }
@@ -82,7 +94,9 @@ install_files()
 	
 	install -v -m 0755 -t $SMARTDNS_INIT_DIR etc/init.d/smartdns 
 	if [ $? -ne 0 ]; then
-		return 1
+		if [ $ISSYSTEMD -ne 0 ]; then
+			return 1
+		fi
 	fi

 	if [ $ISSYSTEMD -eq 0 ]; then
--- a/package/build-pkg.sh
+++ b/package/build-pkg.sh
@@ -0,0 +1,182 @@
+#!/bin/sh
+# Copyright (C) 2018-2019 Nick Peng (pymumu@gmail.com)
+
+CURR_DIR=$(cd $(dirname $0);pwd)
+VER="`date +"1.%Y.%m.%d-%H%M"`"
+CODE_DIR="$CURR_DIR/.."
+IS_BUILD_SMARTDNS=1
+OUTPUTDIR=$CURR_DIR
+export CC
+export STRIP
+
+showhelp()
+{
+	echo "Usage: $0 [OPTION]"
+	echo "Options:"
+	echo " --platform [luci|luci-compat|debian|openwrt|optware|linux]    build for platform. "
+	echo " --arch [all|armhf|arm64|x86-64|...]               build for architecture, e.g. "
+	echo " --cross-tool [cross-tool]                         cross compiler, e.g. mips-openwrt-linux-"
+	echo ""
+	echo "Advance Options:"
+	echo " --static                                          static link smartdns"
+	echo " --only-package                                    only package, not build source"
+	echo " --filearch [arch]                                 output file arch, default: equal --arch"
+	echo " --outputdir [dir]                                 output package to specific directory"
+	echo " "
+	echo "Example:"
+	echo " build luci:"
+	echo "   $0 --platform luci"
+	echo " build luci:"
+	echo "   $0 --platform luci-compat"
+	echo " build debian:"
+	echo "   $0 --platform debian --arch x86-64"
+	echo " build raspbian pi:"
+	echo "   $0 --platform debian --arch armhf"
+	echo " build optware mips:"
+	echo "   $0 --platform optware --arch mipsbig"
+	echo " build openwrt mips:"
+	echo "   $0 --platform openwrt --arch mips_24kc"
+	echo " build generic linux:"
+	echo "   $0 --platform linux --arch x86-64"
+}
+
+build_smartdns()
+{
+	if [ "$PLATFORM" != "luci" ]; then
+		make -C $CODE_DIR/src clean 
+		make -C $CODE_DIR/src all -j8 VER=$VER $MAKE_ARGS
+		if [ $? -ne 0 ]; then
+			echo "make smartdns failed"
+			exit 1
+		fi
+	fi
+
+	$STRIP -d $CODE_DIR/src/smartdns >/dev/null 2>&1
+
+	return 0
+}
+
+
+build()
+{
+	echo "build package for $PLATFORM"
+
+	if [ $IS_BUILD_SMARTDNS -eq 1 ]; then
+		build_smartdns
+		if [ $? -ne 0 ]; then
+			return 1
+		fi
+	fi
+
+	chmod +x $CODE_DIR/package/$PLATFORM/make.sh
+	$CODE_DIR/package/$PLATFORM/make.sh -o $CURR_DIR --arch $ARCH --ver $VER --filearch $FILEARCH -o $OUTPUTDIR
+	if [ $? -ne 0 ]; then
+		echo "build package for $PLATFORM failed"
+		return 1
+	fi
+
+	echo "build package for $PLATFORM success."
+	return 0
+}
+
+main()
+{
+	OPTS=`getopt -o o:h --long arch:,filearch:,ver:,platform:,cross-tool:,static,only-package,outputdir: \
+		-n  "" -- "$@"`
+
+	if [ "$#" -le "1" ]; then
+		showhelp
+		exit 1
+	fi
+
+	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
+
+	# Note the quotes around `$TEMP': they are essential!
+	eval set -- "$OPTS"
+
+	while true; do
+		case "$1" in
+		--arch)
+			ARCH="$2"
+			shift 2;;
+		--filearch)
+			FILEARCH="$2"
+			shift 2;;
+		--platform)
+			PLATFORM="$2"
+			shift 2;;
+		--cross-tool)
+			CROSS_TOOL="$2"
+			shift 2;;
+		--static)
+			export STATIC="yes"
+			shift 1;;
+		--only-package)
+			IS_BUILD_SMARTDNS=0
+			shift 1;;
+		--outputdir)
+			OUTPUTDIR="$2"
+			shift 2;;
+		--ver)
+			VER="$2"
+			shift 2;;
+		-h | --help )
+			showhelp
+			return 0
+			shift ;;
+		-- ) shift; break ;;
+		* ) break ;;
+		esac
+	done
+
+	if [ -z "$PLATFORM" ]; then
+		echo "please input platform"
+		echo "run $0 -h for help."
+		return 1
+	fi
+	
+	if [ "$PLATFORM" = "luci" ]; then
+		ARCH="all"
+	fi
+
+	if [ -z "$ARCH" ]; then
+		echo "please input arch."
+		echo "run $0 -h for help."
+		return 1
+	fi
+
+	if [ -z "$FILEARCH" ]; then 
+		FILEARCH="$ARCH"
+	fi
+
+	if [ -z "$OUTPUTDIR" ]; then
+		OUTPUTDIR=$CURR_DIR
+	fi
+
+	if [ ! -z "$CROSS_TOOL" ]; then
+		CC="${CROSS_TOOL}gcc"
+		STRIP="${CROSS_TOOL}strip"
+	fi
+
+	if [ -z "$CC" ]; then
+		CC="gcc"
+	fi
+
+	if [ -z "$STRIP" ]; then
+		if [ ! -z "`echo $CC | grep '\-gcc'`" ]; then
+			STRIP="`echo "$CC" | sed 's/-gcc\$/-strip/g'`"
+		else
+			STRIP="strip"
+		fi
+	fi
+
+	if [ ! -e "`which $CC`" ]; then
+		echo "Cannot find compiler $CC"
+		return 1
+	fi
+
+	build
+}
+
+main $@
+exit $?
--- a/package/debian/DEBIAN/copyright
+++ b/package/debian/DEBIAN/copyright
@@ -3,5 +3,5 @@ Upstream-Name: smartdns
 Source: http://github.com/pymumu/smartdns

 Files: *
-Copyright: 2018 Nick peng
+Copyright: 2018-2019 Nick peng
 License: proprietary
--- a/package/debian/make.sh
+++ b/package/debian/make.sh
@@ -1,5 +1,19 @@
-#/bin/sh
-
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 CURR_DIR=$(cd $(dirname $0);pwd)
 VER="`date +"1.%Y.%m.%d-%H%M"`"
 SMARTDNS_DIR=$CURR_DIR/../../
@@ -11,42 +25,46 @@ showhelp()
 	echo "Options:"
 	echo " -o               output directory."
 	echo " --arch           archtecture."
-    echo " --ver            version."
+	echo " --ver            version."
 	echo " -h               show this message."
 }

 build()
 {
-    ROOT=/tmp/smartdns-deiban
-    rm -fr $ROOT
-    mkdir -p $ROOT
-    cd $ROOT/
+	ROOT=/tmp/smartdns-deiban
+	rm -fr $ROOT
+	mkdir -p $ROOT
+	cd $ROOT/

-    cp $CURR_DIR/DEBIAN $ROOT/ -af
-    CONTROL=$ROOT/DEBIAN/control
-    mkdir $ROOT/usr/sbin -p
-    mkdir $ROOT/etc/smartdns/ -p
-    mkdir $ROOT/etc/default/ -p
-    mkdir $ROOT/lib/systemd/system/ -p
+	cp $CURR_DIR/DEBIAN $ROOT/ -af
+	CONTROL=$ROOT/DEBIAN/control
+	mkdir $ROOT/usr/sbin -p
+	mkdir $ROOT/etc/smartdns/ -p
+	mkdir $ROOT/etc/default/ -p
+	mkdir $ROOT/lib/systemd/system/ -p

-    sed -i "s/Version:.*/Version: $VER/" $ROOT/DEBIAN/control
-    sed -i "s/Architecture:.*/Architecture: $ARCH/" $ROOT/DEBIAN/control
-    chmod 0755 $ROOT/DEBIAN/prerm
+	sed -i "s/Version:.*/Version: $VER/" $ROOT/DEBIAN/control
+	sed -i "s/Architecture:.*/Architecture: $ARCH/" $ROOT/DEBIAN/control
+	chmod 0755 $ROOT/DEBIAN/prerm

-    cp $SMARTDNS_DIR/etc/smartdns/smartdns.conf  $ROOT/etc/smartdns/
-    cp $SMARTDNS_DIR/etc/default/smartdns  $ROOT/etc/default/
-    cp $SMARTDNS_DIR/systemd/smartdns.service $ROOT/lib/systemd/system/ 
-    cp $SMARTDNS_DIR/src/smartdns $ROOT/usr/sbin
-    chmod +x $ROOT/usr/sbin/smartdns
+	cp $SMARTDNS_DIR/etc/smartdns/smartdns.conf  $ROOT/etc/smartdns/
+	cp $SMARTDNS_DIR/etc/default/smartdns  $ROOT/etc/default/
+	cp $SMARTDNS_DIR/systemd/smartdns.service $ROOT/lib/systemd/system/ 
+	cp $SMARTDNS_DIR/src/smartdns $ROOT/usr/sbin
+	if [ $? -ne 0 ]; then
+		echo "copy smartdns file failed."
+		return 1
+	fi
+	chmod +x $ROOT/usr/sbin/smartdns

-    dpkg -b $ROOT $OUTPUTDIR/smartdns.$VER.$ARCH.deb
+	dpkg -b $ROOT $OUTPUTDIR/smartdns.$VER.$FILEARCH.deb

-    rm -fr $ROOT/
+	rm -fr $ROOT/
 }

 main()
 {
-	OPTS=`getopt -o o:h --long arch:,ver: \
+	OPTS=`getopt -o o:h --long arch:,ver:,filearch: \
 		-n  "" -- "$@"`

 	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
@@ -59,31 +77,38 @@ main()
 		--arch)
 			ARCH="$2"
 			shift 2;;
-        --ver)
-            VER="$2"
-            shift 2;;
+		--filearch)
+			FILEARCH="$2"
+			shift 2;;
+		--ver)
+			VER="$2"
+			shift 2;;
 		-o )
 			OUTPUTDIR="$2"
 			shift 2;;
-        -h | --help )
+		-h | --help )
 			showhelp
 			return 0
 			shift ;;
 		-- ) shift; break ;;
 		* ) break ;;
-  		esac
+		esac
 	done

-    if [ -z "$ARCH" ]; then
-        echo "please input arch."
-        return 1;
-    fi
+	if [ -z "$ARCH" ]; then
+		echo "please input arch."
+		return 1;
+	fi

-    if [ -z "$OUTPUTDIR" ]; then
-        OUTPUTDIR=$CURR_DIR;
-    fi
+	if [ -z "$FILEARCH" ]; then
+		FILEARCH=$ARCH
+	fi

-    build
+	if [ -z "$OUTPUTDIR" ]; then
+		OUTPUTDIR=$CURR_DIR;
+	fi
+
+	build
 }

 main $@
--- a/package/linux/make.sh
+++ b/package/linux/make.sh
@@ -0,0 +1,98 @@
+#!/bin/sh
+
+CURR_DIR=$(cd $(dirname $0);pwd)
+VER="`date +"1.%Y.%m.%d-%H%M"`"
+SMARTDNS_DIR=$CURR_DIR/../../
+SMARTDNS_BIN=$SMARTDNS_DIR/src/smartdns
+
+showhelp()
+{
+	echo "Usage: make [OPTION]"
+	echo "Options:"
+	echo " -o               output directory."
+	echo " --arch           archtecture."
+	echo " --ver            version."
+	echo " -h               show this message."
+}
+
+build()
+{
+	PKG_ROOT=/tmp/smartdns-linux
+	rm -fr $PKG_ROOT
+	mkdir -p $PKG_ROOT/smartdns
+	cd $PKG_ROOT/
+
+	# Generic x86_64
+	mkdir $PKG_ROOT/smartdns/src -p
+	mkdir $PKG_ROOT/smartdns/package -p
+	cd $SMARTDNS_DIR
+	cp package/windows $PKG_ROOT/smartdns/package/ -a
+	cp etc systemd *.md LICENSE install $PKG_ROOT/smartdns/ -a
+	cp src/smartdns $PKG_ROOT/smartdns/src -a
+	if [ $? -ne 0 ]; then
+		echo "copy smartdns file failed"
+		rm -fr $PKG_ROOT
+		exit 1
+	fi
+	cd $PKG_ROOT
+	tar  zcf $OUTPUTDIR/smartdns.$VER.$FILEARCH.tar.gz smartdns
+	if [ $? -ne 0 ]; then
+		echo "create package failed"
+		rm -fr $PKG_ROOT
+		exit 1
+	fi
+	cd $CURR_DIR
+	rm -fr $PKG_ROOT
+}
+
+main()
+{
+	OPTS=`getopt -o o:h --long arch:,ver:,filearch: \
+		-n  "" -- "$@"`
+
+	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
+
+	# Note the quotes around `$TEMP': they are essential!
+	eval set -- "$OPTS"
+
+	while true; do
+		case "$1" in
+		--arch)
+			ARCH="$2"
+			shift 2;;
+		--filearch)
+			FILEARCH="$2"
+			shift 2;;
+		--ver)
+			VER="$2"
+			shift 2;;
+		-o )
+			OUTPUTDIR="$2"
+			shift 2;;
+		-h | --help )
+			showhelp
+			return 0
+			shift ;;
+		-- ) shift; break ;;
+		* ) break ;;
+  		esac
+	done
+
+	if [ -z "$ARCH" ]; then
+		echo "please input arch."
+		return 1;
+	fi
+
+	if [ -z "$FILEARCH" ]; then
+		FILEARCH=$ARCH
+	fi
+
+	if [ -z "$OUTPUTDIR" ]; then
+		OUTPUTDIR=$CURR_DIR;
+	fi
+
+	build
+}
+
+main $@
+exit $?
--- a/package/luci-compat/control/control
+++ b/package/luci-compat/control/control
@@ -0,0 +1,8 @@
+Package: luci-app-smartdns
+Version: git-18.201.27126-7bf0367-1
+Depends: libc, smartdns
+Source: feeds/luci/applications/luci-app-smartdns
+Section: luci
+Architecture: all
+Installed-Size: 1040
+Description:  A smartdns server module
--- a/package/luci-compat/control/postinst
+++ b/package/luci-compat/control/postinst
@@ -0,0 +1,21 @@
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+[ "${IPKG_NO_SCRIPT}" = "1" ] && exit 0
+[ -x ${IPKG_INSTROOT}/lib/functions.sh ] || exit 0
+. ${IPKG_INSTROOT}/lib/functions.sh
+default_postinst $0 $@
--- a/package/luci-compat/control/postinst-pkg
+++ b/package/luci-compat/control/postinst-pkg
@@ -0,0 +1,4 @@
+[ -n "${IPKG_INSTROOT}" ] || {
+	(. /etc/uci-defaults/50_luci-smartdns) && rm -f /etc/uci-defaults/50_luci-smartdns
+	exit 0
+}
--- a/package/luci-compat/control/prerm
+++ b/package/luci-compat/control/prerm
@@ -0,0 +1,20 @@
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+[ -x ${IPKG_INSTROOT}/lib/functions.sh ] || exit 0
+. ${IPKG_INSTROOT}/lib/functions.sh
+default_prerm $0 $@
--- a/package/luci-compat/debian-binary
+++ b/package/luci-compat/debian-binary
@@ -0,0 +1 @@
+2.0
--- a/package/luci-compat/files/etc/uci-defaults/50_luci-smartdns
+++ b/package/luci-compat/files/etc/uci-defaults/50_luci-smartdns
@@ -0,0 +1,26 @@
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+uci -q batch <<-EOF >/dev/null
+	delete ucitrack.@smartdns[-1]
+	add ucitrack smartdns
+	set ucitrack.@smartdns[-1].init=smartdns
+	commit ucitrack
+EOF
+
+rm -f /tmp/luci-indexcache
+exit 0
--- a/package/luci-compat/files/luci/controller/smartdns.lua
+++ b/package/luci-compat/files/luci/controller/smartdns.lua
@@ -0,0 +1,83 @@
+--
+-- Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+--
+-- smartdns is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- smartdns is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module("luci.controller.smartdns", package.seeall)
+local smartdns = require "luci.model.smartdns"
+
+function index()
+	if not nixio.fs.access("/etc/config/smartdns") then
+		return
+	end
+
+	local page
+	page = entry({"admin", "services", "smartdns"}, cbi("smartdns/smartdns"), _("SmartDNS"), 60)
+	page.dependent = true
+	page = entry({"admin", "services", "smartdns", "status"}, call("act_status"))
+	page.leaf = true
+	page = entry({"admin", "services", "smartdns", "upstream"}, cbi("smartdns/upstream"), nil)
+	page.leaf = true
+end
+
+local function is_running()
+	return luci.sys.call("pidof smartdns >/dev/null") == 0
+end
+
+function act_status()
+	local e={}
+	local ipv6_server;
+	local redirect_mode="none";
+
+	e.ipv6_works = 2;
+	e.ipv4_works = 2;
+	e.ipv6_server = 1;
+	e.dnsmasq_forward = 0;
+	redirect_mode = smartdns.get_config_option("smartdns", "smartdns", "redirect", nil);
+	if redirect_mode == "redirect" then
+		e.redirect = 1
+	elseif redirect_mode == "dnsmasq-upstream" then
+		e.redirect = 2
+	else
+		e.redirect = 0
+	end
+
+	e.local_port = smartdns.get_config_option("smartdns", "smartdns", "port", nil);
+	ipv6_server = smartdns.get_config_option("smartdns", "smartdns", "ipv6_server", nil);
+	if e.redirect == 1 then 
+		if e.local_port ~= nil and e.local_port ~= "53" then
+			e.ipv4_works = luci.sys.call("iptables -t nat -nL PREROUTING 2>/dev/null | grep REDIRECT | grep dpt:53 | grep %q >/dev/null 2>&1" % e.local_port) == 0
+			if ipv6_server == "1" then
+				e.ipv6_works = luci.sys.call("ip6tables -t nat -nL PREROUTING 2>/dev/null| grep REDIRECT | grep dpt:53 | grep %q >/dev/null 2>&1" % e.local_port) == 0
+			else 
+				e.ipv6_works = 2
+			end
+		else
+			e.redirect = 0
+		end
+	elseif e.redirect == 2 then
+		local str;
+		local dnsmasq_server = luci.sys.exec("uci get dhcp.@dnsmasq[0].server")
+		if e.local_port ~= nil then
+			str = "127.0.0.1#" .. e.local_port 
+			if  string.sub(dnsmasq_server,1,string.len(str)) == str then 
+				e.dnsmasq_forward = 1
+			end
+		end
+	end
+	e.running = is_running()
+
+	luci.http.prepare_content("application/json")
+	luci.http.write_json(e)
+end
--- a/package/luci-compat/files/luci/i18n/smartdns.zh-cn.po
+++ b/package/luci-compat/files/luci/i18n/smartdns.zh-cn.po
@@ -0,0 +1,293 @@
+msgid ""
+msgstr "Content-Type: text/plain; charset=UTF-8\n"
+
+msgid "SmartDNS"
+msgstr "SmartDNS"
+
+msgid "SmartDNS is a local high-performance DNS server"
+msgstr "SmartDNS是一个本地高性能DNS服务器"
+
+msgid "SmartDNS Server"
+msgstr "SmartDNS 服务器"
+
+msgid "SmartDNS is a local high-performance DNS server, supports finding fastest IP, supports ad filtering, and supports avoiding DNS poisoning."
+msgstr "SmartDNS是一个本地高性能DNS服务器，支持返回最快IP，支持广告过滤。"
+
+msgid "Custom Settings"
+msgstr "自定义设置"
+
+msgid "General Settings"
+msgstr "基本设置"
+
+msgid "Settings"
+msgstr "设置"
+
+msgid "Advanced Settings"
+msgstr "高级设置"
+
+msgid "Generate Coredump"
+msgstr "生成coredump"
+
+msgid "Generate Coredump file when smartdns crash, coredump file is located at /tmp/smartdns.xxx.core."
+msgstr "当smartdns异常时生成coredump文件，coredump文件在/tmp/smartdns.xxx.core."
+
+msgid "Server Name"
+msgstr "服务器名称"
+
+msgid "Smartdns server name"
+msgstr "SmartDNS的服务器名称，默认为smartdns，留空为主机名"
+
+msgid "SmartDNS is a local dns server to find fastest ip."
+msgstr "本地高性能服务器，优化网络访问性能。"
+
+msgid "Enable or disable smartdns server"
+msgstr "启用或禁用SmartDNS服务"
+
+msgid "Local Port"
+msgstr "本地端口"
+
+msgid "Smartdns local server port"
+msgstr "SmartDNS本地服务端口"
+
+msgid "IPV4 53 Port Redirect Failure"
+msgstr "IPV4 53端口重定向失败"
+
+msgid "IPV6 53 Port Redirect Failure"
+msgstr "IPV6 53端口重定向失败"
+
+msgid "Dnsmasq Forwared To Smartdns Failure"
+msgstr "重定向dnsmasq到smartdns失败"
+
+msgid "TCP Server"
+msgstr "TCP服务器"
+
+msgid "Enable TCP DNS Server"
+msgstr "启用TCP服务器"
+
+msgid "IPV6 Server"
+msgstr "IPV6服务器"
+
+msgid "Enable IPV6 DNS Server"
+msgstr "启用IPV6服务器"
+
+msgid "Dual-stack IP Selection"
+msgstr "双栈IP优选"
+
+msgid "Enable IP selection between IPV4 and IPV6"
+msgstr "启用或禁用IPV4，IPV6间的IP优选策略。"
+
+msgid "Domain prefetch"
+msgstr "域名预加载"
+
+msgid "Enable domain prefetch, accelerate domain response speed."
+msgstr "启用域名预加载，加速域名响应速度。"
+
+msgid "Serve expired"
+msgstr "过期缓存服务"
+
+msgid "Attempts to serve old responses from cache with a TTL of 0 in the response without waiting for the actual resolution to finish."
+msgstr "查询性能优化，有请求时尝试回应TTL为0的过期记录，以避免查询等待。"
+
+msgid "Redirect"
+msgstr "重定向"
+
+msgid "SmartDNS redirect mode"
+msgstr "SmartDNS 重定向模式"
+
+msgid "Run as dnsmasq upstream server"
+msgstr "作为dnsmasq的上游服务器"
+
+msgid "Redirect 53 port to SmartDNS"
+msgstr "重定向53端口到SmartDNS"
+
+msgid "Cache Size"
+msgstr "缓存大小"
+
+msgid "DNS domain result cache size"
+msgstr "缓存DNS的结果，缓存大小，配置零则不缓存"
+
+msgid "Domain TTL"
+msgstr "域名TTL"
+
+msgid "TTL for all domain result."
+msgstr "设置所有域名的TTL值"
+
+msgid "Domain TTL Min"
+msgstr "域名TTL最小值"
+
+msgid "Minimum TTL for all domain result."
+msgstr "设置所有域名的TTL最小值"
+
+msgid "Domain TTL Max"
+msgstr "域名TTL最大值"
+
+msgid "Maximum TTL for all domain result."
+msgstr "设置所有域名的TTL最大值"
+
+msgid "smartdns custom settings"
+msgstr "smartdns 自定义设置，具体配置参数参考指导"
+
+msgid "Second Server Settings"
+msgstr "第二DNS服务器"
+
+msgid "Enable or disable second DNS server."
+msgstr "是否启用第二DNS服务器。"
+
+msgid "Skip Speed Check"
+msgstr "跳过测速"
+
+msgid "Do not check speed."
+msgstr "禁用测速。"
+
+msgid "Server Group"
+msgstr "服务器组"
+
+msgid "Query DNS through specific dns server group, such as office, home."
+msgstr "使用指定服务器组查询，比如office, home。"
+
+msgid "Skip Address Rules"
+msgstr "跳过address规则"
+
+msgid "Skip address rules."
+msgstr "跳过address规则。"
+
+msgid "Skip Nameserver Rule"
+msgstr "跳过Nameserver规则"
+
+msgid "Skip nameserver rules."
+msgstr "跳过Nameserver规则。"
+
+msgid "Skip Ipset Rule"
+msgstr "跳过ipset规则"
+
+msgid "Skip ipset rules."
+msgstr "跳过ipset规则。"
+
+msgid "Skip SOA Address Rule"
+msgstr "跳过address SOA(#)规则"
+
+msgid "Skip SOA address rules."
+msgstr "跳过address SOA(#)规则。"
+
+msgid "Skip Dualstack Selection"
+msgstr "跳过双栈优选"
+
+msgid "Skip Dualstack Selection."
+msgstr "跳过双栈优选。"
+
+msgid "Skip Cache"
+msgstr "跳过cache"
+
+msgid "Skip Cache."
+msgstr "跳过cache。"
+
+msgid "Upstream Servers"
+msgstr "上游服务器"
+
+msgid "Upstream Servers, support UDP, TCP protocol. Please configure multiple DNS servers, including multiple foreign DNS servers."
+msgstr "上游DNS服务器列表，支持UDP，TCP协议，请配置多个上游DNS服务器，包括多个国内外服务器"
+
+msgid "DNS Server Name"
+msgstr "DNS服务器名称"
+
+msgid "port"
+msgstr "端口"
+
+msgid "DNS Server port"
+msgstr "DNS服务器端口"
+
+msgid "DNS Server ip"
+msgstr "DNS服务器IP"
+
+msgid "type"
+msgstr "类型"
+
+msgid "DNS Server type"
+msgstr "协议类型"
+
+msgid "Domain Address"
+msgstr "域名地址"
+
+msgid "TLS Hostname Verify"
+msgstr "校验TLS主机名"
+
+msgid "Set TLS hostname to verify."
+msgstr "设置校验TLS主机名。"
+
+msgid "TLS SNI name"
+msgstr "TLS SNI名称"
+
+msgid "HTTP Host"
+msgstr "HTTP主机"
+
+msgid "Sets the server name indication for query."
+msgstr "设置查询时使用的服务器SNI名称。"
+
+msgid "Set the HTTP host used for the query. Use this parameter when the host of the URL address is an IP address."
+msgstr "设置查询时使用的HTTP主机，当URL地址的host是IP地址时，使用此参数。"
+
+msgid "Server Group"
+msgstr "服务器组"
+
+msgid "DNS Server group belongs to, used with nameserver, such as office, home."
+msgstr "DNS服务器所属组， 配合nameserver使用，例如：office，home。"
+
+msgid "IP Blacklist Filtering"
+msgstr "IP黑名单过滤"
+
+msgid "Anti Answer Forgery"
+msgstr "反回答伪造"
+
+msgid "Anti answer forgery, if DNS does not work properly after enabling, please turn off this feature"
+msgstr "反回答伪造，如果启用后DNS工作不正常，请关闭此功能。"
+
+msgid "Filtering IP with blacklist"
+msgstr "使用IP黑名单过滤"
+
+msgid "TLS SPKI Pinning"
+msgstr "TLS SPKI 指纹"
+
+msgid "Used to verify the validity of the TLS server, The value is Base64 encoded SPKI fingerprint, leaving blank to indicate that the validity of TLS is not verified."
+msgstr "用于校验TLS服务器的有效性，数值为Base64编码的SPKI指纹, 留空表示不验证TLS的合法性"
+
+msgid "Additional Server Args"
+msgstr "额外的服务器参数"
+
+msgid "Additional Args for upstream dns servers"
+msgstr "额外的上游DNS服务器参数"
+
+msgid "Upstream DNS Server Configuration"
+msgstr "上游DNS服务器配置"
+
+msgid "Set Specific domain ip address."
+msgstr "指定特定域名的IP地址"
+
+msgid "Specify an IP address to return for any host in the given domains, Queries in the domains are never forwarded and always replied to with the specified IP address which may be IPv4 or IPv6."
+msgstr "配置特定域名返回特定的IP地址，域名查询将不到上游服务器请求，直接返回配置的IP地址，可用于广告屏蔽。"
+
+msgid "IP Blacklist"
+msgstr "IP黑名单"
+
+msgid "Set Specific ip blacklist."
+msgstr "设置IP黑名单列表"
+
+msgid "Configure IP blacklists that will be filtered from the results of specific DNS server."
+msgstr "配置需要从指定域名服务器结果过滤的IP黑名单。"
+
+msgid "Technical Support"
+msgstr "技术支持"
+
+msgid "If you like this software, please buy me a cup of coffee."
+msgstr "如果本软件对你有帮助，请给作者加个蛋。"
+
+msgid "SmartDNS official website"
+msgstr "SmartDNS官方网站"
+
+msgid "open website"
+msgstr "打开网站"
+
+msgid "Donate to smartdns"
+msgstr "捐助smartdns项目"
+
+msgid "Donate"
+msgstr "捐助"
--- a/package/luci-compat/files/luci/model/cbi/smartdns/smartdns.lua
+++ b/package/luci-compat/files/luci/model/cbi/smartdns/smartdns.lua
@@ -1,4 +1,18 @@
-- Copyright 2018 Nick Peng (pymumu@gmail.com)
+--
+-- Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+--
+-- smartdns is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- smartdns is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.

 require ("nixio.fs")
 require ("luci.http")
@@ -16,6 +30,7 @@ s = m:section(TypedSection, "smartdns", translate("Settings"), translate("Genera
 s.anonymous = true

 s:tab("settings", translate("General Settings"))
+s:tab("seconddns", translate("Second Server Settings"))
 s:tab("custom", translate("Custom Settings"))

 ---- Eanble
@@ -68,6 +83,15 @@ o.cfgvalue    = function(...)
    return Flag.cfgvalue(...) or "0"
 end

+---- Domain Serve expired
+o = s:taboption("settings", Flag, "serve_expired", translate("Serve expired"), 
+	translate("Attempts to serve old responses from cache with a TTL of 0 in the response without waiting for the actual resolution to finish."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
 ---- Redirect
 o = s:taboption("settings", ListValue, "redirect", translate("Redirect"), translate("SmartDNS redirect mode"))
 o.placeholder = "none"
@@ -92,10 +116,100 @@ o.placeholder = "300"
 o.default     = 300
 o.optional    = true

+---- second dns server
 ---- rr-ttl-max
 o = s:taboption("settings", Value, "rr_ttl_max", translate("Domain TTL Max"), translate("Maximum TTL for all domain result."))
 o.rempty      = true

+---- Eanble
+o = s:taboption("seconddns", Flag, "seconddns_enabled", translate("Enable"), translate("Enable or disable second DNS server."))
+o.default     = o.disabled
+o.rempty      = false
+
+---- Port
+o = s:taboption("seconddns", Value, "seconddns_port", translate("Local Port"), translate("Smartdns local server port"))
+o.placeholder = 6553
+o.default     = 6553
+o.datatype    = "port"
+o.rempty      = false
+
+---- Enable TCP server
+o = s:taboption("seconddns", Flag, "seconddns_tcp_server", translate("TCP Server"), translate("Enable TCP DNS Server"))
+o.rmempty     = false
+o.default     = o.enabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "1"
+end
+
+---- dns server group
+o = s:taboption("seconddns", Value, "seconddns_server_group", translate("Server Group"), translate("Query DNS through specific dns server group, such as office, home."))
+o.rmempty     = true
+o.placeholder = "default"
+o.datatype    = "hostname"
+o.rempty      = true
+
+o = s:taboption("seconddns", Flag, "seconddns_no_speed_check", translate("Skip Speed Check"), translate("Do not check speed."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
+---- skip address rules
+o = s:taboption("seconddns", Flag, "seconddns_no_rule_addr", translate("Skip Address Rules"), translate("Skip address rules."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
+---- skip name server rules
+o = s:taboption("seconddns", Flag, "seconddns_no_rule_nameserver", translate("Skip Nameserver Rule"), translate("Skip nameserver rules."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
+---- skip ipset rules
+o = s:taboption("seconddns", Flag, "seconddns_no_rule_ipset", translate("Skip Ipset Rule"), translate("Skip ipset rules."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
+---- skip soa address rule
+o = s:taboption("seconddns", Flag, "seconddns_no_rule_soa", translate("Skip SOA Address Rule"), translate("Skip SOA address rules."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
+o = s:taboption("seconddns", Flag, "seconddns_no_dualstack_selection", translate("Skip Dualstack Selection"), translate("Skip Dualstack Selection."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
+---- skip cache
+o = s:taboption("seconddns", Flag, "seconddns_no_cache", translate("Skip Cache"), translate("Skip Cache."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
+---- Force AAAA SOA
+o = s:taboption("seconddns", Flag, "force_aaaa_soa", translate("Force AAAA SOA"), translate("Force AAAA SOA."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+
 ----- custom settings
 custom = s:taboption("custom", Value, "Custom Settings",
 	translate(""), 
@@ -163,13 +277,14 @@ o:value("https", translate("https"))
 o.default     = "udp"
 o.rempty      = false

-- Doman addresss
-s = m:section(TypedSection, "smartdns", translate("Domain Address"), 
-	translate("Set Specific domain ip address."))
-s.anonymous = true
+s = m:section(TypedSection, "smartdns", translate("Advanced Settings"), translate("Advanced Settings"));
+s.anonymous = true;

---- address
-addr = s:option(Value, "address",
+s:tab("domain-address", translate("Domain Address"), translate("Set Specific domain ip address."));
+s:tab("blackip-list", translate("IP Blacklist"), translate("Set Specific ip blacklist."));
+
+-- Doman addresss
+addr = s:taboption("domain-address", Value, "address",
 	translate(""), 
 	translate("Specify an IP address to return for any host in the given domains, Queries in the domains are never forwarded and always replied to with the specified IP address which may be IPv4 or IPv6."))

@@ -186,12 +301,7 @@ function addr.write(self, section, value)
 end

 -- IP Blacklist
-s = m:section(TypedSection, "smartdns", translate("IP Blacklist"), 
-	translate("Set Specific ip blacklist."))
-s.anonymous = true
-
---- blacklist
-addr = s:option(Value, "blacklist_ip",
+addr = s:taboption("blackip-list", Value, "blacklist_ip",
 	translate(""), 
 	translate("Configure IP blacklists that will be filtered from the results of specific DNS server."))

@@ -207,7 +317,7 @@ function addr.write(self, section, value)
 	nixio.fs.writefile("/etc/smartdns/blacklist-ip.conf", value)
 end

-- Doman addresss
+-- Technical Support
 s = m:section(TypedSection, "smartdns", translate("Technical Support"), 
 	translate("If you like this software, please buy me a cup of coffee."))
 s.anonymous = true
--- a/package/luci-compat/files/luci/model/cbi/smartdns/upstream.lua
+++ b/package/luci-compat/files/luci/model/cbi/smartdns/upstream.lua
@@ -1,3 +1,19 @@
+--
+-- Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+--
+-- smartdns is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- smartdns is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 local sid = arg[1]

 m = Map("smartdns", "%s - %s" %{translate("SmartDNS Server"), translate("Upstream DNS Server Configuration")})
@@ -39,23 +55,8 @@ o:value("https", translate("https"))
 o.default     = "udp"
 o.rempty      = false

---- SNI host name
-o = s:option(Value, "host_name", translate("TLS SNI name"), translate("Sets the server name indication"))
-o.default     = ""
-o.datatype    = "hostname"
-o.rempty      = true
-o:depends("type", "tls")
-o:depends("type", "https")
-
---- http host
-o = s:option(Value, "http_host", translate("HTTP Host"), translate("Set the HTTP host used for the query. Use this parameter when the host of the URL address is an IP address."))
-o.default     = ""
-o.datatype    = "hostname"
-o.rempty      = true
-o:depends("type", "https")
-
 ---- server group
-o = s:option(Value, "server_group", translate("Server Group"), translate("DNS Server group belongs to, used with nameserver, such as offlce, home."))
+o = s:option(Value, "server_group", translate("Server Group"), translate("DNS Server group belongs to, used with nameserver, such as office, home."))
 o.rmempty     = true
 o.placeholder = "default"
 o.datatype    = "hostname"
@@ -69,6 +70,29 @@ o.cfgvalue    = function(...)
    return Flag.cfgvalue(...) or "0"
 end

+---- TLS host verify
+o = s:option(Value, "tls_host_verify", translate("TLS Hostname Verify"), translate("Set TLS hostname to verify."))
+o.default     = ""
+o.datatype    = "string"
+o.rempty      = true
+o:depends("type", "tls")
+o:depends("type", "https")
+
+---- SNI host name
+o = s:option(Value, "host_name", translate("TLS SNI name"), translate("Sets the server name indication for query."))
+o.default     = ""
+o.datatype    = "hostname"
+o.rempty      = true
+o:depends("type", "tls")
+o:depends("type", "https")
+
+---- http host
+o = s:option(Value, "http_host", translate("HTTP Host"), translate("Set the HTTP host used for the query. Use this parameter when the host of the URL address is an IP address."))
+o.default     = ""
+o.datatype    = "hostname"
+o.rempty      = true
+o:depends("type", "https")
+
 ---- anti-Answer-Forgery
 -- o = s:option(Flag, "check_edns", translate("Anti Answer Forgery"), translate("Anti answer forgery, if DNS does not work properly after enabling, please turn off this feature"))
 -- o.rmempty     = false
@@ -86,7 +110,6 @@ o.rempty      = true
 o:depends("type", "tls")
 o:depends("type", "https")

-
 ---- other args
 o = s:option(Value, "addition_arg", translate("Additional Server Args"), translate("Additional Args for upstream dns servers"))
 o.default     = ""
--- a/package/luci-compat/files/luci/model/smartdns.lua
+++ b/package/luci-compat/files/luci/model/smartdns.lua
@@ -0,0 +1,31 @@
+--
+-- Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+--
+-- smartdns is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- smartdns is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require ("nixio.fs")
+require ("luci.http")
+require ("luci.dispatcher")
+require ("nixio.fs")
+
+local uci = require "luci.model.uci".cursor()
+
+module("luci.model.smartdns", package.seeall)
+
+function get_config_option(module, section, option, default)
+	return uci:get_first(module, section, option) or default
+end
+
+return m
+
--- a/package/luci-compat/files/luci/view/smartdns/smartdns_status.htm
+++ b/package/luci-compat/files/luci/view/smartdns/smartdns_status.htm
--- a/package/luci-compat/make.sh
+++ b/package/luci-compat/make.sh
@@ -0,0 +1,135 @@
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+CURR_DIR=$(cd $(dirname $0);pwd)
+
+VER="`date +"1.%Y.%m.%d-%H%M"`"
+SMARTDNS_DIR=$CURR_DIR/../../
+PO2LMO=
+
+showhelp()
+{
+	echo "Usage: make [OPTION]"
+	echo "Options:"
+	echo " -o               output directory."
+	echo " --arch           archtecture."
+	echo " --ver            version."
+	echo " -h               show this message."
+}
+
+build_tool()
+{
+	make -C $ROOT/tool/po2lmo -j 
+	PO2LMO="$ROOT/tool/po2lmo/src/po2lmo"
+
+}
+
+clean_tool()
+{
+	make -C $ROOT/tool/po2lmo clean
+}
+
+build()
+{
+
+	ROOT=/tmp/luci-app-smartdns
+	rm -fr $ROOT
+
+	mkdir -p $ROOT
+	cp $CURR_DIR/* $ROOT/ -af
+	cd $ROOT/
+	build_tool
+	mkdir $ROOT/root/usr/lib/lua/ -p
+	cp $ROOT/files/luci $ROOT/root/usr/lib/lua/ -af
+	
+	#Generate Language
+	$PO2LMO $ROOT/files/luci/i18n/smartdns.zh-cn.po $ROOT/root/usr/lib/lua/luci/i18n/smartdns.zh-cn.lmo
+	rm $ROOT/root/usr/lib/lua/luci/i18n/smartdns.zh-cn.po
+
+	cp $ROOT/files/etc $ROOT/root/ -af
+	INST_SIZE="`du -sb $ROOT/root/ | awk '{print $1}'`"
+	
+	sed -i "s/^Architecture.*/Architecture: all/g" $ROOT/control/control
+	sed -i "s/Version:.*/Version: $VER/" $ROOT/control/control
+
+	if [ ! -z "$INST_SIZE" ]; then
+		echo "Installed-Size: $INST_SIZE" >> $ROOT/control/control
+	fi
+
+	cd $ROOT/control
+	chmod +x *
+	tar zcf ../control.tar.gz ./
+	cd $ROOT
+
+	tar zcf $ROOT/data.tar.gz -C root .
+	tar zcf $OUTPUTDIR/luci-app-smartdns.$VER.$FILEARCH.ipk control.tar.gz data.tar.gz debian-binary
+
+	rm -fr $ROOT/
+}
+
+main()
+{
+	OPTS=`getopt -o o:h --long arch:,ver:,filearch: \
+		-n  "" -- "$@"`
+
+	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
+
+	# Note the quotes around `$TEMP': they are essential!
+	eval set -- "$OPTS"
+
+	while true; do
+		case "$1" in
+		--arch)
+			ARCH="$2"
+			shift 2;;
+		--filearch)
+			FILEARCH="$2"
+			shift 2;;
+		--ver)
+			VER="$2"
+			shift 2;;
+		-o )
+			OUTPUTDIR="$2"
+			shift 2;;
+		-h | --help )
+			showhelp
+			return 0
+			shift ;;
+		-- ) shift; break ;;
+		* ) break ;;
+		esac
+	done
+
+	if [ -z "$ARCH" ]; then
+		echo "please input arch."
+		return 1;
+	fi
+
+	if [ -z "$FILEARCH" ]; then
+		FILEARCH=$ARCH
+	fi
+
+	if [ -z "$OUTPUTDIR" ]; then
+		OUTPUTDIR=$CURR_DIR;
+	fi
+
+	build
+}
+
+main $@
+exit $?
+
+
--- a/package/luci-compat/tool/po2lmo/Makefile
+++ b/package/luci-compat/tool/po2lmo/Makefile
@@ -0,0 +1,12 @@
+
+INSTALL = install
+PREFIX  = /usr/bin
+
+po2lmo: src/po2lmo.o src/template_lmo.o
+	$(CC) $(LDFLAGS) -o src/po2lmo src/po2lmo.o src/template_lmo.o
+
+install:
+	$(INSTALL) -m 755 src/po2lmo $(PREFIX)
+
+clean:
+	$(RM) src/po2lmo src/*.o
--- a/package/luci-compat/tool/po2lmo/src/po2lmo.c
+++ b/package/luci-compat/tool/po2lmo/src/po2lmo.c
@@ -0,0 +1,247 @@
+/*
+ * lmo - Lua Machine Objects - PO to LMO conversion tool
+ *
+ *   Copyright (C) 2009-2012 Jo-Philipp Wich <xm@subsignal.org>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "template_lmo.h"
+
+static void die(const char *msg)
+{
+	fprintf(stderr, "Error: %s\n", msg);
+	exit(1);
+}
+
+static void usage(const char *name)
+{
+	fprintf(stderr, "Usage: %s input.po output.lmo\n", name);
+	exit(1);
+}
+
+static void print(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+	if( fwrite(ptr, size, nmemb, stream) == 0 )
+		die("Failed to write stdout");
+}
+
+static int extract_string(const char *src, char *dest, int len)
+{
+	int pos = 0;
+	int esc = 0;
+	int off = -1;
+
+	for( pos = 0; (pos < strlen(src)) && (pos < len); pos++ )
+	{
+		if( (off == -1) && (src[pos] == '"') )
+		{
+			off = pos + 1;
+		}
+		else if( off >= 0 )
+		{
+			if( esc == 1 )
+			{
+				switch (src[pos])
+				{
+				case '"':
+				case '\\':
+					off++;
+					break;
+				}
+				dest[pos-off] = src[pos];
+				esc = 0;
+			}
+			else if( src[pos] == '\\' )
+			{
+				dest[pos-off] = src[pos];
+				esc = 1;
+			}
+			else if( src[pos] != '"' )
+			{
+				dest[pos-off] = src[pos];
+			}
+			else
+			{
+				dest[pos-off] = '\0';
+				break;
+			}
+		}
+	}
+
+	return (off > -1) ? strlen(dest) : -1;
+}
+
+static int cmp_index(const void *a, const void *b)
+{
+	uint32_t x = ((const lmo_entry_t *)a)->key_id;
+	uint32_t y = ((const lmo_entry_t *)b)->key_id;
+
+	if (x < y)
+		return -1;
+	else if (x > y)
+		return 1;
+
+	return 0;
+}
+
+static void print_uint32(uint32_t x, FILE *out)
+{
+	uint32_t y = htonl(x);
+	print(&y, sizeof(uint32_t), 1, out);
+}
+
+static void print_index(void *array, int n, FILE *out)
+{
+	lmo_entry_t *e;
+
+	qsort(array, n, sizeof(*e), cmp_index);
+
+	for (e = array; n > 0; n--, e++)
+	{
+		print_uint32(e->key_id, out);
+		print_uint32(e->val_id, out);
+		print_uint32(e->offset, out);
+		print_uint32(e->length, out);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	char line[4096];
+	char key[4096];
+	char val[4096];
+	char tmp[4096];
+	int state  = 0;
+	int offset = 0;
+	int length = 0;
+	int n_entries = 0;
+	void *array = NULL;
+	lmo_entry_t *entry = NULL;
+	uint32_t key_id, val_id;
+
+	FILE *in;
+	FILE *out;
+
+	if( (argc != 3) || ((in = fopen(argv[1], "r")) == NULL) || ((out = fopen(argv[2], "w")) == NULL) )
+		usage(argv[0]);
+
+	memset(line, 0, sizeof(key));
+	memset(key, 0, sizeof(val));
+	memset(val, 0, sizeof(val));
+
+	while( (NULL != fgets(line, sizeof(line), in)) || (state >= 2 && feof(in)) )
+	{
+		if( state == 0 && strstr(line, "msgid \"") == line )
+		{
+			switch(extract_string(line, key, sizeof(key)))
+			{
+				case -1:
+					die("Syntax error in msgid");
+				case 0:
+					state = 1;
+					break;
+				default:
+					state = 2;
+			}
+		}
+		else if( state == 1 || state == 2 )
+		{
+			if( strstr(line, "msgstr \"") == line || state == 2 )
+			{
+				switch(extract_string(line, val, sizeof(val)))
+				{
+					case -1:
+						state = 4;
+						break;
+					default:
+						state = 3;
+				}
+			}
+			else
+			{
+				switch(extract_string(line, tmp, sizeof(tmp)))
+				{
+					case -1:
+						state = 2;
+						break;
+					default:
+						strcat(key, tmp);
+				}
+			}
+		}
+		else if( state == 3 )
+		{
+			switch(extract_string(line, tmp, sizeof(tmp)))
+			{
+				case -1:
+					state = 4;
+					break;
+				default:
+					strcat(val, tmp);
+			}
+		}
+
+		if( state == 4 )
+		{
+			if( strlen(key) > 0 && strlen(val) > 0 )
+			{
+				key_id = sfh_hash(key, strlen(key));
+				val_id = sfh_hash(val, strlen(val));
+
+				if( key_id != val_id )
+				{
+					n_entries++;
+					array = realloc(array, n_entries * sizeof(lmo_entry_t));
+					entry = (lmo_entry_t *)array + n_entries - 1;
+
+					if (!array)
+						die("Out of memory");
+
+					entry->key_id = key_id;
+					entry->val_id = val_id;
+					entry->offset = offset;
+					entry->length = strlen(val);
+
+					length = strlen(val) + ((4 - (strlen(val) % 4)) % 4);
+
+					print(val, length, 1, out);
+					offset += length;
+				}
+			}
+
+			state = 0;
+			memset(key, 0, sizeof(key));
+			memset(val, 0, sizeof(val));
+		}
+
+		memset(line, 0, sizeof(line));
+	}
+
+	print_index(array, n_entries, out);
+
+	if( offset > 0 )
+	{
+		print_uint32(offset, out);
+		fsync(fileno(out));
+		fclose(out);
+	}
+	else
+	{
+		fclose(out);
+		unlink(argv[2]);
+	}
+
+	fclose(in);
+	return(0);
+}
--- a/package/luci-compat/tool/po2lmo/src/template_lmo.c
+++ b/package/luci-compat/tool/po2lmo/src/template_lmo.c
@@ -0,0 +1,328 @@
+/*
+ * lmo - Lua Machine Objects - Base functions
+ *
+ *   Copyright (C) 2009-2010 Jo-Philipp Wich <xm@subsignal.org>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "template_lmo.h"
+
+/*
+ * Hash function from http://www.azillionmonkeys.com/qed/hash.html
+ * Copyright (C) 2004-2008 by Paul Hsieh
+ */
+
+uint32_t sfh_hash(const char *data, int len)
+{
+	uint32_t hash = len, tmp;
+	int rem;
+
+	if (len <= 0 || data == NULL) return 0;
+
+	rem = len & 3;
+	len >>= 2;
+
+	/* Main loop */
+	for (;len > 0; len--) {
+		hash  += sfh_get16(data);
+		tmp    = (sfh_get16(data+2) << 11) ^ hash;
+		hash   = (hash << 16) ^ tmp;
+		data  += 2*sizeof(uint16_t);
+		hash  += hash >> 11;
+	}
+
+	/* Handle end cases */
+	switch (rem) {
+		case 3: hash += sfh_get16(data);
+			hash ^= hash << 16;
+			hash ^= data[sizeof(uint16_t)] << 18;
+			hash += hash >> 11;
+			break;
+		case 2: hash += sfh_get16(data);
+			hash ^= hash << 11;
+			hash += hash >> 17;
+			break;
+		case 1: hash += *data;
+			hash ^= hash << 10;
+			hash += hash >> 1;
+	}
+
+	/* Force "avalanching" of final 127 bits */
+	hash ^= hash << 3;
+	hash += hash >> 5;
+	hash ^= hash << 4;
+	hash += hash >> 17;
+	hash ^= hash << 25;
+	hash += hash >> 6;
+
+	return hash;
+}
+
+uint32_t lmo_canon_hash(const char *str, int len)
+{
+	char res[4096];
+	char *ptr, prev;
+	int off;
+
+	if (!str || len >= sizeof(res))
+		return 0;
+
+	for (prev = ' ', ptr = res, off = 0; off < len; prev = *str, off++, str++)
+	{
+		if (isspace(*str))
+		{
+			if (!isspace(prev))
+				*ptr++ = ' ';
+		}
+		else
+		{
+			*ptr++ = *str;
+		}
+	}
+
+	if ((ptr > res) && isspace(*(ptr-1)))
+		ptr--;
+
+	return sfh_hash(res, ptr - res);
+}
+
+lmo_archive_t * lmo_open(const char *file)
+{
+	int in = -1;
+	uint32_t idx_offset = 0;
+	struct stat s;
+
+	lmo_archive_t *ar = NULL;
+
+	if (stat(file, &s) == -1)
+		goto err;
+
+	if ((in = open(file, O_RDONLY)) == -1)
+		goto err;
+
+	if ((ar = (lmo_archive_t *)malloc(sizeof(*ar))) != NULL)
+	{
+		memset(ar, 0, sizeof(*ar));
+
+		ar->fd     = in;
+		ar->size = s.st_size;
+
+		fcntl(ar->fd, F_SETFD, fcntl(ar->fd, F_GETFD) | FD_CLOEXEC);
+
+		if ((ar->mmap = mmap(NULL, ar->size, PROT_READ, MAP_SHARED, ar->fd, 0)) == MAP_FAILED)
+			goto err;
+
+		idx_offset = ntohl(*((const uint32_t *)
+		                     (ar->mmap + ar->size - sizeof(uint32_t))));
+
+		if (idx_offset >= ar->size)
+			goto err;
+
+		ar->index  = (lmo_entry_t *)(ar->mmap + idx_offset);
+		ar->length = (ar->size - idx_offset - sizeof(uint32_t)) / sizeof(lmo_entry_t);
+		ar->end    = ar->mmap + ar->size;
+
+		return ar;
+	}
+
+err:
+	if (in > -1)
+		close(in);
+
+	if (ar != NULL)
+	{
+		if ((ar->mmap != NULL) && (ar->mmap != MAP_FAILED))
+			munmap(ar->mmap, ar->size);
+
+		free(ar);
+	}
+
+	return NULL;
+}
+
+void lmo_close(lmo_archive_t *ar)
+{
+	if (ar != NULL)
+	{
+		if ((ar->mmap != NULL) && (ar->mmap != MAP_FAILED))
+			munmap(ar->mmap, ar->size);
+
+		close(ar->fd);
+		free(ar);
+
+		ar = NULL;
+	}
+}
+
+
+lmo_catalog_t *_lmo_catalogs = NULL;
+lmo_catalog_t *_lmo_active_catalog = NULL;
+
+int lmo_load_catalog(const char *lang, const char *dir)
+{
+	DIR *dh = NULL;
+	char pattern[16];
+	char path[PATH_MAX];
+	struct dirent *de = NULL;
+
+	lmo_archive_t *ar = NULL;
+	lmo_catalog_t *cat = NULL;
+
+	if (!lmo_change_catalog(lang))
+		return 0;
+
+	if (!dir || !(dh = opendir(dir)))
+		goto err;
+
+	if (!(cat = malloc(sizeof(*cat))))
+		goto err;
+
+	memset(cat, 0, sizeof(*cat));
+
+	snprintf(cat->lang, sizeof(cat->lang), "%s", lang);
+	snprintf(pattern, sizeof(pattern), "*.%s.lmo", lang);
+
+	while ((de = readdir(dh)) != NULL)
+	{
+		if (!fnmatch(pattern, de->d_name, 0))
+		{
+			snprintf(path, sizeof(path), "%s/%s", dir, de->d_name);
+			ar = lmo_open(path);
+
+			if (ar)
+			{
+				ar->next = cat->archives;
+				cat->archives = ar;
+			}
+		}
+	}
+
+	closedir(dh);
+
+	cat->next = _lmo_catalogs;
+	_lmo_catalogs = cat;
+
+	if (!_lmo_active_catalog)
+		_lmo_active_catalog = cat;
+
+	return 0;
+
+err:
+	if (dh) closedir(dh);
+	if (cat) free(cat);
+
+	return -1;
+}
+
+int lmo_change_catalog(const char *lang)
+{
+	lmo_catalog_t *cat;
+
+	for (cat = _lmo_catalogs; cat; cat = cat->next)
+	{
+		if (!strncmp(cat->lang, lang, sizeof(cat->lang)))
+		{
+			_lmo_active_catalog = cat;
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+static lmo_entry_t * lmo_find_entry(lmo_archive_t *ar, uint32_t hash)
+{
+	unsigned int m, l, r;
+	uint32_t k;
+
+	l = 0;
+	r = ar->length - 1;
+
+	while (1)
+	{
+		m = l + ((r - l) / 2);
+
+		if (r < l)
+			break;
+
+		k = ntohl(ar->index[m].key_id);
+
+		if (k == hash)
+			return &ar->index[m];
+
+		if (k > hash)
+		{
+			if (!m)
+				break;
+
+			r = m - 1;
+		}
+		else
+		{
+			l = m + 1;
+		}
+	}
+
+	return NULL;
+}
+
+int lmo_translate(const char *key, int keylen, char **out, int *outlen)
+{
+	uint32_t hash;
+	lmo_entry_t *e;
+	lmo_archive_t *ar;
+
+	if (!key || !_lmo_active_catalog)
+		return -2;
+
+	hash = lmo_canon_hash(key, keylen);
+
+	for (ar = _lmo_active_catalog->archives; ar; ar = ar->next)
+	{
+		if ((e = lmo_find_entry(ar, hash)) != NULL)
+		{
+			*out = ar->mmap + ntohl(e->offset);
+			*outlen = ntohl(e->length);
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+void lmo_close_catalog(const char *lang)
+{
+	lmo_archive_t *ar, *next;
+	lmo_catalog_t *cat, *prev;
+
+	for (prev = NULL, cat = _lmo_catalogs; cat; prev = cat, cat = cat->next)
+	{
+		if (!strncmp(cat->lang, lang, sizeof(cat->lang)))
+		{
+			if (prev)
+				prev->next = cat->next;
+			else
+				_lmo_catalogs = cat->next;
+
+			for (ar = cat->archives; ar; ar = next)
+			{
+				next = ar->next;
+				lmo_close(ar);
+			}
+
+			free(cat);
+			break;
+		}
+	}
+}
--- a/package/luci-compat/tool/po2lmo/src/template_lmo.h
+++ b/package/luci-compat/tool/po2lmo/src/template_lmo.h
@@ -0,0 +1,92 @@
+/*
+ * lmo - Lua Machine Objects - General header
+ *
+ *   Copyright (C) 2009-2012 Jo-Philipp Wich <xm@subsignal.org>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef _TEMPLATE_LMO_H_
+#define _TEMPLATE_LMO_H_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fnmatch.h>
+#include <dirent.h>
+#include <ctype.h>
+#include <limits.h>
+
+#if (defined(__GNUC__) && defined(__i386__))
+#define sfh_get16(d) (*((const uint16_t *) (d)))
+#else
+#define sfh_get16(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
+					   +(uint32_t)(((const uint8_t *)(d))[0]) )
+#endif
+
+
+struct lmo_entry {
+	uint32_t key_id;
+	uint32_t val_id;
+	uint32_t offset;
+	uint32_t length;
+} __attribute__((packed));
+
+typedef struct lmo_entry lmo_entry_t;
+
+
+struct lmo_archive {
+	int         fd;
+	int	        length;
+	uint32_t    size;
+	lmo_entry_t *index;
+	char        *mmap;
+	char		*end;
+	struct lmo_archive *next;
+};
+
+typedef struct lmo_archive lmo_archive_t;
+
+
+struct lmo_catalog {
+	char lang[6];
+	struct lmo_archive *archives;
+	struct lmo_catalog *next;
+};
+
+typedef struct lmo_catalog lmo_catalog_t;
+
+
+uint32_t sfh_hash(const char *data, int len);
+uint32_t lmo_canon_hash(const char *data, int len);
+
+lmo_archive_t * lmo_open(const char *file);
+void lmo_close(lmo_archive_t *ar);
+
+
+extern lmo_catalog_t *_lmo_catalogs;
+extern lmo_catalog_t *_lmo_active_catalog;
+
+int lmo_load_catalog(const char *lang, const char *dir);
+int lmo_change_catalog(const char *lang);
+int lmo_translate(const char *key, int keylen, char **out, int *outlen);
+void lmo_close_catalog(const char *lang);
+
+#endif
--- a/package/luci/control/postinst
+++ b/package/luci/control/postinst
@@ -1,4 +1,20 @@
 #!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 [ "${IPKG_NO_SCRIPT}" = "1" ] && exit 0
 [ -x ${IPKG_INSTROOT}/lib/functions.sh ] || exit 0
 . ${IPKG_INSTROOT}/lib/functions.sh
--- a/package/luci/control/prerm
+++ b/package/luci/control/prerm
@@ -1,4 +1,20 @@
 #!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 [ -x ${IPKG_INSTROOT}/lib/functions.sh ] || exit 0
 . ${IPKG_INSTROOT}/lib/functions.sh
 default_prerm $0 $@
--- a/package/luci/files/etc/uci-defaults/50_luci-smartdns
+++ b/package/luci/files/etc/uci-defaults/50_luci-smartdns
@@ -1,4 +1,19 @@
 #!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 uci -q batch <<-EOF >/dev/null
 	delete ucitrack.@smartdns[-1]
--- a/package/luci/files/luci/controller/smartdns.lua
+++ b/package/luci/files/luci/controller/smartdns.lua
@@ -1,7 +1,20 @@
-- Copyright 2018 Nick Peng (pymumu@gmail.com)
+--
+-- Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+--
+-- smartdns is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- smartdns is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.

 module("luci.controller.smartdns", package.seeall)
-local smartdns = require "luci.model.smartdns"

 function index()
 	if not nixio.fs.access("/etc/config/smartdns") then
@@ -9,61 +22,6 @@ function index()
 	end

 	local page
-	page = entry({"admin", "services", "smartdns"}, cbi("smartdns/smartdns"), _("SmartDNS"), 60)
+	page = entry({"admin", "services", "smartdns"}, view("smartdns/smartdns"), _("SmartDNS"), 60)
 	page.dependent = true
-	page = entry({"admin", "services", "smartdns", "status"}, call("act_status"))
-	page.leaf = true
-	page = entry({"admin", "services", "smartdns", "upstream"}, cbi("smartdns/upstream"), nil)
-	page.leaf = true
-end
-
-local function is_running()
-	return luci.sys.call("pidof smartdns >/dev/null") == 0
-end
-
-function act_status()
-	local e={}
-	local ipv6_server;
-	local redirect_mode="none";
-
-	e.ipv6_works = 2;
-	e.ipv4_works = 2;
-	e.ipv6_server = 1;
-	e.dnsmasq_forward = 0;
-	redirect_mode = smartdns.get_config_option("smartdns", "smartdns", "redirect", nil);
-	if redirect_mode == "redirect" then
-		e.redirect = 1
-	elseif redirect_mode == "dnsmasq-upstream" then
-		e.redirect = 2
-	else
-		e.redirect = 0
-	end
-
-	e.local_port = smartdns.get_config_option("smartdns", "smartdns", "port", nil);
-	ipv6_server = smartdns.get_config_option("smartdns", "smartdns", "ipv6_server", nil);
-	if e.redirect == 1 then 
-		if e.local_port ~= nil and e.local_port ~= "53" then
-			e.ipv4_works = luci.sys.call("iptables -t nat -nL PREROUTING 2>/dev/null | grep REDIRECT | grep dpt:53 | grep %q >/dev/null 2>&1" % e.local_port) == 0
-			if ipv6_server == "1" then
-				e.ipv6_works = luci.sys.call("ip6tables -t nat -nL PREROUTING 2>/dev/null| grep REDIRECT | grep dpt:53 | grep %q >/dev/null 2>&1" % e.local_port) == 0
-			else 
-				e.ipv6_works = 2
-			end
-		else
-			e.redirect = 0
-		end
-	elseif e.redirect == 2 then
-		local str;
-		local dnsmasq_server = luci.sys.exec("uci get dhcp.@dnsmasq[0].server")
-		if e.local_port ~= nil then
-			str = "127.0.0.1#" .. e.local_port 
-			if  string.sub(dnsmasq_server,1,string.len(str)) == str then 
-				e.dnsmasq_forward = 1
-			end
-		end
-	end
-	e.running = is_running()
-
-	luci.http.prepare_content("application/json")
-	luci.http.write_json(e)
 end
--- a/package/luci/files/luci/htdocs/luci-static/resources/view/smartdns/smartdns.js
+++ b/package/luci/files/luci/htdocs/luci-static/resources/view/smartdns/smartdns.js
@@ -0,0 +1,487 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+'use strict';
+'require fs';
+'require uci';
+'require form';
+'require rpc';
+
+var conf = 'smartdns';
+var callServiceList = rpc.declare({
+	object: 'service',
+	method: 'list',
+	params: ['name'],
+	expect: { '': {} }
+});
+
+function getPidOfSmartdns() {
+	return L.resolveDefault(callServiceList(conf), {})
+		.then(function (res) {
+			var isrunning = false;
+			try {
+				isrunning = res[conf]['instances']['smartdns']['running'];
+			} catch (e) { }
+			return isrunning;
+		});
+}
+
+function getIPTablesRedirect() {
+	return fs.exec('/usr/sbin/iptables', ['-t', 'nat', '-nL', 'PREROUTING']).then(function (res) {
+		if (res.code === 0) {
+			return res.stdout.trim();
+		} else {
+			return "";
+		}
+	});
+}
+
+function getIP6TablesRedirect() {
+	return fs.exec('/usr/sbin/ip6tables', ['-t', 'nat', '-nL', 'PREROUTING']).then(function (res) {
+		if (res.code === 0) {
+			return res.stdout.trim();
+		} else {
+			return "";
+		}
+	});
+}
+
+function smartdnsServiceStatus() {
+	return Promise.all([
+		getPidOfSmartdns(),
+		getIPTablesRedirect(),
+		getIP6TablesRedirect()
+	]);
+}
+
+function smartdnsRenderStatus(res) {
+	var renderHTML = "";
+	var isRunning = res[0];
+	var ipt = res[1];
+	var ip6t = res[2];
+
+	var serverPort = uci.get_first('smartdns', 'smartdns', 'port');
+	var redirectMode = uci.get_first('smartdns', 'smartdns', 'redirect');
+	var ipv6Enabled = uci.get_first('smartdns', 'smartdns', 'ipv6_server');
+
+	if (isRunning) {
+		renderHTML += "<b><font color=green>SmartDNS - " + _("RUNNING") + "</font></b></em>";
+	} else {
+		renderHTML += "<b><font color=red>SmartDNS - " + _("NOT RUNNING") + "</font></b></em>";
+		return renderHTML;
+	}
+
+	if (redirectMode === "dnsmasq-upstream") {
+		var matchLine = "127.0.0.1#" + serverPort;
+		var dnsmasqServer = uci.get_first('dhcp', 'dnsmasq', 'server') || "";
+
+		if (dnsmasqServer.indexOf(matchLine) < 0) {
+			renderHTML += "<br></br><b><font color=red>" + _("Dnsmasq Forwared To Smartdns Failure") + "</font></b>";
+		}
+	} else if (redirectMode === "redirect") {
+		var redirectRules = (ipt || '').split(/\n/).filter(function (rule) {
+			return rule.match(/REDIRECT/) && rule.match(/dpt:53/) && rule.match("ports " + serverPort);
+		});
+
+		if (redirectRules.length <= 0) {
+			renderHTML += "<br></br><b><font color=red>" + _("IPV4 53 Port Redirect Failure") + "</font></b>";
+			if (ipv6Enabled) {
+				var redirectRules = (ip6t || '').split(/\n/).filter(function (rule) {
+					return rule.match(/REDIRECT/) && rule.match(/dpt:53/) && rule.match("ports " + serverPort);
+				});
+				if (redirectRules.length <= 0) {
+					renderHTML += "<br></br><b><font color=red>" + _("IPV6 53 Port Redirect Failure") + "</font></b>";
+				}
+			}
+		}
+	}
+
+	return renderHTML;
+}
+
+return L.view.extend({
+	load: function () {
+		return Promise.all([
+			L.resolveDefault(fs.stat('/etc/config/smartdns'), null),
+			L.resolveDefault(fs.stat('/usr/sbin/smartdns'), {}),
+			uci.load('smartdns'),
+			uci.load('dhcp')
+		]);
+	},
+	render: function (stats) {
+		var m, s, o;
+
+		m = new form.Map('smartdns', _('SmartDNS'));
+		m.title = _("SmartDNS Server");
+		m.description = _("SmartDNS is a local high-performance DNS server, supports finding fastest IP, "
+			+ "supports ad filtering, and supports avoiding DNS poisoning.");
+
+		s = m.section(form.NamedSection, '_status');
+		s.anonymous = true;
+		s.render = function (section_id) {
+			L.Poll.add(function () {
+				return L.resolveDefault(smartdnsServiceStatus()).then(function (res) {
+					var view = document.getElementById("service_status");
+					view.innerHTML = smartdnsRenderStatus(res);
+				});
+			});
+
+			return E('div', { class: 'cbi-map' },
+				E('div', { class: 'cbi-section' }, [
+					E('div', { id: 'service_status' },
+						_('Collecting data ...'))
+				])
+			);
+		}
+
+		// Basic;
+		s = m.section(form.TypedSection, "smartdns", _("Settings"), _("General Settings"));
+		s.anonymous = true;
+
+		s.tab("settings", _("General Settings"));
+		s.tab("seconddns", _("Second Server Settings"));
+		s.tab("custom", _("Custom Settings"));
+
+		// Eanble;
+		o = s.taboption("settings", form.Flag, "enabled", _("Enable"), _("Enable or disable smartdns server"));
+		o.default = o.disabled;
+		o.rempty = false;
+
+		// server name;
+		o = s.taboption("settings", form.Value, "server_name", _("Server Name"), _("Smartdns server name"));
+		o.default = "smartdns";
+		o.datatype = "hostname";
+		o.rempty = false;
+
+		// Port;
+		o = s.taboption("settings", form.Value, "port", _("Local Port"), _("Smartdns local server port"));
+		o.placeholder = 6053;
+		o.default = 6053;
+		o.datatype = "port";
+		o.rempty = false;
+
+		// Enable TCP server;
+		o = s.taboption("settings", form.Flag, "tcp_server", _("TCP Server"), _("Enable TCP DNS Server"));
+		o.rmempty = false;
+		o.default = o.enabled;
+
+		// Support IPV6;
+		o = s.taboption("settings", form.Flag, "ipv6_server", _("IPV6 Server"), _("Enable IPV6 DNS Server"));
+		o.rmempty = false;
+		o.default = o.enabled;
+
+		// Support DualStack ip selection;
+		o = s.taboption("settings", form.Flag, "dualstack_ip_selection", _("Dual-stack IP Selection"),
+			_("Enable IP selection between IPV4 and IPV6"));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		o = s.taboption("settings", form.Flag, "prefetch_domain", _("Domain prefetch"),
+		_("Enable domain prefetch, accelerate domain response speed."));
+		o.rmempty = false;
+		o.default = o.disabled;
+		
+		// Domain Serve expired
+		o = s.taboption("settings", form.Flag, "serve_expired", _("Serve expired"),
+			_("Attempts to serve old responses from cache with a TTL of 0 in the response without waiting for the actual resolution to finish."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// Redirect;
+		o = s.taboption("settings", form.ListValue, "redirect", _("Redirect"), _("SmartDNS redirect mode"));
+		o.placeholder = "none";
+		o.value("none", _("none"));
+		o.value("dnsmasq-upstream", _("Run as dnsmasq upstream server"));
+		o.value("redirect", _("Redirect 53 port to SmartDNS"));
+		o.default = "none";
+		o.rempty = false;
+
+		// cache-size;
+		o = s.taboption("settings", form.Value, "cache_size", _("Cache Size"), _("DNS domain result cache size"));
+		o.rempty = true;
+
+		// rr-ttl;
+		o = s.taboption("settings", form.Value, "rr_ttl", _("Domain TTL"), _("TTL for all domain result."));
+		o.rempty = true;
+
+		// rr-ttl-min;
+		o = s.taboption("settings", form.Value, "rr_ttl_min", _("Domain TTL Min"),
+			_("Minimum TTL for all domain result."));
+		o.rempty = true;
+		o.placeholder = "300";
+		o.default = 300;
+		o.optional = true;
+
+		// second dns server;
+		// rr-ttl-max;
+		o = s.taboption("settings", form.Value, "rr_ttl_max", _("Domain TTL Max"),
+			_("Maximum TTL for all domain result."));
+		o.rempty = true;
+
+		// Eanble;
+		o = s.taboption("seconddns", form.Flag, "seconddns_enabled", _("Enable"),
+			_("Enable or disable second DNS server."));
+		o.default = o.disabled;
+		o.rempty = false;
+
+		// Port;
+		o = s.taboption("seconddns", form.Value, "seconddns_port", _("Local Port"), _("Smartdns local server port"));
+		o.placeholder = 6553;
+		o.default = 6553;
+		o.datatype = "port";
+		o.rempty = false;
+
+		// Enable TCP server;
+		o = s.taboption("seconddns", form.Flag, "seconddns_tcp_server", _("TCP Server"), _("Enable TCP DNS Server"));
+		o.rmempty = false;
+		o.default = o.enabled;
+
+		// dns server group;
+		o = s.taboption("seconddns", form.Value, "seconddns_server_group", _("Server Group"),
+			_("Query DNS through specific dns server group, such as office, home."));
+		o.rmempty = true;
+		o.placeholder = "default";
+		o.datatype = "hostname";
+		o.rempty = true;
+
+		o = s.taboption("seconddns", form.Flag, "seconddns_no_speed_check", _("Skip Speed Check"),
+			_("Do not check speed."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// skip address rules;
+		o = s.taboption("seconddns", form.Flag, "seconddns_no_rule_addr", _("Skip Address Rules"),
+			_("Skip address rules."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// skip name server rules;
+		o = s.taboption("seconddns", form.Flag, "seconddns_no_rule_nameserver", _("Skip Nameserver Rule"),
+			_("Skip nameserver rules."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// skip ipset rules;
+		o = s.taboption("seconddns", form.Flag, "seconddns_no_rule_ipset", _("Skip Ipset Rule"),
+			_("Skip ipset rules."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// skip soa address rule;
+		o = s.taboption("seconddns", form.Flag, "seconddns_no_rule_soa", _("Skip SOA Address Rule"),
+			_("Skip SOA address rules."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		o = s.taboption("seconddns", form.Flag, "seconddns_no_dualstack_selection", _("Skip Dualstack Selection"),
+			_("Skip Dualstack Selection."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// skip cache;
+		o = s.taboption("seconddns", form.Flag, "seconddns_no_cache", _("Skip Cache"), _("Skip Cache."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// Force AAAA SOA
+		o = s.taboption("seconddns", form.Flag, "force_aaaa_soa", _("Force AAAA SOA"), _("Force AAAA SOA."));
+		o.rmempty = false;
+		o.default = o.disabled;
+
+		// custom settings;
+		o = s.taboption("custom", form.TextValue, "custom_conf",
+			_(""),
+			_("smartdns custom settings"));
+
+		o.rows = 20;
+		o.cfgvalue = function (section_id) {
+			return fs.trimmed('/etc/smartdns/custom.conf');
+		};
+		o.write = function (section_id, formvalue) {
+			return fs.write('/etc/smartdns/custom.conf', formvalue.trim().replace(/\r\n/g, '\n') + '\n');
+		};
+
+		o = s.taboption("custom", form.Flag, "coredump", _("Generate Coredump"),
+			_("Generate Coredump file when smartdns crash, coredump file is located at /tmp/smartdns.xxx.core."));
+		o.rmempty = false;
+		o.default = o.disabled;
+		// Upstream servers;
+		s = m.section(form.GridSection, "server", _("Upstream Servers"),
+			_("Upstream Servers, support UDP, TCP protocol. Please configure multiple DNS servers, "
+				+ "including multiple foreign DNS servers."));
+		s.anonymous = true;
+		s.addremove = true;
+
+		s.tab('general', _('General Settings'));
+		s.tab('advanced', _('Advanced Settings'));
+
+		// enable flag;
+		o = s.taboption("general", form.Flag, "enabled", _("Enable"), _("Enable"));
+		o.rmempty = false;
+		o.default = o.enabled;
+		o.editable = true;
+
+		// name;
+		o = s.taboption("general", form.Value, "name", _("DNS Server Name"), _("DNS Server Name"));
+
+		// IP address;
+		o = s.taboption("general", form.Value, "ip", _("ip"), _("DNS Server ip"));
+		o.datatype = "or(ipaddr, string)";
+		o.rmempty = false;
+
+		// port;
+		o = s.taboption("general", form.Value, "port", _("port"), _("DNS Server port"));
+		o.placeholder = "default";
+		o.datatype = "port";
+		o.rempty = true;
+		o.depends("type", "udp");
+		o.depends("type", "tcp");
+		o.depends("type", "tls");
+
+		// type;
+		o = s.taboption("general", form.ListValue, "type", _("type"), _("DNS Server type"));
+		o.placeholder = "udp";
+		o.value("udp", _("udp"));
+		o.value("tcp", _("tcp"));
+		o.value("tls", _("tls"));
+		o.value("https", _("https"));
+		o.default = "udp";
+		o.rempty = false;
+
+		// Advanced Options
+		// server group
+		o = s.taboption("advanced", form.Value, "server_group", _("Server Group"), _("DNS Server group belongs to, "
+			+ "used with nameserver, such as office, home."))
+		o.rmempty = true
+		o.placeholder = "default"
+		o.datatype = "hostname"
+		o.rempty = true
+		o.modalonly = true;
+
+		// blacklist_ip
+		o = s.taboption("advanced", form.Flag, "blacklist_ip", _("IP Blacklist Filtering"),
+			_("Filtering IP with blacklist"))
+		o.rmempty = false
+		o.default = o.disabled
+		o.modalonly = true;
+
+		// TLS host verify
+		o = s.taboption("advanced", form.Value, "tls_host_verify", _("TLS Hostname Verify"),
+			_("Set TLS hostname to verify."))
+		o.default = ""
+		o.datatype = "string"
+		o.rempty = true
+		o.modalonly = true;
+		o.depends("type", "tls")
+		o.depends("type", "https")
+
+		// SNI host name
+		o = s.taboption("advanced", form.Value, "host_name", _("TLS SNI name"),
+			_("Sets the server name indication for query."))
+		o.default = ""
+		o.datatype = "hostname"
+		o.rempty = true
+		o.modalonly = true;
+		o.depends("type", "tls")
+		o.depends("type", "https")
+
+		// http host
+		o = s.taboption("advanced", form.Value, "http_host", _("HTTP Host"),
+			_("Set the HTTP host used for the query. Use this parameter when the host of the URL address is an IP address."))
+		o.default = ""
+		o.datatype = "hostname"
+		o.rempty = true
+		o.modalonly = true;
+		o.depends("type", "https")
+
+		// SPKI pin
+		o = s.taboption("advanced", form.Value, "spki_pin", _("TLS SPKI Pinning"),
+			_("Used to verify the validity of the TLS server, The value is Base64 encoded SPKI fingerprint, "
+				+ "leaving blank to indicate that the validity of TLS is not verified."))
+		o.default = ""
+		o.datatype = "string"
+		o.rempty = true
+		o.modalonly = true;
+		o.depends("type", "tls")
+		o.depends("type", "https")
+
+		// other args
+		o = s.taboption("advanced", form.Value, "addition_arg", _("Additional Server Args"),
+			_("Additional Args for upstream dns servers"))
+		o.default = ""
+		o.rempty = true
+		o.modalonly = true;
+
+		// Doman addresss;
+		s = m.section(form.TypedSection, "smartdns", _("Advanced Settings"), _("Advanced Settings"));
+		s.anonymous = true;
+
+		s.tab("domain-address", _("Domain Address"), _("Set Specific domain ip address."));
+		s.tab("blackip-list", _("IP Blacklist"), _("Set Specific ip blacklist."));
+
+		o = s.taboption("domain-address", form.TextValue, "address_conf",
+			_(""),
+			_("Specify an IP address to return for any host in the given domains, Queries in the domains are never "
+				+ "forwarded and always replied to with the specified IP address which may be IPv4 or IPv6."));
+		o.rows = 20;
+		o.cfgvalue = function (section_id) {
+			return fs.trimmed('/etc/smartdns/address.conf');
+		};
+		o.write = function (section_id, formvalue) {
+			return fs.write('/etc/smartdns/address.conf', formvalue.trim().replace(/\r\n/g, '\n') + '\n');
+		};
+
+		// IP Blacklist;
+		// blacklist;
+		o = s.taboption("blackip-list", form.TextValue, "blackip_ip_conf",
+			_(""),
+			_("Configure IP blacklists that will be filtered from the results of specific DNS server."));
+		o.rows = 20;
+		o.cfgvalue = function (section_id) {
+			return fs.trimmed('/etc/smartdns/blacklist-ip.conf');
+		};
+		o.write = function (section_id, formvalue) {
+			return fs.write('/etc/smartdns/blacklist-ip.conf', formvalue.trim().replace(/\r\n/g, '\n') + '\n');
+		};
+
+		// Doman addresss;
+		s = m.section(form.TypedSection, "smartdns", _("Technical Support"),
+			_("If you like this software, please buy me a cup of coffee."));
+		s.anonymous = true;
+
+		o = s.option(form.Button, "web");
+		o.title = _("SmartDNS official website");
+		o.inputtitle = _("open website");
+		o.inputstyle = "apply";
+		o.onclick = function () {
+			window.open("https://pymumu.github.io/smartdns", '_blank');
+		};
+
+		o = s.option(form.Button, "Donate");
+		o.title = _("Donate to smartdns");
+		o.inputtitle = _("Donate");
+		o.inputstyle = "apply";
+		o.onclick = function () {
+			window.open("https://pymumu.github.io/smartdns/#donate", '_blank');
+		};
+
+		return m.render();
+	}
+});
+
--- a/package/luci/files/luci/i18n/smartdns.zh-cn.po
+++ b/package/luci/files/luci/i18n/smartdns.zh-cn.po
@@ -16,6 +16,21 @@ msgstr "SmartDNS是一个本地高性能DNS服务器，支持返回最快IP，
 msgid "Custom Settings"
 msgstr "自定义设置"

+msgid "General Settings"
+msgstr "基本设置"
+
+msgid "Settings"
+msgstr "设置"
+
+msgid "Advanced Settings"
+msgstr "高级设置"
+
+msgid "RUNNING"
+msgstr "运行中"
+
+msgid "NOT RUNNING"
+msgstr "未运行"
+
 msgid "Generate Coredump"
 msgstr "生成coredump"

@@ -73,6 +88,12 @@ msgstr "域名预加载"
 msgid "Enable domain prefetch, accelerate domain response speed."
 msgstr "启用域名预加载，加速域名响应速度。"

+msgid "Serve expired"
+msgstr "缓存过期服务"
+
+msgid "Attempts to serve old responses from cache with a TTL of 0 in the response without waiting for the actual resolution to finish."
+msgstr "查询性能优化，有请求时尝试回应TTL为0的过期记录，以避免查询等待。"
+
 msgid "Redirect"
 msgstr "重定向"

@@ -112,6 +133,66 @@ msgstr "设置所有域名的TTL最大值"
 msgid "smartdns custom settings"
 msgstr "smartdns 自定义设置，具体配置参数参考指导"

+msgid "Second Server Settings"
+msgstr "第二DNS服务器"
+
+msgid "Enable or disable second DNS server."
+msgstr "是否启用第二DNS服务器。"
+
+msgid "Skip Speed Check"
+msgstr "跳过测速"
+
+msgid "Do not check speed."
+msgstr "禁用测速。"
+
+msgid "Server Group"
+msgstr "服务器组"
+
+msgid "Query DNS through specific dns server group, such as office, home."
+msgstr "使用指定服务器组查询，比如office, home。"
+
+msgid "Skip Address Rules"
+msgstr "跳过address规则"
+
+msgid "Skip address rules."
+msgstr "跳过address规则。"
+
+msgid "Skip Nameserver Rule"
+msgstr "跳过Nameserver规则"
+
+msgid "Skip nameserver rules."
+msgstr "跳过Nameserver规则。"
+
+msgid "Skip Ipset Rule"
+msgstr "跳过ipset规则"
+
+msgid "Skip ipset rules."
+msgstr "跳过ipset规则。"
+
+msgid "Skip SOA Address Rule"
+msgstr "跳过address SOA(#)规则"
+
+msgid "Skip SOA address rules."
+msgstr "跳过address SOA(#)规则。"
+
+msgid "Skip Dualstack Selection"
+msgstr "跳过双栈优选"
+
+msgid "Skip Dualstack Selection."
+msgstr "跳过双栈优选。"
+
+msgid "Skip Cache"
+msgstr "跳过cache"
+
+msgid "Skip Cache."
+msgstr "跳过cache。"
+
+msgid "Force AAAA SOA"
+msgstr "停用IPV6地址解析"
+
+msgid "Force AAAA SOA."
+msgstr "停用IPV6地址解析。"
+
 msgid "Upstream Servers"
 msgstr "上游服务器"

@@ -139,14 +220,20 @@ msgstr "协议类型"
 msgid "Domain Address"
 msgstr "域名地址"

+msgid "TLS Hostname Verify"
+msgstr "校验TLS主机名"
+
+msgid "Set TLS hostname to verify."
+msgstr "设置校验TLS主机名。"
+
 msgid "TLS SNI name"
 msgstr "TLS SNI名称"

 msgid "HTTP Host"
 msgstr "HTTP主机"

-msgid "Sets the server name indication"
-msgstr "设置服务器SNI名称"
+msgid "Sets the server name indication for query."
+msgstr "设置查询时使用的服务器SNI名称。"

 msgid "Set the HTTP host used for the query. Use this parameter when the host of the URL address is an IP address."
 msgstr "设置查询时使用的HTTP主机，当URL地址的host是IP地址时，使用此参数。"
@@ -154,8 +241,8 @@ msgstr "设置查询时使用的HTTP主机，当URL地址的host是IP地址时
 msgid "Server Group"
 msgstr "服务器组"

-msgid "DNS Server group belongs to, used with nameserver, such as offlce, home."
-msgsr "DNS服务器所属组， 配合nameserver使用，例如：office，home。"
+msgid "DNS Server group belongs to, used with nameserver, such as office, home."
+msgstr "DNS服务器所属组， 配合nameserver使用，例如：office，home。"

 msgid "IP Blacklist Filtering"
 msgstr "IP黑名单过滤"
@@ -216,7 +303,3 @@ msgstr "捐助smartdns项目"

 msgid "Donate"
 msgstr "捐助"
-
-
-
-
--- a/package/luci/files/luci/model/smartdns.lua
+++ b/package/luci/files/luci/model/smartdns.lua
@@ -1,17 +0,0 @@
-- Copyright 2018 Nick Peng (pymumu@gmail.com)
-
-require ("nixio.fs")
-require ("luci.http")
-require ("luci.dispatcher")
-require ("nixio.fs")
-
-local uci = require "luci.model.uci".cursor()
-
-module("luci.model.smartdns", package.seeall)
-
-function get_config_option(module, section, option, default)
-	return uci:get_first(module, section, option) or default
-end
-
-return m
-
--- a/package/luci/files/usr/share/rpcd/acl.d/luci-app-smartdns.json
+++ b/package/luci/files/usr/share/rpcd/acl.d/luci-app-smartdns.json
@@ -0,0 +1,21 @@
+{
+	"luci-app-smartdns": {
+		"description": "Grant access to LuCI app smartdns",
+		"read": {
+			"file": {
+				"/etc/smartdns/*": [ "read" ],
+				"/usr/sbin/iptables": [ "exec" ],
+				"/usr/sbin/ip6tables": [ "exec" ],
+				"/usr/sbin/smartdns": [ "exec" ]
+			},
+			"ubus": {
+				"service": [ "list" ]
+			}
+		},
+		"write": {
+			"file": {
+				"/etc/smartdns/*": [ "write" ]
+			}
+		}
+	}
+}
--- a/package/luci/make.sh
+++ b/package/luci/make.sh
@@ -1,5 +1,19 @@
-#/bin/sh
-
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 CURR_DIR=$(cd $(dirname $0);pwd)

 VER="`date +"1.%Y.%m.%d-%H%M"`"
@@ -12,63 +26,72 @@ showhelp()
 	echo "Options:"
 	echo " -o               output directory."
 	echo " --arch           archtecture."
-    echo " --ver            version."
+	echo " --ver            version."
 	echo " -h               show this message."
 }

 build_tool()
 {
-    make -C $ROOT/tool/po2lmo -j 
-    PO2LMO="$ROOT/tool/po2lmo/src/po2lmo"
+	make -C $ROOT/tool/po2lmo -j 
+	PO2LMO="$ROOT/tool/po2lmo/src/po2lmo"

 }

 clean_tool()
 {
-    make -C $ROOT/tool/po2lmo clean
+	make -C $ROOT/tool/po2lmo clean
 }

 build()
 {

-    ROOT=/tmp/luci-app-smartdns
-    rm -fr $ROOT
+	ROOT=/tmp/luci-app-smartdns
+	rm -fr $ROOT

-    mkdir -p $ROOT
-    cp $CURR_DIR/* $ROOT/ -af
-    cd $ROOT/
-    build_tool
-    mkdir $ROOT/root/usr/lib/lua/ -p
-    cp $ROOT/files/luci $ROOT/root/usr/lib/lua/ -af
+	mkdir -p $ROOT
+	cp $CURR_DIR/* $ROOT/ -af
+	cd $ROOT/
+	build_tool
 	
-    #Generate Language
-    $PO2LMO $ROOT/files/luci/i18n/smartdns.zh-cn.po $ROOT/root/usr/lib/lua/luci/i18n/smartdns.zh-cn.lmo
-    rm $ROOT/root/usr/lib/lua/luci/i18n/smartdns.zh-cn.po
+	mkdir $ROOT/root/usr/lib/lua/ -p
+	mkdir $ROOT/root/usr/lib/lua/luci/controller/ -p
+	mkdir $ROOT/root/usr/share/rpcd/acl.d/ -p
+	cp $ROOT/files/luci/controller/* $ROOT/root/usr/lib/lua/luci/controller/ -avf
+	cp $ROOT/files/luci/i18n $ROOT/root/usr/lib/lua/luci/ -avf
+	cp $ROOT/files/luci/view $ROOT/root/usr/lib/lua/luci/ -avf

-    cp $ROOT/files/etc $ROOT/root/ -af
-    INST_SIZE="`du -sb $ROOT/root/ | awk '{print $1}'`"
+	mkdir $ROOT/root/www/luci-static/resources/view -p
+	cp $ROOT/files/luci/htdocs/luci-static/resources/view/* $ROOT/root/www/luci-static/resources/view/ -avf

-    sed -i "s/^Architecture.*/Architecture: $ARCH/g" $ROOT/control/control
-    sed -i "s/Version:.*/Version: $VER/" $ROOT/control/control
+	#Generate Language
+	$PO2LMO $ROOT/files/luci/i18n/smartdns.zh-cn.po $ROOT/root/usr/lib/lua/luci/i18n/smartdns.zh-cn.lmo
+	rm $ROOT/root/usr/lib/lua/luci/i18n/smartdns.zh-cn.po

-    if [ ! -z "$INST_SIZE" ]; then
-        echo "Installed-Size: $INST_SIZE" >> $ROOT/control/control
-    fi
+	cp $ROOT/files/etc $ROOT/root/ -avf
+	cp $ROOT/files/usr $ROOT/root/ -avf
+	INST_SIZE="`du -sb $ROOT/root/ | awk '{print $1}'`"
 	
-    cd $ROOT/control
-    chmod +x *
-    tar zcf ../control.tar.gz ./
-    cd $ROOT
+	sed -i "s/^Architecture.*/Architecture: all/g" $ROOT/control/control
+	sed -i "s/Version:.*/Version: $VER/" $ROOT/control/control

-    tar zcf $ROOT/data.tar.gz -C root .
-    tar zcf $OUTPUTDIR/luci-app-smartdns.$VER.$ARCH.ipk control.tar.gz data.tar.gz debian-binary
+	if [ ! -z "$INST_SIZE" ]; then
+		echo "Installed-Size: $INST_SIZE" >> $ROOT/control/control
+	fi

-    rm -fr $ROOT/
+	cd $ROOT/control
+	chmod +x *
+	tar zcf ../control.tar.gz ./
+	cd $ROOT
+
+	tar zcf $ROOT/data.tar.gz -C root .
+	tar zcf $OUTPUTDIR/luci-app-smartdns.$VER.$FILEARCH.ipk control.tar.gz data.tar.gz debian-binary
+
+	rm -fr $ROOT/
 }

 main()
 {
-	OPTS=`getopt -o o:h --long arch:,ver: \
+	OPTS=`getopt -o o:h --long arch:,ver:,filearch: \
 		-n  "" -- "$@"`

 	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
@@ -81,31 +104,38 @@ main()
 		--arch)
 			ARCH="$2"
 			shift 2;;
-        --ver)
-            VER="$2"
-            shift 2;;
+		--filearch)
+			FILEARCH="$2"
+			shift 2;;
+		--ver)
+			VER="$2"
+			shift 2;;
 		-o )
 			OUTPUTDIR="$2"
 			shift 2;;
-        -h | --help )
+		-h | --help )
 			showhelp
 			return 0
 			shift ;;
 		-- ) shift; break ;;
 		* ) break ;;
-  		esac
+		esac
 	done

-    if [ -z "$ARCH" ]; then
-        echo "please input arch."
-        return 1;
-    fi
+	if [ -z "$ARCH" ]; then
+		echo "please input arch."
+		return 1;
+	fi

-    if [ -z "$OUTPUTDIR" ]; then
-        OUTPUTDIR=$CURR_DIR;
-    fi
+	if [ -z "$FILEARCH" ]; then
+		FILEARCH=$ARCH
+	fi

-    build
+	if [ -z "$OUTPUTDIR" ]; then
+		OUTPUTDIR=$CURR_DIR;
+	fi
+
+	build
 }

 main $@
--- a/package/openwrt/Makefile
+++ b/package/openwrt/Makefile
@@ -1,34 +1,59 @@
+#
+# Copyright (c) 2018-2019 Nick Peng (pymumu@gmail.com)
+# This is free software, licensed under the GNU General Public License v3.
+#
+
 include $(TOPDIR)/rules.mk

-PKG_NAME:=smarttdns
-PKG_VERSION:=2018.7.1.1607
-PKG_RELEASE:=$(PKG_SOURCE_VERSION)
+PKG_NAME:=smartdns
+PKG_VERSION:=1.2019.28
+PKG_RELEASE:=1

-PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION)
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_URL:=https://www.github.com/pymumu/smartdns.git
+PKG_SOURCE_VERSION:=982002e836e486fb4e360bc10e84e7e7197caf46
+PKG_MIRROR_HASH:=ae889b521ecf114660ce5597af5c361f5970a7dcb75dadf61b938ba3d2baba54
+
+PKG_MAINTAINER:=Nick Peng <pymumu@gmail.com>
+PKG_LICENSE:=GPL-3.0-or-later
+PKG_LICENSE_FILES:=LICENSE
+
+PKG_BUILD_PARALLEL:=1

 include $(INCLUDE_DIR)/package.mk

+MAKE_VARS += VER=$(PKG_VERSION) 
+MAKE_PATH:=src
+
 define Package/smartdns
-	SECTION:=net
-	CATEGORY:=Network
-	TITLE:=smartdns
-	URL:=https://github.com/pymumu/smartdns
-	MAINTAINER:=Nick Peng <pymumu@gmail.com>
-	DEPENDS:=
+  SECTION:=net
+  CATEGORY:=Network
+  TITLE:=smartdns server
+  DEPENDS:=+libpthread +libopenssl
+  URL:=https://www.github.com/pymumu/smartdns/
 endef

 define Package/smartdns/description
-	smartdns server, find fastest ip.
+SmartDNS is a local DNS server which accepts DNS query requests from local network clients,
+get DNS query results from multiple upstream DNS servers concurrently, and returns the fastest IP to clients.
+Unlike dnsmasq's all-servers, smartdns returns the fastest IP. 
 endef

-define Build/Prepare
-	mkdir -p $(PKG_BUILD_DIR)
-	cp -r ../* $(PKG_BUILD_DIR)
+define Package/smartdns/conffiles
+/etc/config/smartdns
+/etc/smartdns/address.conf
+/etc/smartdns/blacklist-ip.conf
+/etc/smartdns/custom.conf
 endef

 define Package/smartdns/install
-	$(INSTALL_DIR) $(1)/usr/sbin
-	$(INSTALL_BIN) $(PKG_BUILD_DIR)/smartdns $(1)/usr/sbin
+	$(INSTALL_DIR) $(1)/usr/sbin $(1)/etc/config $(1)/etc/init.d $(1)/etc/smartdns
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/src/smartdns $(1)/usr/sbin/smartdns
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/package/openwrt/files/etc/init.d/smartdns $(1)/etc/init.d/smartdns
+	$(INSTALL_CONF) $(PKG_BUILD_DIR)/package/openwrt/address.conf $(1)/etc/smartdns/address.conf
+	$(INSTALL_CONF) $(PKG_BUILD_DIR)/package/openwrt/blacklist-ip.conf $(1)/etc/smartdns/blacklist-ip.conf
+	$(INSTALL_CONF) $(PKG_BUILD_DIR)/package/openwrt/custom.conf $(1)/etc/smartdns/custom.conf
+	$(INSTALL_CONF) $(PKG_BUILD_DIR)/package/openwrt/files/etc/config/smartdns $(1)/etc/config/smartdns
 endef

-$(eval $(call BuildPackage, smartdns))
+$(eval $(call BuildPackage,smartdns))
--- a/package/openwrt/control/postinst
+++ b/package/openwrt/control/postinst
@@ -1,4 +1,19 @@
 #!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 chmod +x /usr/sbin/smartdns
 chmod +x /etc/init.d/smartdns
--- a/package/openwrt/control/prerm
+++ b/package/openwrt/control/prerm
@@ -1,4 +1,20 @@
 #!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 . ${IPKG_INSTROOT}/lib/functions.sh
 default_prerm $0 $@
 rm /var/etc/smartdns.conf -f
--- a/package/openwrt/files/etc/init.d/smartdns
+++ b/package/openwrt/files/etc/init.d/smartdns
@@ -1,5 +1,19 @@
 #!/bin/sh /etc/rc.common
-# Copyright (C) 2018 Nick Peng (pymumu@gmail.com)
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 START=99
 NAME=smartdns
@@ -8,7 +22,6 @@ SERVICE_USE_PID=1
 SERVICE_WRITE_PID=1
 SERVICE_DAEMONIZE=1
 SERVICE_PID_FILE="/var/run/smartdns.pid"
-BASECONFIGFILE="/etc/smartdns/smartdns.conf"
 SMARTDNS_CONF_DIR="/etc/smartdns"
 SMARTDNS_VAR_CONF_DIR="/var/etc/smartdns"
 SMARTDNS_CONF="$SMARTDNS_VAR_CONF_DIR/smartdns.conf"
@@ -23,18 +36,15 @@ set_forward_dnsmasq()
 {
 	local PORT="$1"
 	addr="127.0.0.1#$PORT"
-	OLD_SERVER="`uci get dhcp.@dnsmasq[0].server 2>/dev/null`"
-	echo $OLD_SERVER | grep "^$addr" >/dev/null 2>&1
-	if [ $? -eq 0 ]; then
+	OLD_SERVER="$(uci get dhcp.@dnsmasq[0].server 2>/dev/null)"
+	if echo "$OLD_SERVER" | grep "^$addr" >/dev/null 2>&1; then
 		return
 	fi
 	uci delete dhcp.@dnsmasq[0].server 2>/dev/null
-	uci add_list dhcp.@dnsmasq[0].server=$addr
+	uci add_list dhcp.@dnsmasq[0].server="$addr"
 	for server in $OLD_SERVER; do
-		if [ "$server" = "$addr" ]; then
-			continue
-		fi
-		uci add_list dhcp.@dnsmasq[0].server=$server
+		[ "$server" = "$addr" ] && continue
+		uci add_list dhcp.@dnsmasq[0].server="$server"
 	done
 	uci delete dhcp.@dnsmasq[0].resolvfile 2>/dev/null
 	uci set dhcp.@dnsmasq[0].noresolv=1
@@ -46,18 +56,17 @@ stop_forward_dnsmasq()
 {
 	local OLD_PORT="$1"
 	addr="127.0.0.1#$OLD_PORT"
-	OLD_SERVER="`uci get dhcp.@dnsmasq[0].server 2>/dev/null`"
-	echo $OLD_SERVER | grep "^$addr" >/dev/null 2>&1
-	if [ $? -ne 0 ]; then
+	OLD_SERVER="$(uci get dhcp.@dnsmasq[0].server 2>/dev/null)"
+	if echo "$OLD_SERVER" | grep "^$addr" >/dev/null 2>&1; then
 		return
 	fi

-	uci del_list dhcp.@dnsmasq[0].server=$addr 2>/dev/null
-	addrlist="`uci get dhcp.@dnsmasq[0].server 2>/dev/null`"
-	if [ -z "$addrlist" ] ; then
+	uci del_list dhcp.@dnsmasq[0].server="$addr" 2>/dev/null
+	addrlist="$(uci get dhcp.@dnsmasq[0].server 2>/dev/null)"
+	[ -z "$addrlist" ] && {
 		uci set dhcp.@dnsmasq[0].resolvfile=/tmp/resolv.conf.auto 2>/dev/null
 		uci delete dhcp.@dnsmasq[0].noresolv 2>/dev/null
-	fi
+	}
 	uci commit dhcp
 	/etc/init.d/dnsmasq restart
 }
@@ -67,26 +76,24 @@ set_iptable()
 	local ipv6_server=$1
 	local tcp_server=$2

-	IPS="`ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F : '{print $2}'`"
+	IPS="$(ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F : '{print $2}')"
 	for IP in $IPS
 	do
-		if [ "$tcp_server" == "1" ]; then
-			iptables -t nat -A PREROUTING -p tcp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT >/dev/null 2>&1
+		if [ "$tcp_server" = "1" ]; then
+			iptables -t nat -A PREROUTING -p tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" >/dev/null 2>&1
 		fi
-		iptables -t nat -A PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT >/dev/null 2>&1
+		iptables -t nat -A PREROUTING -p udp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" >/dev/null 2>&1
 	done

-	if [ "$ipv6_server" == 0 ]; then
-		return
-	fi
+	[ "$ipv6_server" = 0 ] && return

-	IPS="`ifconfig | grep "inet6 addr" | grep -v " fe80::" | grep -v " ::1" | grep "Global" | awk '{print $3}'`"
+	IPS="$(ifconfig | grep "inet6 addr" | grep -v " fe80::" | grep -v " ::1" | grep "Global" | awk '{print $3}')"
 	for IP in $IPS
 	do
-		if [ "$tcp_server" == "1" ]; then
-			ip6tables -t nat -A PREROUTING -p tcp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT >/dev/null 2>&1
+		if [ "$tcp_server" = "1" ]; then
+			ip6tables -t nat -A PREROUTING -p tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" >/dev/null 2>&1
 		fi
-		ip6tables -t nat -A PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT >/dev/null 2>&1
+		ip6tables -t nat -A PREROUTING -p udp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" >/dev/null 2>&1
 	done

 }
@@ -95,22 +102,20 @@ clear_iptable()
 {
 	local OLD_PORT="$1"
 	local ipv6_server=$2
-	IPS="`ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F : '{print $2}'`"
+	IPS="$(ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F : '{print $2}')"
 	for IP in $IPS
 	do
-		iptables -t nat -D PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-ports $OLD_PORT >/dev/null 2>&1
-		iptables -t nat -D PREROUTING -p tcp -d $IP --dport 53 -j REDIRECT --to-ports $OLD_PORT >/dev/null 2>&1
+		iptables -t nat -D PREROUTING -p udp -d "$IP" --dport 53 -j REDIRECT --to-ports "$OLD_PORT" >/dev/null 2>&1
+		iptables -t nat -D PREROUTING -p tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$OLD_PORT" >/dev/null 2>&1
 	done

-	if [ "$ipv6_server" == 0 ]; then
-		return
-	fi
+	[ "$ipv6_server" = 0 ] && return

-	IPS="`ifconfig | grep "inet6 addr" | grep -v " fe80::" | grep -v " ::1" | grep "Global" | awk '{print $3}'`"
+	IPS="$(ifconfig | grep "inet6 addr" | grep -v " fe80::" | grep -v " ::1" | grep "Global" | awk '{print $3}')"
 	for IP in $IPS
 	do
-		ip6tables -t nat -D PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-ports $OLD_PORT >/dev/null 2>&1
-		ip6tables -t nat -D PREROUTING -p tcp -d $IP --dport 53 -j REDIRECT --to-ports $OLD_PORT >/dev/null 2>&1
+		ip6tables -t nat -D PREROUTING -p udp -d "$IP" --dport 53 -j REDIRECT --to-ports "$OLD_PORT" >/dev/null 2>&1
+		ip6tables -t nat -D PREROUTING -p tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$OLD_PORT" >/dev/null 2>&1
 	done

 }
@@ -126,27 +131,43 @@ conf_append()
 	echo "$1 $2" >> $SMARTDNS_CONF_TMP
 }

+get_tz()
+{
+	SET_TZ=""
+
+	[ -e "/etc/localtime" ] && return
+
+	for tzfile in /etc/TZ /var/etc/TZ
+	do
+		[ -e "$tzfile" ] || continue
+		tz="$(cat $tzfile 2>/dev/null)"
+	done
+
+	[ -z "$tz" ] && return
+
+	SET_TZ=$tz
+}
+
 load_server()
 {
 	local section="$1"
 	local ADDITIONAL_ARGS=""
 	local DNS_ADDRESS=""

-	config_get_bool "enabled" "$section" "enabled" "1"
-	config_get "port" "$section" "port" ""
-	config_get "type" "$section" "type" "udp"
-	config_get "ip" "$section" "ip" ""
-	config_get "host_name" "$section" "host_name" ""
-	config_get "http_host" "$section" "http_host" ""
-	config_get "server_group" "$section" "server_group" ""
-	config_get "blacklist_ip" "$section" "blacklist_ip" "0"
-	config_get "check_edns" "$section" "check_edns" "0"
-	config_get "spki_pin" "$section" "spki_pin" ""
-	config_get "addition_arg" "$section" "addition_arg" ""
+	config_get_bool enabled "$section" "enabled" "1"
+	config_get port "$section" "port" ""
+	config_get type "$section" "type" "udp"
+	config_get ip "$section" "ip" ""
+	config_get tls_host_verify "$section" "tls_host_verify" ""
+	config_get host_name "$section" "host_name" ""
+	config_get http_host "$section" "http_host" ""
+	config_get server_group "$section" "server_group" ""
+	config_get blacklist_ip "$section" "blacklist_ip" "0"
+	config_get check_edns "$section" "check_edns" "0"
+	config_get spki_pin "$section" "spki_pin" ""
+	config_get addition_arg "$section" "addition_arg" ""

-	if [ "$enabled" = "0" ]; then
-		return
-	fi
+	[ "$enabled" = "0" ] && return

 	if [ -z "$ip" ] || [ -z "$type" ]; then
 		return
@@ -161,150 +182,158 @@ load_server()
 		SERVER="server-https"
 	fi

-	if [ ! -z "`echo $ip | grep ":" | grep -v "https://"`" ]; then
-		if [ -z "`echo $ip | grep "\["`" ]; then
+	if echo "$ip" | grep ":" | grep -q -v "https://" >/dev/null 2>&1; then
+		if ! echo "$ip" | grep -q "\\[" >/dev/null 2>&1; then
 			ip="[$ip]"
 		fi
 	fi

-	if [ ! -z "$host_name" ]; then
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -host-name $host_name"
-	fi
+	[ -z "$tls_host_verify" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -tls-host-verify $tls_host_verify"
+	[ -z "$host_name" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -host-name $host_name"
+	[ -z "$http_host" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -http-host $http_host"
+	[ -z "$server_group" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -group $server_group"
+	[ "$blacklist_ip" = "0" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -blacklist-ip"
+	[ "$check_edns" = "0" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -check-edns"
+	[ -z "$spki_pin" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -spki-pin $spki_pin"

-	if [ ! -z "$http_host" ]; then
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -http-host $http_host"
-	fi
-
-	if [ ! -z "$server_group" ]; then
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -group $server_group"
-	fi
-
-	if [ "$blacklist_ip" != "0" ]; then
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -blacklist-ip"
-	fi
-
-	if [ "$check_edns" != "0" ]; then
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -check-edns"
-	fi
-
-	if [ ! -z "$spki_pin" ]; then
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -spki-pin $spki_pin"
-	fi
-
-	if [ ! -z "$port" ]; then
-		DNS_ADDRESS="$ip:$port"
+	if [ -z "$port" ]; then
+		DNS_ADDRESS="$ip"
 	else
-		DNS_ADDRESS="$ip"
+		DNS_ADDRESS="$ip:$port"
 	fi

-	if [ "$type" = "https" ]; then
-		DNS_ADDRESS="$ip"
-	fi
+	[ "$type" = "https" ] && DNS_ADDRESS="$ip"

 	conf_append "$SERVER" "$DNS_ADDRESS $ADDITIONAL_ARGS $addition_arg"
 }

-load_service() {
+load_second_server()
+{
+	local section="$1"
+	local ARGS=""
+	local ADDR=""
+
+	config_get_bool seconddns_enabled "$section" "seconddns_enabled" "0"
+	[ "$seconddns_enabled" = "0" ] && return
+
+	config_get seconddns_port "$section" "seconddns_port" "6553"
+
+	config_get_bool seconddns_no_speed_check "$section" "seconddns_no_speed_check" "0"
+	[ "$seconddns_no_speed_check" = "1" ] && ARGS="$ARGS -no-speed-check"
+
+	config_get seconddns_server_group "$section" "seconddns_server_group" ""
+	[ -z "$seconddns_server_group" ] || ARGS="$ARGS -group $seconddns_server_group"
+
+	config_get_bool seconddns_no_rule_addr "$section" "seconddns_no_rule_addr" "0"
+	[ "$seconddns_no_rule_addr" = "1" ] && ARGS="$ARGS -no-rule-addr"
+
+	config_get_bool seconddns_no_rule_nameserver "$section" "seconddns_no_rule_nameserver" "0"
+	[ "$seconddns_no_rule_nameserver" = "1" ] && ARGS="$ARGS -no-rule-nameserver"
+
+	config_get_bool seconddns_no_rule_ipset "$section" "seconddns_no_rule_ipset" "0"
+	[ "$seconddns_no_rule_ipset" = "1" ] && ARGS="$ARGS -no-rule-ipset"
+
+	config_get_bool seconddns_no_rule_soa "$section" "seconddns_no_rule_soa" "0"
+	[ "$seconddns_no_rule_soa" = "1" ] && ARGS="$ARGS -no-rule-soa"
+
+	config_get_bool seconddns_no_dualstack_selection "$section" "seconddns_no_dualstack_selection" "0"
+	[ "$seconddns_no_dualstack_selection" = "1" ] && ARGS="$ARGS -no-dualstack-selection"
+
+	config_get_bool seconddns_no_cache "$section" "seconddns_no_cache" "0"
+	[ "$seconddns_no_cache" = "1" ] && ARGS="$ARGS -no-cache"
+
+	config_get_bool force_aaaa_soa "$section" "force_aaaa_soa" "0"
+	[ "$force_aaaa_soa" = "1" ] && ARGS="$ARGS -force-aaaa-soa"
+
+	config_get ipv6_server "$section" "ipv6_server" "1"
+	if [ "$ipv6_server" = "1" ]; then
+		ADDR="[::]"
+	else
+		ADDR=""
+	fi
+
+	conf_append "bind" "$ADDR:$seconddns_port $ARGS"
+	config_get_bool "seconddns_tcp_server" "$section" "seconddns_tcp_server" "1"
+	[ "$seconddns_tcp_server" = "1" ] && conf_append "bind-tcp" "$ADDR:$seconddns_port $ARGS"
+}
+
+load_service()
+{
 	local section="$1"
 	args=""

 	mkdir -p $SMARTDNS_VAR_CONF_DIR
 	rm -f $SMARTDNS_CONF_TMP

-	config_get_bool "enabled" "$section" "enabled" '0'
+	config_get_bool enabled "$section" "enabled" '0'

-	config_get "server_name" "$section" "server_name" ""
-	if [ ! -z "$server_name" ]; then
-		conf_append "server-name" "$server_name"	
-	fi
+	config_get server_name "$section" "server_name" ""
+	[ -z "$server_name" ] || conf_append "server-name" "$server_name"

-	config_get "coredump" "$section" "coredump" "0"
-	if [ "$coredump" = "1" ]; then
-		COREDUMP="1"
-	fi
+	config_get coredump "$section" "coredump" "0"
+	[ "$coredump" = "1" ] && COREDUMP="1"

-	config_get "port" "$section" "port" "6053"
-	config_get "ipv6_server" "$section" "ipv6_server" "1"
-	config_get "tcp_server" "$section" "tcp_server" "1"
+	config_get port "$section" "port" "6053"
+	config_get ipv6_server "$section" "ipv6_server" "1"
+	config_get tcp_server "$section" "tcp_server" "1"
 	if [ "$ipv6_server" = "1" ]; then
 		conf_append "bind" "[::]:$port"
 	else
 		conf_append "bind" ":$port"
 	fi

-	if [ "$tcp_server" = "1" ]; then
+	[ "$tcp_server" = "1" ] && {
 		if [ "$ipv6_server" = "1" ]; then
 			conf_append "bind-tcp" "[::]:$port"
 		else
 			conf_append "bind-tcp" ":$port"
 		fi
-	fi
-	config_get "dualstack_ip_selection" "$section" "dualstack_ip_selection" "0"
-	if [ "$dualstack_ip_selection" = "1" ]; then
-		conf_append "dualstack-ip-selection" "yes"
-	fi
+	}
+	config_get dualstack_ip_selection "$section" "dualstack_ip_selection" "0"
+	[ "$dualstack_ip_selection" = "1" ] && conf_append "dualstack-ip-selection" "yes"

-	config_get "prefetch_domain" "$section" "prefetch_domain" "0"
-	if [ "$prefetch_domain" = "1" ]; then
-		conf_append "prefetch-domain" "yes"
-	fi
+	config_get prefetch_domain "$section" "prefetch_domain" "0"
+	[ "$prefetch_domain" = "1" ] && conf_append "prefetch-domain" "yes"
+
+	config_get serve_expired "$section" "serve_expired" "0"
+	[ "$serve_expired" = "1" ] && conf_append "serve-expired" "yes"

 	SMARTDNS_PORT="$port"

-	config_get "cache_size" "$section" "cache_size" ""
-	if [ ! -z "$cache_size" ]; then
-		conf_append "cache-size" "$cache_size"
-	fi
+	config_get cache_size "$section" "cache_size" ""
+	[ -z "$cache_size" ] || conf_append "cache-size" "$cache_size"

-	config_get "rr_ttl" "$section" "rr_ttl" ""
-	if [ ! -z "$rr_ttl" ]; then
-		conf_append "rr-ttl" "$rr_ttl"
-	fi
+	config_get rr_ttl "$section" "rr_ttl" ""
+	[ -z "$rr_ttl" ] || conf_append "rr-ttl" "$rr_ttl"

-	config_get "rr_ttl_min" "$section" "rr_ttl_min" ""
-	if [ ! -z "$rr_ttl_min" ]; then
-		conf_append "rr-ttl-min" "$rr_ttl_min"
-	fi
+	config_get rr_ttl_min "$section" "rr_ttl_min" ""
+	[ -z "$rr_ttl_min" ] || conf_append "rr-ttl-min" "$rr_ttl_min"

-	config_get "rr_ttl_max" "$section" "rr_ttl_max" ""
-	if [ ! -z "$rr_ttl_max" ]; then
-		conf_append "rr-ttl-max" "$rr_ttl_max"
-	fi
+	config_get rr_ttl_max "$section" "rr_ttl_max" ""
+	[ -z "$rr_ttl_max" ] || conf_append "rr-ttl-max" "$rr_ttl_max"

-	config_get "log_size" "$section" "log_size" "64K"
-	if [ ! -z "$log_size" ]; then
-		conf_append "log-size" "$log_size"
-	fi
+	config_get log_size "$section" "log_size" "64K"
+	[ -z "$log_size" ] || conf_append "log-size" "$log_size"

-	config_get "log_num" "$section" "log_num" "1"
-	if [ ! -z "$log_num" ]; then
-		conf_append "log-num" "$log_num"
-	fi
+	config_get log_num "$section" "log_num" "1"
+	[ -z "$log_num" ] || conf_append "log-num" "$log_num"

-	config_get "log_level" "$section" "log_level" "error"
-	if [ ! -z "$log_level" ]; then
-		conf_append "log-level" "$log_level"
-	fi
+	config_get log_level "$section" "log_level" "error"
+	[ -z "$log_level" ]|| conf_append "log-level" "$log_level"

-	config_get "log_file" "$section" "log_file" ""
-	if [ ! -z "$log_file" ]; then
-		conf_append "log-file" "$log_file"
-	fi
+	config_get log_file "$section" "log_file" ""
+	[ -z "$log_file" ] || conf_append "log-file" "$log_file"

-	config_get "redirect" "$section" "redirect" "none"
-	config_get "old_redirect" "$section" "old_redirect" "none"
-	config_get "old_port" "$section" "old_port" "0"
-	config_get "old_enabled" "$section" "old_enabled" "0"
+	config_get redirect "$section" "redirect" "none"
+	config_get old_redirect "$section" "old_redirect" "none"
+	config_get old_port "$section" "old_port" "0"
+	config_get old_enabled "$section" "old_enabled" "0"

 	if [ "$old_redirect" != "$redirect" ] || [ "$old_port" != "$SMARTDNS_PORT" ] || [ "$old_enabled" = "1" -a "$enabled" = "0" ]; then
-		if [ "$old_redirect" != "none" ]; then
-			if [ "$old_port" != "0" ]; then
-				clear_iptable "$old_port" "$ipv6_server"
-			fi
-			if [ "$old_redirect" == "dnsmasq-upstream" ]; then
-				stop_forward_dnsmasq "$old_port"
-			fi
-		fi
+		[ "$old_redirect" = "none" ] || {
+			[ "$old_port" = "0" ] || clear_iptable "$old_port" "$ipv6_server"
+			[ "$old_redirect" = "dnsmasq-upstream" ] && stop_forward_dnsmasq "$old_port"
+		}
 	fi

 	uci delete smartdns.@smartdns[0].old_redirect 2>/dev/null
@@ -323,33 +352,40 @@ load_service() {
 		set_forward_dnsmasq "$SMARTDNS_PORT"
 	fi

+	load_second_server $section
+
 	config_foreach load_server "server"

-	echo "conf-file $ADDRESS_CONF" >> $SMARTDNS_CONF_TMP
-	echo "conf-file $BLACKLIST_IP_CONF" >> $SMARTDNS_CONF_TMP
-	echo "conf-file $CUSTOM_CONF" >> $SMARTDNS_CONF_TMP
+	{
+		echo "conf-file $ADDRESS_CONF"
+		echo "conf-file $BLACKLIST_IP_CONF"
+		echo "conf-file $CUSTOM_CONF"
+	} >> $SMARTDNS_CONF_TMP
 	mv $SMARTDNS_CONF_TMP $SMARTDNS_CONF

 	procd_open_instance "smartdns"
-	if [ "$COREDUMP" = "1" ]; then
+	[ "$COREDUMP" = "1" ] && {
 		args="$args -S"
 		procd_set_param limits core="unlimited"
-	fi
+	}
+
+	get_tz
+	[ -z "$SET_TZ" ] || procd_set_param env TZ="$SET_TZ"

 	procd_set_param command /usr/sbin/smartdns -f -c $SMARTDNS_CONF $args
-	if [ "$RESPAWN" = "1" ]; then
-		procd_set_param respawn ${respawn_threshold:-3600} ${respawn_timeout:-5} ${respawn_retry:-5}
-	fi
+	[ "$RESPAWN" = "1" ] &&	procd_set_param respawn ${respawn_threshold:-3600} ${respawn_timeout:-5} ${respawn_retry:-5}
 	procd_set_param file "$SMARTDNS_CONF"
 	procd_close_instance
 }

-start_service() {
+start_service()
+{
 	config_load "smartdns"
 	config_foreach load_service "smartdns"
 }

-reload_service(){
+reload_service()
+{
 	stop
 	start
 }
--- a/package/openwrt/make.sh
+++ b/package/openwrt/make.sh
@@ -1,5 +1,19 @@
-#/bin/sh
-
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 CURR_DIR=$(cd $(dirname $0);pwd)

 VER="`date +"1.%Y.%m.%d-%H%M"`"
@@ -16,52 +30,57 @@ showhelp()
 	echo "Options:"
 	echo " -o               output directory."
 	echo " --arch           archtecture."
-    echo " --ver            version."
+	echo " --ver            version."
 	echo " -h               show this message."
 }

 build()
 {
-    ROOT=/tmp/smartdns-openwrt
-    rm -fr $ROOT
+	ROOT=/tmp/smartdns-openwrt
+	rm -fr $ROOT

-    mkdir -p $ROOT
-    cp $CURR_DIR/* $ROOT/ -af
-    cd $ROOT/
-    mkdir $ROOT/root/usr/sbin -p
-    mkdir $ROOT/root/etc/init.d -p
-    mkdir $ROOT/root/etc/smartdns/ -p
+	mkdir -p $ROOT
+	cp $CURR_DIR/* $ROOT/ -af
+	cd $ROOT/
+	mkdir $ROOT/root/usr/sbin -p
+	mkdir $ROOT/root/etc/init.d -p
+	mkdir $ROOT/root/etc/smartdns/ -p

-    cp $SMARTDNS_CONF  $ROOT/root/etc/smartdns/
-    cp $ADDRESS_CONF $ROOT/root/etc/smartdns/
-    cp $BLACKLIST_IP_CONF $ROOT/root/etc/smartdns/
-    cp $CUSTOM_CONF $ROOT/root/etc/smartdns/
-    cp $CURR_DIR/files/etc $ROOT/root/ -af
-    cp $SMARTDNS_BIN $ROOT/root/usr/sbin
+	cp $SMARTDNS_CONF  $ROOT/root/etc/smartdns/
+	cp $ADDRESS_CONF $ROOT/root/etc/smartdns/
+	cp $BLACKLIST_IP_CONF $ROOT/root/etc/smartdns/
+	cp $CUSTOM_CONF $ROOT/root/etc/smartdns/
+	cp $CURR_DIR/files/etc $ROOT/root/ -af
+	cp $SMARTDNS_BIN $ROOT/root/usr/sbin
+	if [ $? -ne 0 ]; then
+		echo "copy smartdns file failed."
+		rm -fr $ROOT/
+		return 1
+	fi

-    chmod +x $ROOT/root/etc/init.d/smartdns
-    INST_SIZE="`du -sb $ROOT/root/ | awk '{print $1}'`"
+	chmod +x $ROOT/root/etc/init.d/smartdns
+	INST_SIZE="`du -sb $ROOT/root/ | awk '{print $1}'`"

-    sed -i "s/^Architecture.*/Architecture: $ARCH/g" $ROOT/control/control
-    sed -i "s/Version:.*/Version: $VER/" $ROOT/control/control
-    sed -i "s/^\(bind .*\):53/\1:6053/g" $ROOT/root/etc/smartdns/smartdns.conf
-    if [ ! -z "$INST_SIZE" ]; then
-        echo "Installed-Size: $INST_SIZE" >> $ROOT/control/control
-    fi
+	sed -i "s/^Architecture.*/Architecture: $ARCH/g" $ROOT/control/control
+	sed -i "s/Version:.*/Version: $VER/" $ROOT/control/control
+	sed -i "s/^\(bind .*\):53/\1:6053/g" $ROOT/root/etc/smartdns/smartdns.conf
+	if [ ! -z "$INST_SIZE" ]; then
+		echo "Installed-Size: $INST_SIZE" >> $ROOT/control/control
+	fi

-    cd $ROOT/control
-    chmod +x *
-    tar zcf ../control.tar.gz --owner=0 --group=0 ./
-    cd $ROOT
+	cd $ROOT/control
+	chmod +x *
+	tar zcf ../control.tar.gz --owner=0 --group=0 ./
+	cd $ROOT

-    tar zcf $ROOT/data.tar.gz -C root --owner=0 --group=0 .
-    tar zcf $OUTPUTDIR/smartdns.$VER.$ARCH.ipk --owner=0 --group=0 control.tar.gz data.tar.gz debian-binary
-    rm -fr $ROOT/
+	tar zcf $ROOT/data.tar.gz -C root --owner=0 --group=0 .
+	tar zcf $OUTPUTDIR/smartdns.$VER.$FILEARCH.ipk --owner=0 --group=0 control.tar.gz data.tar.gz debian-binary
+	rm -fr $ROOT/
 }

 main()
 {
-	OPTS=`getopt -o o:h --long arch:,ver: \
+	OPTS=`getopt -o o:h --long arch:,ver:,filearch: \
 		-n  "" -- "$@"`

 	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
@@ -74,31 +93,38 @@ main()
 		--arch)
 			ARCH="$2"
 			shift 2;;
-        --ver)
-            VER="$2"
-            shift 2;;
+		--filearch)
+			FILEARCH="$2"
+			shift 2;;
+		--ver)
+			VER="$2"
+			shift 2;;
 		-o )
 			OUTPUTDIR="$2"
 			shift 2;;
-        -h | --help )
+		-h | --help )
 			showhelp
 			return 0
 			shift ;;
 		-- ) shift; break ;;
 		* ) break ;;
-  		esac
+		esac
 	done

-    if [ -z "$ARCH" ]; then
-        echo "please input arch."
-        return 1;
-    fi
+	if [ -z "$ARCH" ]; then
+		echo "please input arch."
+		return 1;
+	fi

-    if [ -z "$OUTPUTDIR" ]; then
-        OUTPUTDIR=$CURR_DIR;
-    fi
+	if [ -z "$FILEARCH" ]; then
+		FILEARCH=$ARCH
+	fi

-    build
+	if [ -z "$OUTPUTDIR" ]; then
+		OUTPUTDIR=$CURR_DIR;
+	fi
+
+	build
 }

 main $@
--- a/package/optware/S50smartdns
+++ b/package/optware/S50smartdns
@@ -1,9 +1,24 @@
-#! /bin/sh
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 SMARTDNS_BIN=/opt/usr/sbin/smartdns
 SMARTDNS_CONF=/opt/etc/smartdns/smartdns.conf
-DNSMASQ_CONF=/etc/dnsmasq.conf
-SMARTDNS_PID="/var/run/smartdns.pid"
+DNSMASQ_CONF="/etc/dnsmasq.conf /var/etc/dnsmasq.conf /etc/storage/dnsmasq/dnsmasq.conf"
+SMARTDNS_PID=/var/run/smartdns.pid
 SMARTDNS_PORT=535
 SMARTDNS_OPT=/opt/etc/smartdns/smartdns-opt.conf
 # workmode 
@@ -28,123 +43,184 @@ set_iptable()
 		redirect_tcp=1;
 	fi

-	IPS="`ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F: '{print $2}'`"
+	IPS="$(ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F: '{print $2}')"
 	for IP in $IPS
 	do
 		if [ $redirect_tcp -eq 1 ]; then
-			iptables -t nat -A PREROUTING -p tcp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT > /dev/null 2>&1
+			iptables -t nat -A PREROUTING -p tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" > /dev/null 2>&1
 		fi
-		iptables -t nat -A PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT > /dev/null 2>&1
+		iptables -t nat -A PREROUTING -p udp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" > /dev/null 2>&1
 	done

 }

 clear_iptable()
 {
-	IPS="`ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F: '{print $2}'`"
+	IPS="$(ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F: '{print $2}')"
 	for IP in $IPS
 	do
-		iptables -t nat -D PREROUTING -p tcp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT > /dev/null 2>&1
-		iptables -t nat -D PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-ports $SMARTDNS_PORT > /dev/null 2>&1
+		iptables -t nat -D PREROUTING -p tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" > /dev/null 2>&1
+		iptables -t nat -D PREROUTING -p udp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" > /dev/null 2>&1
 	done
 	
 }

-restart_dnsmasq()
+get_dnsmasq_cmd()
 {
-	CMD="`ps | grep "  dnsmasq" | grep -v grep 2>/dev/null`"
-	if [ -z "$CMD" ]; then
-		CMD="`ps ax | grep dnsmasq | grep -v grep 2>/dev/null`"
+	CMD="$(ps 2>/dev/null | grep -e '[a-zA-Z]\{0,2\} \{1,\}dnsmasq' | grep -v grep 2>/dev/null)"
+	if [ ! -z "$CMD" ]; then
+		return
 	fi

+	CMD="$(ps 2>/dev/null | grep '/usr/sbin/dnsmasq' | grep -v grep 2>/dev/null)"
+	if [ ! -z "$CMD" ]; then
+		return
+	fi
+
+	CMD="$(ps 2>/dev/null | grep 'dnsmasq' | grep -v grep 2>/dev/null)"
+	if [ ! -z "$CMD" ]; then
+		return
+	fi
+
+	CMD="$(ps ax 2>/dev/null | grep -e '[a-zA-Z]\{0,2\} \{1,\}dnsmasq' | grep -v grep 2>/dev/null)"
+	if [ ! -z "$CMD" ]; then
+		return
+	fi
+
+	CMD="$(ps ax 2>/dev/null | grep /usr/sbin/dnsmasq | grep -v grep 2>/dev/null)"
+	if [ ! -z "$CMD" ]; then
+		return
+	fi
+
+	CMD="$(ps ax 2>/dev/null | grep 'dnsmasq' | grep -v grep 2>/dev/null)"
+	if [ ! -z "$CMD" ]; then
+		return
+	fi	
+}
+
+restart_dnsmasq()
+{
+	local CMD=""
+
+	get_dnsmasq_cmd
 	if [ -z "$CMD" ]; then
 		echo "cannot find dnsmasq"
 		return 1
 	fi

-	PID=`echo "$CMD" | awk '{print $1}'`
+	PID="$(echo "$CMD" | awk '{print $1}')"
 	if [ ! -d "/proc/$PID" ]; then
 		echo "dnsmasq is not running"
 		return 1
 	fi

-	kill -9 $PID
+	kill -9 "$PID"

-	DNSMASQ_CMD="`echo $CMD | awk '{for(i=5; i<=NF;i++)printf \$i " "}'`"
+	DNSMASQ_CMD="$(echo "$CMD" | awk '{for(i=5; i<=NF;i++)printf $i " "}')"

 	$DNSMASQ_CMD
 }

 get_server_ip()
 {
-	IPS="`ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F: '{print $2}'`"
-	LOCAL_SERVER_IP=""
+	CONF_FILE=$1
+	IPS="$(ifconfig | grep "inet addr" | grep -v ":127" | grep "Bcast" | awk '{print $2}' | awk -F: '{print $2}')"
 	for IP in $IPS
 	do
 		N=3
 		while [ $N -gt 0 ]
 		do
-			ADDR=`echo $IP | awk -F. "{for(i=1;i<=$N;i++)printf \\$i\".\"}"`
-			grep "dhcp-range=" $DNSMASQ_CONF | grep $ADDR >/dev/null 2>&1
+			ADDR="$(echo "$IP" | awk -F. "{for(i=1;i<="$N";i++)printf \$i\".\"}")"
+			grep "dhcp-range=" "$CONF_FILE" | grep "$ADDR" >/dev/null 2>&1
 			if [ $? -eq 0 ]; then
-					SERVER_TAG="`grep "^dhcp-range *=" $DNSMASQ_CONF | grep $ADDR | awk -F= '{print $2}' | awk -F, '{print $1}'`"
+					SERVER_TAG="$(grep "^dhcp-range *=" "$CONF_FILE" | grep "$ADDR" | awk -F= '{print $2}' | awk -F, '{print $1}')"
 					LOCAL_SERVER_IP="$IP"
-					return 0
+					return 1
 			fi
-			N="`expr $N - 1`"
+			N=$((N-1))
 		done
 	done

 	return 1
 }

-set_dnsmasq()
+set_dnsmasq_conf()
 {
-	local RESTART_DNSMASQ=0
 	local LOCAL_SERVER_IP=""
 	local SERVER_TAG=""
-	get_server_ip
+	local CONF_FILE=$1
+
+	get_server_ip $CONF_FILE
+
 	if [ "$LOCAL_SERVER_IP" ] && [ "$SERVER_TAG" ]; then
-		grep "dhcp-option *=" $DNSMASQ_CONF | grep "$SERVER_TAG,6,$LOCAL_SERVER_IP" > /dev/null 2>&1
+		grep "dhcp-option *=" "$CONF_FILE" | grep "$SERVER_TAG,6,$LOCAL_SERVER_IP" > /dev/null 2>&1
 		if [ $? -ne 0 ]; then
-			sed -i "/^dhcp-option *=$SERVER_TAG,6,/d" $DNSMASQ_CONF
-			echo "dhcp-option=$SERVER_TAG,6,$LOCAL_SERVER_IP" >> $DNSMASQ_CONF
+			sed -i "/^dhcp-option *=$SERVER_TAG,6,/d" "$CONF_FILE"
+			echo "dhcp-option=$SERVER_TAG,6,$LOCAL_SERVER_IP" >> "$CONF_FILE"
 			RESTART_DNSMASQ=1
 		fi
 	fi

-	grep "^port *=0" $DNSMASQ_CONF > /dev/null 2>&1
+	grep "^port *=0" "$CONF_FILE" > /dev/null 2>&1
 	if [ $? -ne 0 ]; then
-		sed -i "/^port *=/d" $DNSMASQ_CONF
-		echo "port=0" >> $DNSMASQ_CONF
+		sed -i "/^port *=/d" "$CONF_FILE"
+		echo "port=0" >> "$CONF_FILE"
 		RESTART_DNSMASQ=1
 	fi
+}
+
+set_dnsmasq()
+{
+	local RESTART_DNSMASQ=0
+
+	for conf in $DNSMASQ_CONF
+	do
+		if [ ! -e "$conf" ]; then
+			continue
+		fi
+
+		set_dnsmasq_conf "$conf"
+	done
 	
 	if [ $RESTART_DNSMASQ -ne 0 ]; then
 		restart_dnsmasq	
 	fi
+}

+clear_dnsmasq_conf()
+{
+	local LOCAL_SERVER_IP=""
+	local SERVER_TAG=""
+	local CONF_FILE=$1
+	
+	get_server_ip "$CONF_FILE"
+	if [ "$LOCAL_SERVER_IP" ] && [ "$SERVER_TAG" ]; then
+		grep "dhcp-option *=" "$CONF_FILE" | grep "$SERVER_TAG,6,$LOCAL_SERVER_IP" > /dev/null 2>&1
+		if [ $? -eq 0 ]; then
+			sed -i "/^dhcp-option *=$SERVER_TAG,6,/d" "$CONF_FILE"
+			RESTART_DNSMASQ=1
+		fi
+	fi
+
+	grep "^port *=" "$CONF_FILE" > /dev/null 2>&1
+	if [ $? -eq 0 ]; then
+		sed -i "/^port *=/d" "$CONF_FILE"
+		RESTART_DNSMASQ=1
+	fi
 }

 clear_dnsmasq()
 {
 	local RESTART_DNSMASQ=0
-	local LOCAL_SERVER_IP=""
-	local SERVER_TAG=""
-	get_server_ip
-	if [ "$LOCAL_SERVER_IP" ] && [ "$SERVER_TAG" ]; then
-		grep "dhcp-option *=" $DNSMASQ_CONF | grep "$SERVER_TAG,6,$LOCAL_SERVER_IP" > /dev/null 2>&1
-		if [ $? -eq 0 ]; then
-			sed -i "/^dhcp-option *=$SERVER_TAG,6,/d" $DNSMASQ_CONF
-			RESTART_DNSMASQ=1
-		fi
-	fi

-	grep "^port *=" $DNSMASQ_CONF > /dev/null 2>&1
-	if [ $? -eq 0 ]; then
-		sed -i "/^port *=/d" $DNSMASQ_CONF
-		RESTART_DNSMASQ=1
-	fi
+	for conf in $DNSMASQ_CONF
+	do
+		if [ ! -e "$conf" ]; then
+			continue
+		fi
+
+		clear_dnsmasq_conf "$conf"
+	done

 	if [ $RESTART_DNSMASQ -ne 0 ]; then
 		restart_dnsmasq	
@@ -156,11 +232,11 @@ set_smartdns_port()
 	if [ "$SMARTDNS_WORKMODE" = "0" ]; then
 		return 0
 	elif [ "$SMARTDNS_WORKMODE" = "1" ]; then
-		sed -i "s/^\(bind .*\):53 *\(.*\)\$/\1:$SMARTDNS_PORT \2/g" $SMARTDNS_CONF
-    	sed -i "s/^\(bind-tcp .*\):53 *\(.*\)\$/\1:$SMARTDNS_PORT \2/g" $SMARTDNS_CONF
+		sed -i "s/^\\(bind .*\\):53 *\\(.*\\)\$/\\1:$SMARTDNS_PORT \\2/g" $SMARTDNS_CONF
+		sed -i "s/^\\(bind-tcp .*\\):53 *\\(.*\\)\$/\\1:$SMARTDNS_PORT \\2/g" $SMARTDNS_CONF
 	elif [ "$SMARTDNS_WORKMODE" = "2" ]; then
-		sed -i "s/^\(bind .*\):$SMARTDNS_PORT *\(.*\)\$/\1:53 \2/g" $SMARTDNS_CONF
-    	sed -i "s/^\(bind-tcp .*\):$SMARTDNS_PORT *\(.*\)\$/\1:53 \2/g" $SMARTDNS_CONF
+		sed -i "s/^\\(bind .*\\):$SMARTDNS_PORT *\\(.*\\)\$/\\1:53 \\2/g" $SMARTDNS_CONF
+		sed -i "s/^\\(bind-tcp .*\\):$SMARTDNS_PORT *\\(.*\\)\$/\\1:53 \\2/g" $SMARTDNS_CONF
 	else
 		return 1
 	fi	
@@ -198,6 +274,28 @@ clear_rule()
 	fi
 }

+get_tz()
+{
+	if [ -e "/etc/localtime" ]; then
+		return 
+	fi
+	
+	for tzfile in /etc/TZ /var/etc/TZ
+	do
+		if [ ! -e "$tzfile" ]; then
+			continue
+		fi
+		
+		tz="$(cat $tzfile 2>/dev/null)"
+	done
+	
+	if [ -z "$tz" ]; then
+		return	
+	fi
+	
+	export TZ=$tz
+}
+
 case "$1" in
 	start)
 	set_rule
@@ -206,13 +304,14 @@ case "$1" in
 	fi

 	set_smartdns_port
+	get_tz
 	$SMARTDNS_BIN -c $SMARTDNS_CONF -p $SMARTDNS_PID
 	if [ $? -ne 0 ]; then
 		clear_rule
 	fi
 	;;
 	status)
-	pid="`cat $SMARTDNS_PID |head -n 1 2>/dev/null`"
+	pid="$(cat $SMARTDNS_PID |head -n 1 2>/dev/null)"
 	if [ -z "$pid" ]; then
 		echo "smartdns not running."
 		return 0
@@ -227,7 +326,7 @@ case "$1" in
 	;;
 	stop)
 	clear_rule
-	pid="`cat $SMARTDNS_PID | head -n 1 2>/dev/null`"
+	pid="$(cat "$SMARTDNS_PID" | head -n 1 2>/dev/null)"
 	if [ -z "$pid" ]; then
 		echo "smartdns not running."
 		return 0
@@ -237,7 +336,7 @@ case "$1" in
 		return 0;
 	fi

-	kill -9 $pid 2>/dev/null
+	kill -9 "$pid" 2>/dev/null
 	;;
 	restart)
 	$0 stop
--- a/package/optware/control/postinst
+++ b/package/optware/control/postinst
@@ -1,4 +1,19 @@
-#! /bin/sh
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 chmod +x /opt/usr/sbin/smartdns
 chmod +x /opt/etc/init.d/S50smartdns
--- a/package/optware/control/prerm
+++ b/package/optware/control/prerm
@@ -1,3 +1,18 @@
-#! /bin/sh
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 /opt/etc/init.d/S50smartdns stop
--- a/package/optware/make.sh
+++ b/package/optware/make.sh
@@ -1,5 +1,19 @@
-#/bin/sh
-
+#!/bin/sh
+#
+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 CURR_DIR=$(cd $(dirname $0);pwd)
 VER="`date +"1.%Y.%m.%d-%H%M"`"
 SMARTDNS_DIR=$CURR_DIR/../../
@@ -13,44 +27,49 @@ showhelp()
 	echo "Options:"
 	echo " -o               output directory."
 	echo " --arch           archtecture."
-    echo " --ver            version."
+	echo " --ver            version."
 	echo " -h               show this message."
 }

 build()
 {
-    ROOT=/tmp/smartdns-optware
-    rm -fr $ROOT
+	ROOT=/tmp/smartdns-optware
+	rm -fr $ROOT

-    mkdir -p $ROOT
-    cp $CURR_DIR/* $ROOT/ -af
-    cd $ROOT/
-    mkdir $ROOT/opt/usr/sbin -p
-    mkdir $ROOT/opt/etc/init.d -p
-    mkdir $ROOT/opt/etc/smartdns/ -p
+	mkdir -p $ROOT
+	cp $CURR_DIR/* $ROOT/ -af
+	cd $ROOT/
+	mkdir $ROOT/opt/usr/sbin -p
+	mkdir $ROOT/opt/etc/init.d -p
+	mkdir $ROOT/opt/etc/smartdns/ -p

-    cp $SMARTDNS_CONF  $ROOT/opt/etc/smartdns/
-    cp $SMARTDNS_OPT $ROOT/opt/etc/smartdns/
-    cp $CURR_DIR/S50smartdns $ROOT/opt/etc/init.d/
-    cp $SMARTDNS_BIN $ROOT/opt/usr/sbin
+	cp $SMARTDNS_CONF  $ROOT/opt/etc/smartdns/
+	cp $SMARTDNS_OPT $ROOT/opt/etc/smartdns/
+	cp $CURR_DIR/S50smartdns $ROOT/opt/etc/init.d/
+	cp $SMARTDNS_BIN $ROOT/opt/usr/sbin
+	if [ $? -ne 0 ]; then
+		echo "copy smartdns file failed."
+		rm -fr $ROOT/
+		return 1
+	fi

-    sed -i "s/# *server-name smartdns/server-name smartdns/g" $ROOT/opt/etc/smartdns/smartdns.conf
-    sed -i "s/^Architecture.*/Architecture: $ARCH/g" $ROOT/control/control
-    sed -i "s/Version:.*/Version: $VER/" $ROOT/control/control
+	sed -i "s/# *server-name smartdns/server-name smartdns/g" $ROOT/opt/etc/smartdns/smartdns.conf
+	sed -i "s/^Architecture.*/Architecture: $ARCH/g" $ROOT/control/control
+	sed -i "s/Version:.*/Version: $VER/" $ROOT/control/control

-    cd $ROOT/control
-    chmod +x *
-    tar zcf ../control.tar.gz --owner=0 --group=0 ./ 
-    cd $ROOT
+	cd $ROOT/control
+	chmod +x *
+	tar zcf ../control.tar.gz --owner=0 --group=0 ./ 
+	cd $ROOT

-    tar zcf data.tar.gz --owner=0 --group=0 opt
-    tar zcf $OUTPUTDIR/smartdns.$VER.$ARCH.ipk --owner=0 --group=0 control.tar.gz data.tar.gz debian-binary
-    rm -fr $ROOT/
+	tar zcf data.tar.gz --owner=0 --group=0 opt
+	tar zcf $OUTPUTDIR/smartdns.$VER.$FILEARCH.ipk --owner=0 --group=0 control.tar.gz data.tar.gz debian-binary
+	rm -fr $ROOT/
 }

 main()
 {
-	OPTS=`getopt -o o:h --long arch:,ver: \
+	OPTS=`getopt -o o:h --long arch:,ver:,filearch: \
 		-n  "" -- "$@"`

 	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
@@ -63,31 +82,38 @@ main()
 		--arch)
 			ARCH="$2"
 			shift 2;;
-        --ver)
-            VER="$2"
-            shift 2;;
+		--filearch)
+			FILEARCH="$2"
+			shift 2;;
+		--ver)
+			VER="$2"
+			shift 2;;
 		-o )
 			OUTPUTDIR="$2"
 			shift 2;;
-        -h | --help )
+		-h | --help )
 			showhelp
 			return 0
 			shift ;;
 		-- ) shift; break ;;
 		* ) break ;;
-  		esac
+		esac
 	done

-    if [ -z "$ARCH" ]; then
-        echo "please input arch."
-        return 1;
-    fi
+	if [ -z "$ARCH" ]; then
+		echo "please input arch."
+		return 1;
+	fi

-    if [ -z "$OUTPUTDIR" ]; then
-        OUTPUTDIR=$CURR_DIR;
-    fi
+	if [ -z "$FILEARCH" ]; then
+		FILEARCH=$ARCH
+	fi

-    build
+	if [ -z "$OUTPUTDIR" ]; then
+		OUTPUTDIR=$CURR_DIR;
+	fi
+
+	build
 }

 main $@
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,13 +1,42 @@

+# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+#
+# smartdns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# smartdns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 BIN=smartdns 
 OBJS_LIB=lib/rbtree.o lib/art.o lib/bitops.o lib/radix.o lib/conf.o
 OBJS=smartdns.o fast_ping.o dns_client.o dns_server.o dns.o util.o tlog.o dns_conf.o dns_cache.o http_parse.o $(OBJS_LIB)
-CFLAGS +=-O2 -g -Wall -Wstrict-prototypes -fno-omit-frame-pointer -Wstrict-aliasing 
-CFLAGS +=-Iinclude
-CFLAGS += -DBASE_FILE_NAME=\"$(notdir $<)\"
+
+# cflags
+ifndef CFLAGS
+CFLAGS =-O2 -g -Wall -Wstrict-prototypes -fno-omit-frame-pointer -Wstrict-aliasing 
+endif
+override CFLAGS +=-Iinclude
+override CFLAGS += -DBASE_FILE_NAME=\"$(notdir $<)\"
+ifdef VER
+override CFLAGS += -DSMARTDNS_VERION=\"$(VER)\"
+endif
+
 CXXFLAGS=-O2 -g -Wall -std=c++11 
-CXXFLAGS +=-Iinclude
-LDFLAGS += -lpthread -lssl -lcrypto
+override CXXFLAGS +=-Iinclude
+
+# ldflags
+ifeq ($(STATIC), yes)
+override LDFLAGS += -lssl -lcrypto -Wl,--whole-archive -lpthread -Wl,--no-whole-archive -ldl -static
+else
+override LDFLAGS += -lssl -lcrypto -lpthread 
+endif

 .PHONY: all

--- a/src/dns.c
+++ b/src/dns.c
@@ -1,6 +1,6 @@
 /*************************************************************************
 *
- * Copyright (C) 2018 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
 *
 * smartdns is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
 #define _GNU_SOURCE
 #include "dns.h"
 #include "tlog.h"
+#include "stringutil.h"
 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
@@ -264,6 +265,7 @@ static int _dns_add_qr_head(struct dns_data_context *data_context, char *domain,
 static int _dns_get_qr_head(struct dns_data_context *data_context, char *domain, int maxsize, int *qtype, int *qclass)
 {
 	int i;
+	int is_read_all = 0;
 	/* question head */
 	/* |domain         |
 	 * |qtype | qclass |
@@ -277,6 +279,7 @@ static int _dns_get_qr_head(struct dns_data_context *data_context, char *domain,
 			domain++;
 			data_context->ptr++;
 			i++;
+			is_read_all = 1;
 			break;
 		}
 		*domain = *data_context->ptr;
@@ -285,6 +288,9 @@ static int _dns_get_qr_head(struct dns_data_context *data_context, char *domain,
 	}

 	*domain = '\0';
+	if (is_read_all == 0) {
+		return -1;
+	}

 	if (_dns_data_left_len(data_context) < 4) {
 		return -1;
@@ -612,19 +618,19 @@ int dns_add_SOA(struct dns_packet *packet, dns_rr_type type, char *domain, int t
 	unsigned char data[sizeof(*soa)];
 	unsigned char *ptr = data;
 	int len = 0;
-	strncpy((char *)ptr, soa->mname, DNS_MAX_CNAME_LEN - 1);
+	safe_strncpy((char *)ptr, soa->mname, DNS_MAX_CNAME_LEN);
 	ptr += strnlen(soa->mname, DNS_MAX_CNAME_LEN - 1) + 1;
-	strncpy((char *)ptr, soa->rname, DNS_MAX_CNAME_LEN - 1);
+	safe_strncpy((char *)ptr, soa->rname, DNS_MAX_CNAME_LEN);
 	ptr += strnlen(soa->rname, DNS_MAX_CNAME_LEN - 1) + 1;
-	*((unsigned int *)ptr) = soa->serial;
+	memcpy(ptr, &soa->serial, sizeof(unsigned int));
 	ptr += 4;
-	*((unsigned int *)ptr) = soa->refresh;
+	memcpy(ptr, &soa->refresh, sizeof(unsigned int));
 	ptr += 4;
-	*((unsigned int *)ptr) = soa->retry;
+	memcpy(ptr, &soa->retry, sizeof(unsigned int));
 	ptr += 4;
-	*((unsigned int *)ptr) = soa->expire;
+	memcpy(ptr, &soa->expire, sizeof(unsigned int));
 	ptr += 4;
-	*((unsigned int *)ptr) = soa->minimum;
+	memcpy(ptr, &soa->minimum, sizeof(unsigned int));
 	ptr += 4;
 	len = ptr - data;

@@ -650,12 +656,12 @@ int dns_get_SOA(struct dns_rrs *rrs, char *domain, int maxsize, int *ttl, struct
 		return -1;
 	}

-	strncpy(soa->mname, (char *)ptr, DNS_MAX_CNAME_LEN - 1);
+	safe_strncpy(soa->mname, (char *)ptr, DNS_MAX_CNAME_LEN - 1);
 	ptr += strnlen(soa->mname, DNS_MAX_CNAME_LEN - 1) + 1;
 	if (ptr - data >= len) {
 		return -1;
 	}
-	strncpy(soa->rname, (char *)ptr, DNS_MAX_CNAME_LEN - 1);
+	safe_strncpy(soa->rname, (char *)ptr, DNS_MAX_CNAME_LEN - 1);
 	ptr += strnlen(soa->rname, DNS_MAX_CNAME_LEN - 1) + 1;
 	if (ptr - data + 20 > len) {
 		return -1;
@@ -955,7 +961,7 @@ static int _dns_decode_domain(struct dns_context *context, char *output, int siz
 			}
 			ptr = context->data + len;
 			if (ptr > context->data + context->maxsize) {
-				tlog(TLOG_DEBUG, "length is not enouth %u:%ld, %p, %p", context->maxsize, (long)(ptr - context->data), context->ptr, context->data);
+				tlog(TLOG_DEBUG, "length is not enough %u:%ld, %p, %p", context->maxsize, (long)(ptr - context->data), context->ptr, context->data);
 				return -1;
 			}
 			is_compressed = 1;
@@ -973,7 +979,7 @@ static int _dns_decode_domain(struct dns_context *context, char *output, int siz
 		}

 		if (ptr > context->data + context->maxsize) {
-			tlog(TLOG_DEBUG, "length is not enouth %u:%ld, %p, %p", context->maxsize, (long)(ptr - context->data), context->ptr, context->data);
+			tlog(TLOG_DEBUG, "length is not enough %u:%ld, %p, %p", context->maxsize, (long)(ptr - context->data), context->ptr, context->data);
 			return -1;
 		}

@@ -982,7 +988,7 @@ static int _dns_decode_domain(struct dns_context *context, char *output, int siz
 			/* copy sub string */
 			copy_len = (len < size - output_len) ? len : size - 1 - output_len;
 			if ((ptr + copy_len) > (context->data + context->maxsize)) {
-				tlog(TLOG_DEBUG, "length is not enouth %u:%ld, %p, %p", context->maxsize, (long)(ptr - context->data), context->ptr, context->data);
+				tlog(TLOG_DEBUG, "length is not enough %u:%ld, %p, %p", context->maxsize, (long)(ptr - context->data), context->ptr, context->data);
 				return -1;
 			}
 			memcpy(output, ptr, copy_len);
--- a/src/dns.h
+++ b/src/dns.h
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef _DNS_HEAD_H
 #define _DNS_HEAD_H

--- a/src/dns_cache.c
+++ b/src/dns_cache.c
@@ -1,23 +1,52 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "dns_cache.h"
+#include "stringutil.h"
 #include "tlog.h"
 #include <pthread.h>

+#define DNS_CACHE_MAX_HITNUM 5000
+#define DNS_CACHE_HITNUM_STEP 2
+#define DNS_CACHE_HITNUM_STEP_MAX 6
+
 struct dns_cache_head {
 	DECLARE_HASHTABLE(cache_hash, 10);
 	struct list_head cache_list;
+	struct list_head inactive_list;
 	atomic_t num;
 	int size;
+	int enable_inactive;
+	int inactive_list_expired;
 	pthread_mutex_t lock;
 };

 static struct dns_cache_head dns_cache_head;

-int dns_cache_init(int size)
+int dns_cache_init(int size, int enable_inactive, int inactive_list_expired)
 {
 	INIT_LIST_HEAD(&dns_cache_head.cache_list);
+	INIT_LIST_HEAD(&dns_cache_head.inactive_list);
 	hash_init(dns_cache_head.cache_hash);
 	atomic_set(&dns_cache_head.num, 0);
 	dns_cache_head.size = size;
+	dns_cache_head.enable_inactive = enable_inactive;
+	dns_cache_head.inactive_list_expired = inactive_list_expired;

 	pthread_mutex_init(&dns_cache_head.lock, NULL);

@@ -26,11 +55,25 @@ int dns_cache_init(int size)

 static __attribute__((unused)) struct dns_cache *_dns_cache_last(void)
 {
+	struct dns_cache *dns_cache = NULL;
+
+	dns_cache = list_last_entry(&dns_cache_head.inactive_list, struct dns_cache, list);
+	if (dns_cache) {
+		return dns_cache;
+	}
+
 	return list_last_entry(&dns_cache_head.cache_list, struct dns_cache, list);
 }

 static struct dns_cache *_dns_cache_first(void)
 {
+	struct dns_cache *dns_cache = NULL;
+
+	dns_cache = list_first_entry_or_null(&dns_cache_head.inactive_list, struct dns_cache, list);
+	if (dns_cache) {
+		return dns_cache;
+	}
+
 	return list_first_entry_or_null(&dns_cache_head.cache_list, struct dns_cache, list);
 }

@@ -69,6 +112,12 @@ static void _dns_cache_remove(struct dns_cache *dns_cache)
 	dns_cache_release(dns_cache);
 }

+static void _dns_cache_move_inactive(struct dns_cache *dns_cache)
+{
+	list_del_init(&dns_cache->list);
+	list_add_tail(&dns_cache->list, &dns_cache_head.inactive_list);
+}
+
 int dns_cache_replace(char *domain, char *cname, int cname_ttl, int ttl, dns_type_t qtype, unsigned char *addr, int addr_len, int speed)
 {
 	struct dns_cache *dns_cache = NULL;
@@ -110,16 +159,19 @@ int dns_cache_replace(char *domain, char *cname, int cname_ttl, int ttl, dns_typ
 	}

 	if (cname) {
-		strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
+		safe_strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
 		dns_cache->cname_ttl = cname_ttl;
 	}
+
+	list_del_init(&dns_cache->list);
+	list_add_tail(&dns_cache->list, &dns_cache_head.cache_list);
 	pthread_mutex_unlock(&dns_cache_head.lock);

 	dns_cache_release(dns_cache);
 	return 0;
 errout_unlock:
 	pthread_mutex_unlock(&dns_cache_head.lock);
-//errout:
+	// errout:
 	if (dns_cache) {
 		dns_cache_release(dns_cache);
 	}
@@ -154,11 +206,12 @@ int dns_cache_insert(char *domain, char *cname, int cname_ttl, int ttl, dns_type

 	key = hash_string(domain);
 	key = jhash(&qtype, sizeof(qtype), key);
-	strncpy(dns_cache->domain, domain, DNS_MAX_CNAME_LEN);
+	safe_strncpy(dns_cache->domain, domain, DNS_MAX_CNAME_LEN);
 	dns_cache->cname[0] = 0;
 	dns_cache->qtype = qtype;
 	dns_cache->ttl = ttl;
-	atomic_set(&dns_cache->hitnum, 2);
+	atomic_set(&dns_cache->hitnum, 3);
+	dns_cache->hitnum_update_add = DNS_CACHE_HITNUM_STEP;
 	dns_cache->del_pending = 0;
 	dns_cache->speed = speed;
 	atomic_set(&dns_cache->ref, 1);
@@ -178,7 +231,7 @@ int dns_cache_insert(char *domain, char *cname, int cname_ttl, int ttl, dns_type
 	}

 	if (cname) {
-		strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
+		safe_strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
 		dns_cache->cname_ttl = cname_ttl;
 	}

@@ -239,7 +292,7 @@ struct dns_cache *dns_cache_lookup(char *domain, dns_type_t qtype)

 	if (dns_cache_ret) {
 		/* Return NULL if the cache times out */
-		if (now - dns_cache_ret->insert_time > dns_cache_ret->ttl) {
+		if (dns_cache_head.enable_inactive == 0 && (now - dns_cache_ret->insert_time > dns_cache_ret->ttl)) {
 			_dns_cache_remove(dns_cache_ret);
 			dns_cache_ret = NULL;
 		} else {
@@ -273,17 +326,58 @@ void dns_cache_delete(struct dns_cache *dns_cache)
 	pthread_mutex_unlock(&dns_cache_head.lock);
 }

+int dns_cache_hitnum_dec_get(struct dns_cache *dns_cache)
+{
+	int hitnum = 0;
+	pthread_mutex_lock(&dns_cache_head.lock);
+	hitnum = atomic_dec_return(&dns_cache->hitnum);
+	if (dns_cache->hitnum_update_add > DNS_CACHE_HITNUM_STEP) {
+		dns_cache->hitnum_update_add--;
+	}
+	pthread_mutex_unlock(&dns_cache_head.lock);
+
+	return hitnum;
+}
+
 void dns_cache_update(struct dns_cache *dns_cache)
 {
 	pthread_mutex_lock(&dns_cache_head.lock);
 	if (!list_empty(&dns_cache->list)) {
 		list_del_init(&dns_cache->list);
 		list_add_tail(&dns_cache->list, &dns_cache_head.cache_list);
-		atomic_inc(&dns_cache->hitnum);
+		atomic_add(dns_cache->hitnum_update_add, &dns_cache->hitnum);
+		if (atomic_read(&dns_cache->hitnum) > DNS_CACHE_MAX_HITNUM) {
+			atomic_set(&dns_cache->hitnum, DNS_CACHE_MAX_HITNUM);
+		}
+
+		if (dns_cache->hitnum_update_add < DNS_CACHE_HITNUM_STEP_MAX) {
+			dns_cache->hitnum_update_add++;
+		}
 	}
 	pthread_mutex_unlock(&dns_cache_head.lock);
 }

+void _dns_cache_remove_expired_ttl(time_t *now)
+{
+	struct dns_cache *dns_cache = NULL;
+	struct dns_cache *tmp;
+	int ttl = 0;
+
+	list_for_each_entry_safe(dns_cache, tmp, &dns_cache_head.inactive_list, list)
+	{
+		ttl = dns_cache->insert_time + dns_cache->ttl - *now;
+		if (ttl > 0) {
+			continue;
+		}
+
+		if (dns_cache_head.inactive_list_expired + ttl > 0) {
+			continue;
+		}
+
+		_dns_cache_remove(dns_cache);
+	}
+}
+
 void dns_cache_invalidate(dns_cache_preinvalid_callback callback, int ttl_pre)
 {
 	struct dns_cache *dns_cache = NULL;
@@ -312,9 +406,18 @@ void dns_cache_invalidate(dns_cache_preinvalid_callback callback, int ttl_pre)
 		}

 		if (ttl < 0) {
-			_dns_cache_remove(dns_cache);
+			if (dns_cache_head.enable_inactive) {
+				_dns_cache_move_inactive(dns_cache);
+			} else {
+				_dns_cache_remove(dns_cache);
+			}
 		}
 	}
+
+	if (dns_cache_head.enable_inactive && dns_cache_head.inactive_list_expired != 0) {
+		_dns_cache_remove_expired_ttl(&now);
+	}
+
 	pthread_mutex_unlock(&dns_cache_head.lock);

 	list_for_each_entry_safe(dns_cache, tmp, &checklist, check_list)
@@ -332,6 +435,11 @@ void dns_cache_destroy(void)
 	struct dns_cache *dns_cache = NULL;
 	struct dns_cache *tmp;
 	pthread_mutex_lock(&dns_cache_head.lock);
+	list_for_each_entry_safe(dns_cache, tmp, &dns_cache_head.inactive_list, list)
+	{
+		_dns_cache_delete(dns_cache);
+	}
+
 	list_for_each_entry_safe(dns_cache, tmp, &dns_cache_head.cache_list, list)
 	{
 		_dns_cache_delete(dns_cache);
--- a/src/dns_cache.h
+++ b/src/dns_cache.h
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef _SMARTDNS_CACHE_H
 #define _SMARTDNS_CACHE_H

@@ -9,6 +27,10 @@
 #include <stdlib.h>
 #include <time.h>

+#ifdef __cpluscplus
+extern "C" {
+#endif
+
 #define DNS_CACHE_TTL_MIN 30

 struct dns_cache {
@@ -19,9 +41,10 @@ struct dns_cache {
 	char domain[DNS_MAX_CNAME_LEN];
 	char cname[DNS_MAX_CNAME_LEN];
 	unsigned int cname_ttl;
-	unsigned int ttl;;
+	unsigned int ttl;
 	int speed;
 	atomic_t hitnum;
+	int hitnum_update_add;
 	int del_pending;
 	time_t insert_time;
 	dns_type_t qtype;
@@ -32,7 +55,7 @@ struct dns_cache {
 	};
 };

-int dns_cache_init(int size);
+int dns_cache_init(int size, int enable_inactive, int inactive_list_expired);

 int dns_cache_replace(char *domain, char *cname, int cname_ttl, int ttl, dns_type_t qtype, unsigned char *addr, int addr_len, int speed);

@@ -46,6 +69,8 @@ void dns_cache_get(struct dns_cache *dns_cache);

 void dns_cache_release(struct dns_cache *dns_cache);

+int dns_cache_hitnum_dec_get(struct dns_cache *dns_cache);
+
 void dns_cache_update(struct dns_cache *dns_cache);

 typedef void dns_cache_preinvalid_callback(struct dns_cache *dns_cache);
@@ -56,4 +81,7 @@ int dns_cache_get_ttl(struct dns_cache *dns_cache);

 void dns_cache_destroy(void);

+#ifdef __cpluscplus
+}
+#endif
 #endif // !_SMARTDNS_CACHE_H
--- a/src/dns_client.c
+++ b/src/dns_client.c
@@ -1,6 +1,6 @@
 /*************************************************************************
 *
- * Copyright (C) 2018 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
 *
 * smartdns is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -16,6 +16,7 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#define _GNU_SOURCE
 #include "dns_client.h"
 #include "atomic.h"
 #include "dns.h"
@@ -29,6 +30,7 @@
 #include "util.h"
 #include <arpa/inet.h>
 #include <errno.h>
+#include <ctype.h>
 #include <fcntl.h>
 #include <linux/filter.h>
 #include <netdb.h>
@@ -44,6 +46,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/epoll.h>
+#include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -57,10 +60,9 @@
 #define DNS_TCP_CONNECT_TIMEOUT (5)
 #define DNS_QUERY_TIMEOUT (500)
 #define DNS_QUERY_RETRY (3)
+#define SOCKET_PRIORITY (6)
+#define SOCKET_IP_TOS (IPTOS_LOWDELAY | IPTOS_RELIABILITY)

-#ifndef TCP_FASTOPEN_CONNECT
-#define TCP_FASTOPEN_CONNECT 30
-#endif

 /* ECS info */
 struct dns_client_ecs {
@@ -241,9 +243,34 @@ struct dns_query_struct {
 static struct dns_client client;
 static atomic_t dns_client_sid = ATOMIC_INIT(0);
 static LIST_HEAD(pending_servers);
-pthread_mutex_t pending_server_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t pending_server_mutex = PTHREAD_MUTEX_INITIALIZER;
 static int dns_client_has_bootstrap_dns = 0;

+const char *_dns_server_get_type_string(dns_server_type_t type) 
+{
+	const char *type_str = "";
+
+	switch (type)
+	{
+	case DNS_SERVER_UDP:
+		type_str = "udp";
+		break;
+	case DNS_SERVER_TCP:
+		type_str = "tcp";
+		break;
+	case DNS_SERVER_TLS:
+		type_str = "tls";
+		break;
+	case DNS_SERVER_HTTPS:
+		type_str = "https";
+		break;
+	default:
+		break;
+	}
+
+	return type_str;
+}
+
 /* get addr info */
 static struct addrinfo *_dns_client_getaddr(const char *host, char *port, int type, int protocol)
 {
@@ -435,7 +462,7 @@ static int _dns_client_add_to_pending_group(char *group_name, char *server_ip, i
 		goto errout;
 	}
 	memset(group, 0, sizeof(*group));
-	strncpy(group->group_name, group_name, DNS_GROUP_NAME_LEN);
+	safe_strncpy(group->group_name, group_name, DNS_GROUP_NAME_LEN);

 	pthread_mutex_lock(&pending_server_mutex);
 	list_add_tail(&group->list, &pending->group_list);
@@ -451,7 +478,7 @@ errout:
 }

 /* add server to group */
-int _dns_client_add_to_group_pending(char *group_name, char *server_ip, int port, dns_server_type_t server_type, int ispending)
+static int _dns_client_add_to_group_pending(char *group_name, char *server_ip, int port, dns_server_type_t server_type, int ispending)
 {
 	struct dns_server_info *server_info = NULL;

@@ -547,7 +574,7 @@ int dns_client_add_group(char *group_name)

 	memset(group, 0, sizeof(*group));
 	INIT_LIST_HEAD(&group->head);
-	strncpy(group->group_name, group_name, DNS_GROUP_NAME_LEN);
+	safe_strncpy(group->group_name, group_name, DNS_GROUP_NAME_LEN);
 	key = hash_string(group_name);
 	hash_add(client.group, &group->node, key);

@@ -623,6 +650,37 @@ int dns_client_spki_decode(const char *spki, unsigned char *spki_data_out)
 	return spki_data_len;
 }

+static char *_dns_client_server_get_tls_host_verify(struct dns_server_info *server_info)
+{
+	char *tls_host_verify = NULL;
+
+	switch (server_info->type) {
+	case DNS_SERVER_UDP: {
+	} break;
+	case DNS_SERVER_HTTPS: {
+		struct client_dns_server_flag_https *flag_https = &server_info->flags.https;
+		tls_host_verify = flag_https->tls_host_verify;
+	} break;
+	case DNS_SERVER_TLS: {
+		struct client_dns_server_flag_tls *flag_tls = &server_info->flags.tls;
+		tls_host_verify = flag_tls->tls_host_verify;
+	} break;
+	case DNS_SERVER_TCP:
+		break;
+	default:
+		return NULL;
+		break;
+	}
+
+	if (tls_host_verify) {
+		if (tls_host_verify[0] == '\0') {
+			return NULL;
+		}
+	}
+
+	return tls_host_verify;
+}
+
 static char *_dns_client_server_get_spki(struct dns_server_info *server_info, int *spki_len)
 {
 	*spki_len = 0;
@@ -640,7 +698,6 @@ static char *_dns_client_server_get_spki(struct dns_server_info *server_info, in
 		spki = flag_tls->spki;
 		*spki_len = flag_tls->spi_len;
 	} break;
-		break;
 	case DNS_SERVER_TCP:
 		break;
 	default:
@@ -660,7 +717,6 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 {
 	struct dns_server_info *server_info = NULL;
 	struct addrinfo *gai = NULL;
-	unsigned char *spki_data = NULL;
 	int spki_data_len = 0;
 	int ttl = 0;
 	char port_s[8];
@@ -683,9 +739,9 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 		spki_data_len = flag_https->spi_len;
 		if (flag_https->httphost[0] == 0) {
 			if (server_host) {
-				strncpy(flag_https->httphost, server_host, DNS_MAX_CNAME_LEN);
+				safe_strncpy(flag_https->httphost, server_host, DNS_MAX_CNAME_LEN);
 			} else {
-				strncpy(flag_https->httphost, server_ip, DNS_MAX_CNAME_LEN);
+				safe_strncpy(flag_https->httphost, server_ip, DNS_MAX_CNAME_LEN);
 			}
 		}
 		sock_type = SOCK_STREAM;
@@ -695,7 +751,6 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 		spki_data_len = flag_tls->spi_len;
 		sock_type = SOCK_STREAM;
 	} break;
-		break;
 	case DNS_SERVER_TCP:
 		sock_type = SOCK_STREAM;
 		break;
@@ -731,7 +786,7 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 	}

 	memset(server_info, 0, sizeof(*server_info));
-	strncpy(server_info->ip, server_ip, sizeof(server_info->ip));
+	safe_strncpy(server_info->ip, server_ip, sizeof(server_info->ip));
 	server_info->port = port;
 	server_info->ai_family = gai->ai_family;
 	server_info->ai_addrlen = gai->ai_addrlen;
@@ -752,7 +807,11 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,

 	/* if server type is TLS, create ssl context */
 	if (server_type == DNS_SERVER_TLS || server_type == DNS_SERVER_HTTPS) {
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+		server_info->ssl_ctx = SSL_CTX_new(TLS_client_method());
+#else
 		server_info->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
+#endif
 		if (server_info->ssl_ctx == NULL) {
 			tlog(TLOG_ERROR, "init ssl failed.");
 			goto errout;
@@ -789,12 +848,10 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 	atomic_inc(&client.dns_server_num);
 	freeaddrinfo(gai);

+	tlog(TLOG_INFO, "add server %s:%d, type: %s", server_ip, port, _dns_server_get_type_string(server_info->type));
+
 	return 0;
 errout:
-	if (spki_data) {
-		free(spki_data);
-	}
-
 	if (server_info) {
 		if (server_info->ssl_ctx) {
 			SSL_CTX_free(server_info->ssl_ctx);
@@ -822,7 +879,6 @@ static void _dns_client_close_socket(struct dns_server_info *server_info)

 	if (server_info->ssl) {
 		/* Shutdown ssl */
-		SSL_shutdown(server_info->ssl);
 		SSL_free(server_info->ssl);
 		server_info->ssl = NULL;
 	}
@@ -915,7 +971,7 @@ static int _dns_client_server_pending(char *server_ip, int port, dns_server_type
 	}
 	memset(pending, 0, sizeof(*pending));

-	strncpy(pending->host, server_ip, DNS_HOSTNAME_LEN);
+	safe_strncpy(pending->host, server_ip, DNS_HOSTNAME_LEN);
 	pending->port = port;
 	pending->type = server_type;
 	pending->ping_time_v4 = -1;
@@ -939,7 +995,8 @@ errout:
 	return -1;
 }

-static int _dns_client_add_server_pending(char *server_ip, char *server_host, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags, int ispending)
+static int _dns_client_add_server_pending(char *server_ip, char *server_host, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags,
+										  int ispending)
 {
 	int ret;

@@ -1235,10 +1292,12 @@ static int _dns_client_recv(struct dns_server_info *server_info, unsigned char *

 	/* get query reference */
 	query = _dns_client_get_request(packet->head.id, domain);
-	if (query == NULL || (query && has_opt == 0 && server_info->flags.result_flag & DNSSERVER_FLAG_CHECK_EDNS)) {
-		if (query) {
-			_dns_client_query_release(query);
-		}
+	if (query == NULL) {
+		return 0;
+	}
+
+	if (has_opt == 0 && server_info->flags.result_flag & DNSSERVER_FLAG_CHECK_EDNS) {
+		_dns_client_query_release(query);
 		return 0;
 	}

@@ -1278,6 +1337,8 @@ static int _dns_client_create_socket_udp(struct dns_server_info *server_info)
 	struct epoll_event event;
 	const int on = 1;
 	const int val = 255;
+	const int priority = SOCKET_PRIORITY;
+	const int ip_tos = SOCKET_IP_TOS;

 	fd = socket(server_info->ai_family, SOCK_DGRAM, 0);
 	if (fd < 0) {
@@ -1297,6 +1358,8 @@ static int _dns_client_create_socket_udp(struct dns_server_info *server_info)
 	server_info->status = DNS_SERVER_STATUS_CONNECTIONLESS;
 	setsockopt(server_info->fd, IPPROTO_IP, IP_RECVTTL, &on, sizeof(on));
 	setsockopt(server_info->fd, SOL_IP, IP_TTL, &val, sizeof(val));
+	setsockopt(server_info->fd, SOL_SOCKET, SO_PRIORITY, &priority, sizeof(priority));
+	setsockopt(server_info->fd, IPPROTO_IP, IP_TOS, &ip_tos, sizeof(ip_tos));
 	if (server_info->ai_family == AF_INET6) {
 		/* for recving ip ttl value */
 		setsockopt(server_info->fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on, sizeof(on));
@@ -1318,6 +1381,8 @@ static int _DNS_client_create_socket_tcp(struct dns_server_info *server_info)
 	int fd = 0;
 	struct epoll_event event;
 	int yes = 1;
+	const int priority = SOCKET_PRIORITY;
+	const int ip_tos = SOCKET_IP_TOS;

 	fd = socket(server_info->ai_family, SOCK_STREAM, 0);
 	if (fd < 0) {
@@ -1336,6 +1401,11 @@ static int _DNS_client_create_socket_tcp(struct dns_server_info *server_info)
 	}

 	setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes));
+	setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &priority, sizeof(priority));
+	setsockopt(fd, IPPROTO_IP, IP_TOS, &ip_tos, sizeof(ip_tos));
+	setsockopt(fd, IPPROTO_TCP, TCP_THIN_DUPACK, &yes, sizeof(yes));
+	setsockopt(fd, IPPROTO_TCP, TCP_THIN_LINEAR_TIMEOUTS, &yes, sizeof(yes));
+	set_sock_keepalive(fd, 15, 3, 4);

 	if (connect(fd, (struct sockaddr *)&server_info->addr, server_info->ai_addrlen) != 0) {
 		if (errno != EINPROGRESS) {
@@ -1372,6 +1442,8 @@ static int _DNS_client_create_socket_tls(struct dns_server_info *server_info, ch
 	struct epoll_event event;
 	SSL *ssl = NULL;
 	int yes = 1;
+	const int priority = SOCKET_PRIORITY;
+	const int ip_tos = SOCKET_IP_TOS;

 	if (server_info->ssl_ctx == NULL) {
 		tlog(TLOG_ERROR, "create ssl ctx failed.");
@@ -1401,6 +1473,11 @@ static int _DNS_client_create_socket_tls(struct dns_server_info *server_info, ch

 	// ? this cause ssl crash ?
 	// setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes));
+	// setsockopt(fd, IPPROTO_TCP, TCP_THIN_DUPACK, &yes, sizeof(yes));
+	// setsockopt(fd, IPPROTO_TCP, TCP_THIN_LINEAR_TIMEOUTS, &yes, sizeof(yes));
+	// set_sock_keepalive(fd, 15, 3, 4);
+	setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &priority, sizeof(priority));
+	setsockopt(fd, IPPROTO_IP, IP_TOS, &ip_tos, sizeof(ip_tos));

 	if (connect(fd, (struct sockaddr *)&server_info->addr, server_info->ai_addrlen) != 0) {
 		if (errno != EINPROGRESS) {
@@ -1571,17 +1648,17 @@ static int _dns_client_socket_ssl_send(SSL *ssl, const void *buf, int num)
 		break;
 	case SSL_ERROR_SSL:
 		ssl_err = ERR_get_error();
-		if (ERR_GET_REASON(ssl_err) == SSL_R_UNINITIALIZED) {
+		if (ERR_GET_REASON(ssl_err) == SSL_R_UNINITIALIZED || ERR_GET_REASON(ssl_err) == SSL_R_PROTOCOL_IS_SHUTDOWN) {
 			errno = EAGAIN;
 			return -1;
 		}

-		tlog(TLOG_ERROR, "SSL write fail error no:  %s(%ld)\n", ERR_reason_error_string(ssl_err), ssl_err);
+		tlog(TLOG_DEBUG, "SSL write fail error no:  %s(%ld)\n", ERR_reason_error_string(ssl_err), ssl_err);
 		errno = EFAULT;
 		ret = -1;
 		break;
 	case SSL_ERROR_SYSCALL:
-		tlog(TLOG_ERROR, "SSL syscall failed, %s", strerror(errno));
+		tlog(TLOG_DEBUG, "SSL syscall failed, %s", strerror(errno));
 		return ret;
 	default:
 		errno = EFAULT;
@@ -1678,13 +1755,97 @@ static int _dns_client_socket_recv(struct dns_server_info *server_info)
 	}
 }

+static int _dns_client_process_tcp_buff(struct dns_server_info *server_info)
+{
+	int len = 0;
+	int dns_packet_len = 0;
+	struct http_head *http_head = NULL;
+	unsigned char *inpacket_data = NULL;
+
+	while (1) {
+		if (server_info->type == DNS_SERVER_HTTPS) {
+			http_head = http_head_init(4096);
+			if (http_head == NULL) {
+				goto errout;
+			}
+
+			len = http_head_parse(http_head, (char *)server_info->recv_buff.data, server_info->recv_buff.len);
+			if (len < 0) {
+				tlog(TLOG_DEBUG, "remote server not supported.");
+				if (len == -1) {
+					break;
+				}
+				goto errout;
+			}
+
+			if (http_head_get_httpcode(http_head) != 200) {
+				tlog(TLOG_WARN, "http server query from %s:%d failed, server return http code : %d, %s", 
+					server_info->ip, server_info->port,
+					http_head_get_httpcode(http_head),
+					http_head_get_httpcode_msg(http_head));
+				goto errout;
+			}
+
+			dns_packet_len = http_head_get_data_len(http_head);
+			inpacket_data = (unsigned char *)http_head_get_data(http_head);
+		} else {
+			/* tcp result format
+			 * | len (short) | dns query result |
+			 */
+			inpacket_data = server_info->recv_buff.data;
+			len = ntohs(*((unsigned short *)(inpacket_data)));
+			if (len <= 0 || len >= DNS_IN_PACKSIZE) {
+				/* data len is invalid */
+				goto errout;
+			}
+
+			if (len > server_info->recv_buff.len - 2) {
+				/* len is not expceded, wait and recv */
+				break;
+			}
+
+			inpacket_data = server_info->recv_buff.data + 2;
+			dns_packet_len = len;
+			len += 2;
+		}
+
+		tlog(TLOG_DEBUG, "recv tcp packet from %s, len = %d", server_info->ip, len);
+		/* process result */
+		if (_dns_client_recv(server_info, inpacket_data, dns_packet_len, &server_info->addr, server_info->ai_addrlen) != 0) {
+			goto errout;
+		}
+
+		if (http_head) {
+			http_head_destroy(http_head);
+			http_head = NULL;
+		}
+
+		server_info->recv_buff.len -= len;
+		if (server_info->recv_buff.len < 0) {
+			tlog(TLOG_ERROR, "Internal error.");
+			abort();
+		}
+
+		/* move to next result */
+		if (server_info->recv_buff.len > 0) {
+			memmove(server_info->recv_buff.data, server_info->recv_buff.data + len, server_info->recv_buff.len);
+		} else {
+			break;
+		}
+	}
+
+	return 0;
+errout:
+	if (http_head) {
+		http_head_destroy(http_head);
+	}
+	return -1;
+}
+
 static int _dns_client_process_tcp(struct dns_server_info *server_info, struct epoll_event *event, unsigned long now)
 {
 	int len;
-	int dns_packet_len = 0;
 	int ret = -1;
-	struct http_head *http_head = NULL;
-	unsigned char *inpacket_data = NULL;

 	if (event->events & EPOLLIN) {
 		/* receive from tcp */
@@ -1700,7 +1861,7 @@ static int _dns_client_process_tcp(struct dns_server_info *server_info, struct e
 				goto errout;
 			}

-			tlog(TLOG_ERROR, "recv failed, server %s, %s\n", server_info->ip, strerror(errno));
+			tlog(TLOG_ERROR, "recv failed, server %s:%d, %s\n", server_info->ip, server_info->port, strerror(errno));
 			goto errout;
 		}

@@ -1721,77 +1882,14 @@ static int _dns_client_process_tcp(struct dns_server_info *server_info, struct e
 		}

 		time(&server_info->last_recv);
-
 		server_info->recv_buff.len += len;
-		if (server_info->recv_buff.len < 2) {
+		if (server_info->recv_buff.len <= 2) {
 			/* wait and recv */
 			return 0;
 		}

-		while (1) {
-			if (server_info->type == DNS_SERVER_HTTPS) {
-				http_head = http_head_init(4096);
-				if (http_head == NULL) {
-					goto errout;
-				}
-
-				len = http_head_parse(http_head, (char *)server_info->recv_buff.data, server_info->recv_buff.len);
-				if (len < 0) {
-					http_head_destroy(http_head);
-					if (len == -1) {
-						break;
-					}
-					goto errout;
-				}
-
-				if (http_head_get_httpcode(http_head) != 200) {
-					tlog(TLOG_WARN, "http server query failed, server return http code : %d, %s", http_head_get_httpcode(http_head),
-						 http_head_get_httpcode_msg(http_head));
-					goto errout;
-				}
-
-				dns_packet_len = http_head_get_data_len(http_head);
-				inpacket_data = (unsigned char *)http_head_get_data(http_head);
-			} else {
-				/* tcp result format
-				 * | len (short) | dns query result |
-				 */
-				inpacket_data = server_info->recv_buff.data;
-				len = ntohs(*((unsigned short *)(inpacket_data)));
-				if (len <= 0 || len >= DNS_IN_PACKSIZE) {
-					/* data len is invalid */
-					goto errout;
-				}
-
-				if (len > server_info->recv_buff.len - 2) {
-					/* len is not expceded, wait and recv */
-					break;
-				}
-
-				inpacket_data = server_info->recv_buff.data + 2;
-				dns_packet_len = len;
-				len += 2;
-			}
-			tlog(TLOG_DEBUG, "recv tcp packet from %s, len = %d", server_info->ip, len);
-
-			/* process result */
-			if (_dns_client_recv(server_info, inpacket_data, dns_packet_len, &server_info->addr, server_info->ai_addrlen) != 0) {
-				goto errout;
-			}
-
-			if (http_head) {
-				http_head_destroy(http_head);
-				http_head = NULL;
-			}
-
-			server_info->recv_buff.len -= len;
-
-			/* move to next result */
-			if (server_info->recv_buff.len > 0) {
-				memmove(server_info->recv_buff.data, server_info->recv_buff.data + len, server_info->recv_buff.len);
-			} else {
-				break;
-			}
+		if (_dns_client_process_tcp_buff(server_info) != 0) {
+			goto errout;
 		}
 	}

@@ -1807,26 +1905,27 @@ static int _dns_client_process_tcp(struct dns_server_info *server_info, struct e
 		if (server_info->status != DNS_SERVER_STATUS_CONNECTED) {
 			server_info->status = DNS_SERVER_STATUS_DISCONNECTED;
 		}
-		pthread_mutex_lock(&client.server_list_lock);
+
 		if (server_info->send_buff.len > 0) {
 			/* send existing send_buffer data  */
 			len = _dns_client_socket_send(server_info);
 			if (len < 0) {
 				if (errno == EAGAIN) {
-					pthread_mutex_unlock(&client.server_list_lock);
 					return 0;
 				}
-				pthread_mutex_unlock(&client.server_list_lock);
 				goto errout;
 			}

+			pthread_mutex_lock(&client.server_list_lock);
 			server_info->send_buff.len -= len;
 			if (server_info->send_buff.len > 0) {
 				memmove(server_info->send_buff.data, server_info->send_buff.data + len, server_info->send_buff.len);
+			} else if (server_info->send_buff.len < 0) {
+				tlog(TLOG_ERROR, "Internal Error");
+				abort();
 			}
+			pthread_mutex_unlock(&client.server_list_lock);
 		}
-		pthread_mutex_unlock(&client.server_list_lock);
-
 		/* still remain data, retry */
 		if (server_info->send_buff.len > 0) {
 			return 0;
@@ -1837,20 +1936,14 @@ static int _dns_client_process_tcp(struct dns_server_info *server_info, struct e
 		event.events = EPOLLIN;
 		event.data.ptr = server_info;
 		if (epoll_ctl(client.epoll_fd, EPOLL_CTL_MOD, server_info->fd, &event) != 0) {
-			tlog(TLOG_ERROR, "epoll ctl failed.");
+			tlog(TLOG_ERROR, "epoll ctl failed, %s", strerror(errno));
 			goto errout;
 		}
-
-		return 0;
 	}

 	return 0;

 errout:
-	if (http_head) {
-		http_head_destroy(http_head);
-	}
-
 	pthread_mutex_lock(&client.server_list_lock);
 	server_info->recv_buff.len = 0;
 	server_info->send_buff.len = 0;
@@ -1869,9 +1962,39 @@ static inline int _dns_client_to_hex(int c)
 	}
 }

+static int _dns_client_tls_matchName(const char *host, const char *pattern, int size)
+{
+	int match = -1;
+	int i = 0, j = 0;
+
+	while (i < size && host[j] != '\0') {
+		if (toupper(pattern[i]) == toupper(host[j])) {
+			i++;
+			j++;
+			continue;
+		}
+		if (pattern[i] == '*') {
+			while (host[j] != '.' && host[j] != '\0') {
+				j++;
+			}
+			i++;
+			continue;
+		}
+		break;
+	}
+
+	if (i == size && host[j] == '\0') {
+		match = 0;
+	}
+	
+	return match;
+}
+
 static int _dns_client_tls_verify(struct dns_server_info *server_info)
 {
 	X509 *cert = NULL;
+	X509_PUBKEY *pubkey = NULL;
+	X509_NAME *cert_name = NULL;
 	char peer_CN[256];
 	char cert_fingerprint[256];
 	int i = 0;
@@ -1881,6 +2004,10 @@ static int _dns_client_tls_verify(struct dns_server_info *server_info)
 	unsigned char *key_sha256 = NULL;
 	char *spki = NULL;
 	int spki_len = 0;
+	char *tls_host_verify = NULL;
+	if (server_info->ssl == NULL) {
+		return -1;
+	}

 	cert = SSL_get_peer_certificate(server_info->ssl);
 	if (cert == NULL) {
@@ -1888,11 +2015,36 @@ static int _dns_client_tls_verify(struct dns_server_info *server_info)
 		return -1;
 	}

-	X509_NAME_get_text_by_NID(X509_get_subject_name(cert), NID_commonName, peer_CN, 256);
+	cert_name = X509_get_subject_name(cert);
+	if (cert_name == NULL) {
+		tlog(TLOG_ERROR, "get subject name failed.");
+		goto errout;
+	}
+
+	if (X509_NAME_get_text_by_NID(cert_name, NID_commonName, peer_CN, 256) == -1) {
+		tlog(TLOG_ERROR, "cannot found x509 name");
+		goto errout;
+	}
+	
 	tlog(TLOG_DEBUG, "peer CN: %s", peer_CN);

+	/* check tls host */
+	tls_host_verify = _dns_client_server_get_tls_host_verify(server_info);
+	if (tls_host_verify) {
+		if (_dns_client_tls_matchName(peer_CN, tls_host_verify, strnlen(tls_host_verify, DNS_MAX_CNAME_LEN)) != 0) {
+			tlog(TLOG_INFO, "server %s CN is invalid, peer CN: %s, expect CN: %s", server_info->ip, peer_CN, tls_host_verify);
+			goto errout;
+		}
+	}
+
+	pubkey = X509_get_X509_PUBKEY(cert);
+	if (pubkey == NULL) {
+		tlog(TLOG_ERROR, "get pub key failed.");
+		goto errout;
+	}
+
 	/* get spki pin */
-	key_len = i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), NULL);
+	key_len = i2d_X509_PUBKEY(pubkey, NULL);
 	if (key_len <= 0) {
 		tlog(TLOG_ERROR, "get x509 public key failed.");
 		goto errout;
@@ -1905,7 +2057,7 @@ static int _dns_client_tls_verify(struct dns_server_info *server_info)
 		goto errout;
 	}

-	i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), &key_data_tmp);
+	i2d_X509_PUBKEY(pubkey, &key_data_tmp);

 	/* Get the SHA256 value of SPKI */
 	key_sha256 = SSL_SHA256(key_data, key_len, NULL);
@@ -1928,7 +2080,7 @@ static int _dns_client_tls_verify(struct dns_server_info *server_info)
 	tlog(TLOG_DEBUG, "cert SPKI pin(%s): %s", "sha256", cert_fingerprint);

 	spki = _dns_client_server_get_spki(server_info, &spki_len);
-	if (spki) {
+	if (spki && spki_len > 0 && spki_len <= SHA256_DIGEST_LENGTH) {
 		/* check SPKI */
 		if (memcmp(spki, key_sha256, spki_len) != 0) {
 			tlog(TLOG_INFO, "server %s cert spki is invalid", server_info->ip);
@@ -1960,6 +2112,11 @@ static int _dns_client_process_tls(struct dns_server_info *server_info, struct e
 	struct epoll_event fd_event;
 	int ssl_ret;

+	if (unlikely(server_info->ssl == NULL)) {
+		tlog(TLOG_ERROR, "ssl is invalid.");
+		goto errout;
+	}
+
 	if (server_info->status == DNS_SERVER_STATUS_CONNECTING) {
 		/* do SSL hand shake */
 		ret = SSL_connect(server_info->ssl);
@@ -1978,7 +2135,7 @@ static int _dns_client_process_tls(struct dns_server_info *server_info, struct e

 			fd_event.data.ptr = server_info;
 			if (epoll_ctl(client.epoll_fd, EPOLL_CTL_MOD, server_info->fd, &fd_event) != 0) {
-				tlog(TLOG_ERROR, "epoll ctl failed.");
+				tlog(TLOG_ERROR, "epoll ctl failed, %s", strerror(errno));
 				goto errout;
 			}

@@ -1991,6 +2148,7 @@ static int _dns_client_process_tls(struct dns_server_info *server_info, struct e
 			tlog(TLOG_DEBUG, "reused session");
 		} else {
 			tlog(TLOG_DEBUG, "new session");
+			pthread_mutex_lock(&client.server_list_lock);
 			if (server_info->ssl_session) {
 				/* free session */
 				SSL_SESSION_free(server_info->ssl_session);
@@ -1999,11 +2157,13 @@ static int _dns_client_process_tls(struct dns_server_info *server_info, struct e

 			if (_dns_client_tls_verify(server_info) != 0) {
 				tlog(TLOG_WARN, "peer %s verify failed.", server_info->ip);
+				pthread_mutex_unlock(&client.server_list_lock);
 				goto errout;
 			}

 			/* save ssl session for next request */
 			server_info->ssl_session = SSL_get1_session(server_info->ssl);
+			pthread_mutex_unlock(&client.server_list_lock);
 		}

 		server_info->status = DNS_SERVER_STATUS_CONNECTED;
@@ -2011,7 +2171,7 @@ static int _dns_client_process_tls(struct dns_server_info *server_info, struct e
 		fd_event.events = EPOLLIN | EPOLLOUT;
 		fd_event.data.ptr = server_info;
 		if (epoll_ctl(client.epoll_fd, EPOLL_CTL_MOD, server_info->fd, &fd_event) != 0) {
-			tlog(TLOG_ERROR, "epoll ctl failed.");
+			tlog(TLOG_ERROR, "epoll ctl failed, %s", strerror(errno));
 			goto errout;
 		}
 	}
@@ -2154,11 +2314,11 @@ static int _dns_client_send_tls(struct dns_server_info *server_info, void *packe

 	send_len = _dns_client_socket_ssl_send(server_info->ssl, inpacket, len);
 	if (send_len < 0) {
-		if (errno == EAGAIN || server_info->ssl == NULL) {
+		if (errno == EAGAIN || errno == EPIPE || server_info->ssl == NULL ) {
 			/* save data to buffer, and retry when EPOLLOUT is available */
 			return _dns_client_send_data_to_buffer(server_info, inpacket, len);
 		} else if (server_info->ssl && errno != ENOMEM) {
-			SSL_shutdown(server_info->ssl);
+			SSL_set_shutdown(server_info->ssl, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
 		}
 		return -1;
 	} else if (send_len < len) {
@@ -2204,11 +2364,11 @@ static int _dns_client_send_https(struct dns_server_info *server_info, void *pac

 	send_len = _dns_client_socket_ssl_send(server_info->ssl, inpacket, http_len);
 	if (send_len < 0) {
-		if (errno == EAGAIN || server_info->ssl == NULL) {
+		if (errno == EAGAIN || errno == EPIPE || server_info->ssl == NULL ) {
 			/* save data to buffer, and retry when EPOLLOUT is available */
 			return _dns_client_send_data_to_buffer(server_info, inpacket, http_len);
 		} else if (server_info->ssl && errno != ENOMEM) {
-			SSL_shutdown(server_info->ssl);
+			SSL_set_shutdown(server_info->ssl, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
 		}
 		return -1;
 	} else if (send_len < http_len) {
@@ -2375,7 +2535,7 @@ int dns_client_query(char *domain, int qtype, dns_client_callback callback, void
 	atomic_set(&query->dns_request_sent, 0);
 	atomic_set(&query->retry_count, DNS_QUERY_RETRY);
 	hash_init(query->replied_map);
-	strncpy(query->domain, domain, DNS_MAX_CNAME_LEN);
+	safe_strncpy(query->domain, domain, DNS_MAX_CNAME_LEN);
 	query->user_ptr = user_ptr;
 	query->callback = callback;
 	query->qtype = qtype;
@@ -2418,7 +2578,6 @@ errout_del_list:
 	query = NULL;
 errout:
 	if (query) {
-		tlog(TLOG_ERROR, "release %p", query);
 		free(query);
 	}
 	return -1;
@@ -2460,14 +2619,14 @@ static int _dns_client_pending_server_resolve(char *domain, dns_rtcode_t rtcode,
 		pending->ping_time_v4 = -1;
 		if (rtcode == DNS_RC_NOERROR) {
 			pending->ping_time_v4 = ping_time;
-			strncpy(pending->ipv4, ip, DNS_HOSTNAME_LEN);
+			safe_strncpy(pending->ipv4, ip, DNS_HOSTNAME_LEN);
 		}
 	} else if (addr_type == DNS_T_AAAA) {
 		pending->has_v6 = 1;
 		pending->ping_time_v6 = -1;
 		if (rtcode == DNS_RC_NOERROR) {
 			pending->ping_time_v6 = ping_time;
-			strncpy(pending->ipv6, ip, DNS_HOSTNAME_LEN);
+			safe_strncpy(pending->ipv6, ip, DNS_HOSTNAME_LEN);
 		}
 	} else {
 		return -1;
@@ -2542,9 +2701,9 @@ static void _dns_client_add_pending_servers(void)
 		/* if has no bootstrap DNS, just call getaddrinfo to get address */
 		if (dns_client_has_bootstrap_dns == 0) {
 			if (_dns_client_add_pendings(pending, pending->host) != 0) {
+				pthread_mutex_unlock(&pending_server_mutex);
 				tlog(TLOG_ERROR, "add pending DNS server %s failed", pending->host);
 				exit(1);
-				pthread_mutex_unlock(&pending_server_mutex);
 				return;
 			}
 			list_del_init(&pending->list);
--- a/src/dns_client.h
+++ b/src/dns_client.h
@@ -1,8 +1,31 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef _SMART_DNS_CLIENT_H
 #define _SMART_DNS_CLIENT_H

 #include "dns.h"
-#define DNS_SERVER_SPKI_LEN  64
+
+#ifdef __cpluscplus
+extern "C" {
+#endif
+
+#define DNS_SERVER_SPKI_LEN 64
 #define DNS_SERVER_GROUP_DEFAULT "default"

 typedef enum {
@@ -20,8 +43,9 @@ typedef enum dns_result_type {
 } dns_result_type;

 #define DNSSERVER_FLAG_BLACKLIST_IP (0x1 << 0)
-#define DNSSERVER_FLAG_CHECK_EDNS (0x1 << 1)
-#define DNSSERVER_FLAG_CHECK_TTL (0x1 << 2)
+#define DNSSERVER_FLAG_WHITELIST_IP (0x1 << 1)
+#define DNSSERVER_FLAG_CHECK_EDNS (0x1 << 2)
+#define DNSSERVER_FLAG_CHECK_TTL (0x1 << 3)

 int dns_client_init(void);

@@ -44,6 +68,7 @@ struct client_dns_server_flag_tls {
 	char spki[DNS_SERVER_SPKI_LEN];
 	int spi_len;
 	char hostname[DNS_MAX_CNAME_LEN];
+	char tls_host_verify[DNS_MAX_CNAME_LEN];
 };

 struct client_dns_server_flag_https {
@@ -52,6 +77,7 @@ struct client_dns_server_flag_https {
 	char hostname[DNS_MAX_CNAME_LEN];
 	char httphost[DNS_MAX_CNAME_LEN];
 	char path[DNS_MAX_CNAME_LEN];
+	char tls_host_verify[DNS_MAX_CNAME_LEN];
 };

 struct client_dns_server_flags {
@@ -84,4 +110,7 @@ int dns_client_remove_group(char *group_name);

 int dns_server_num(void);

+#ifdef __cpluscplus
+}
+#endif
 #endif
--- a/src/dns_conf.c
+++ b/src/dns_conf.c
@@ -1,15 +1,33 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "dns_conf.h"
 #include "list.h"
 #include "rbtree.h"
 #include "tlog.h"
 #include "util.h"
 #include <getopt.h>
+#include <libgen.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <syslog.h>
 #include <unistd.h>
- #include <libgen.h>

 #define DEFAULT_DNS_CACHE_SIZE 512

@@ -23,19 +41,27 @@ static struct dns_ipset_table dns_ipset_table;
 struct dns_group_table dns_group_table;

 /* server ip/port  */
-char dns_conf_server_ip[DNS_MAX_IPLEN];
-char dns_conf_server_tcp_ip[DNS_MAX_IPLEN];
+struct dns_bind_ip dns_conf_bind_ip[DNS_MAX_BIND_IP];
+int dns_conf_bind_ip_num = 0;
 int dns_conf_tcp_idle_time = 120;

 /* cache */
 int dns_conf_cachesize = DEFAULT_DNS_CACHE_SIZE;
 int dns_conf_prefetch = 0;
+int dns_conf_serve_expired = 0;
+int dns_conf_serve_expired_ttl = 0;

 /* upstream servers */
 struct dns_servers dns_conf_servers[DNS_MAX_SERVERS];
 char dns_conf_server_name[DNS_MAX_SERVER_NAME_LEN];
 int dns_conf_server_num;

+struct dns_domain_check_order dns_conf_check_order = {
+	.order = {DOMAIN_CHECK_ICMP, DOMAIN_CHECK_TCP},
+	.tcp_port = 80,
+};
+int dns_has_cap_ping = 0;
+
 /* logging */
 int dns_conf_log_level = TLOG_ERROR;
 char dns_conf_log_file[DNS_MAX_PATH];
@@ -44,6 +70,7 @@ int dns_conf_log_num = 8;

 /* auditing */
 int dns_conf_audit_enable = 0;
+int dns_conf_audit_log_SOA;
 char dns_conf_audit_file[DNS_MAX_PATH];
 size_t dns_conf_audit_size = 1024 * 1024;
 int dns_conf_audit_num = 2;
@@ -70,6 +97,49 @@ struct dns_edns_client_subnet dns_conf_ipv6_ecs;

 char dns_conf_sni_proxy_ip[DNS_MAX_IPLEN];

+static int _get_domain(char *value, char *domain, int max_dmain_size, char **ptr_after_domain)
+{
+	char *begin = NULL;
+	char *end = NULL;
+	int len = 0;
+
+	/* first field */
+	begin = strstr(value, "/");
+	if (begin == NULL) {
+		goto errout;
+	}
+
+	/* second field */
+	begin++;
+	end = strstr(begin, "/");
+	if (end == NULL) {
+		goto errout;
+	}
+
+	/* remove prefix . */
+	while (*begin == '.') {
+		begin++;
+	}
+
+	/* Get domain */
+	len = end - begin;
+	if (len >= max_dmain_size) {
+		tlog(TLOG_ERROR, "domain name %s too long", value);
+		goto errout;
+	}
+
+	memcpy(domain, begin, len);
+	domain[len] = '\0';
+
+	if (ptr_after_domain) {
+		*ptr_after_domain = end + 1;
+	}
+
+	return 0;
+errout:
+	return -1;
+}
+
 /* create and get dns server group */
 static struct dns_server_groups *_dns_conf_get_group(const char *group_name)
 {
@@ -90,7 +160,7 @@ static struct dns_server_groups *_dns_conf_get_group(const char *group_name)
 	}

 	memset(group, 0, sizeof(*group));
-	strncpy(group->group_name, group_name, DNS_GROUP_NAME_LEN);
+	safe_strncpy(group->group_name, group_name, DNS_GROUP_NAME_LEN);
 	hash_add(dns_group_table.group, &group->node, key);

 	return group;
@@ -168,6 +238,7 @@ static int _config_server(int argc, char *argv[], dns_server_type_t type, int de
 	/* clang-format off */
 	static struct option long_options[] = {
 		{"blacklist-ip", no_argument, NULL, 'b'}, /* filtering with blacklist-ip */
+		{"whitelist-ip", no_argument, NULL, 'w'}, /* filtering with whitelist-ip */
 #ifdef FEATURE_CHECK_EDNS
 		/* experimental feature */
 		{"check-edns", no_argument, NULL, 'e'},   /* check edns */
@@ -175,6 +246,7 @@ static int _config_server(int argc, char *argv[], dns_server_type_t type, int de
 		{"spki-pin", required_argument, NULL, 'p'}, /* check SPKI pin */
 		{"host-name", required_argument, NULL, 'h'}, /* host name */
 		{"http-host", required_argument, NULL, 'H'}, /* http host */
+		{"tls-host-verify", required_argument, NULL, 'V' }, /* verify tls hostname */
 		{"group", required_argument, NULL, 'g'}, /* add to group */
 		{"exclude-default-group", no_argument, NULL, 'E'}, /* ecluse this from default group */
 		{NULL, no_argument, NULL, 0}
@@ -195,6 +267,7 @@ static int _config_server(int argc, char *argv[], dns_server_type_t type, int de
 	server->path[0] = '\0';
 	server->hostname[0] = '\0';
 	server->httphost[0] = '\0';
+	server->tls_host_verify[0] = '\0';

 	ip = argv[1];

@@ -202,10 +275,10 @@ static int _config_server(int argc, char *argv[], dns_server_type_t type, int de
 		if (parse_uri(ip, NULL, server->server, &port, server->path) != 0) {
 			return -1;
 		}
-		strncpy(server->hostname, server->server, sizeof(server->hostname));
-		strncpy(server->httphost, server->httphost, sizeof(server->hostname));
+		safe_strncpy(server->hostname, server->server, sizeof(server->hostname));
+		safe_strncpy(server->httphost, server->server, sizeof(server->httphost));
 		if (server->path[0] == 0) {
-			strcpy(server->path, "/");
+			safe_strncpy(server->path, "/", sizeof(server->path));
 		}
 	} else {
 		/* parse ip, port from ip */
@@ -232,16 +305,20 @@ static int _config_server(int argc, char *argv[], dns_server_type_t type, int de
 			result_flag |= DNSSERVER_FLAG_BLACKLIST_IP;
 			break;
 		}
+		case 'w': {
+			result_flag |= DNSSERVER_FLAG_WHITELIST_IP;
+			break;
+		}
 		case 'e': {
 			result_flag |= DNSSERVER_FLAG_CHECK_EDNS;
 			break;
 		}
 		case 'h': {
-			strncpy(server->hostname, optarg, DNS_MAX_CNAME_LEN);
+			safe_strncpy(server->hostname, optarg, DNS_MAX_CNAME_LEN);
 			break;
 		}
 		case 'H': {
-			strncpy(server->httphost, optarg, DNS_MAX_CNAME_LEN);
+			safe_strncpy(server->httphost, optarg, DNS_MAX_CNAME_LEN);
 			break;
 		}
 		case 'E': {
@@ -256,7 +333,11 @@ static int _config_server(int argc, char *argv[], dns_server_type_t type, int de
 			break;
 		}
 		case 'p': {
-			strncpy(server->spki, optarg, DNS_MAX_SPKI_LEN);
+			safe_strncpy(server->spki, optarg, DNS_MAX_SPKI_LEN);
+			break;
+		}
+		case 'V': {
+			safe_strncpy(server->tls_host_verify, optarg, DNS_MAX_CNAME_LEN);
 			break;
 		}
 		default:
@@ -339,7 +420,7 @@ static int _config_domain_rule_add(char *domain, enum domain_rule type, void *ru
 		tlog(TLOG_ERROR, "domain name %s too long", domain);
 		goto errout;
 	}
-	reverse_string(domain_key, domain, len);
+	reverse_string(domain_key, domain, len, 1);
 	domain_key[len] = '.';
 	len++;
 	domain_key[len] = 0;
@@ -400,7 +481,7 @@ static int _config_domain_rule_flag_set(char *domain, unsigned int flag)
 		tlog(TLOG_ERROR, "domain %s too long", domain);
 		return -1;
 	}
-	reverse_string(domain_key, domain, len);
+	reverse_string(domain_key, domain, len, 1);
 	domain_key[len] = '.';
 	len++;
 	domain_key[len] = 0;
@@ -476,7 +557,7 @@ static const char *_dns_conf_get_ipset(const char *ipsetname)
 	}

 	key = hash_string(ipsetname);
-	strncpy(ipset_name->ipsetname, ipsetname, DNS_MAX_IPSET_NAMELEN);
+	safe_strncpy(ipset_name->ipsetname, ipsetname, DNS_MAX_IPSET_NAMELEN);
 	hash_add(dns_ipset_table.ipset, &ipset_name->node, key);

 	return ipset_name->ipsetname;
@@ -488,58 +569,14 @@ errout:
 	return NULL;
 }

-static int _config_ipset(void *data, int argc, char *argv[])
+static int _conf_domain_rule_ipset(char *domain, const char *ipsetname)
 {
 	struct dns_ipset_rule *ipset_rule = NULL;
-	char domain[DNS_MAX_CONF_CNAME_LEN];
-	char ipsetname[DNS_MAX_CONF_CNAME_LEN];
 	const char *ipset = NULL;
-	char *begin = NULL;
-	char *end = NULL;
-	int len = 0;
-	char *value = argv[1];
-
-	if (argc <= 1) {
-		goto errout;
-	}
-
-	/* first field */
-	begin = strstr(value, "/");
-	if (begin == NULL) {
-		goto errout;
-	}
-
-	/* second field */
-	begin++;
-	end = strstr(begin, "/");
-	if (end == NULL) {
-		goto errout;
-	}
-
-	/* remove prefix . */
-	while (*begin == '.') {
-		begin++;
-	}
-
-	/* Get domain */
-	len = end - begin;
-	if (len >= sizeof(domain)) {
-		tlog(TLOG_ERROR, "domain name %s too long", value);
-		goto errout;
-	}
-
-	memcpy(domain, begin, len);
-	domain[len] = '\0';
-
-	len = strlen(end + 1);
-	if (len <= 0) {
-		goto errout;
-	}

 	/* Process domain option */
-	if (strncmp(end + 1, "-", sizeof("-")) != 0) {
+	if (strncmp(ipsetname, "-", sizeof("-")) != 0) {
 		/* new ipset domain */
-		strncpy(ipsetname, end + 1, DNS_MAX_IPSET_NAMELEN);
 		ipset = _dns_conf_get_ipset(ipsetname);
 		if (ipset == NULL) {
 			goto errout;
@@ -570,66 +607,47 @@ errout:
 		free(ipset_rule);
 	}

+	tlog(TLOG_ERROR, "add ipset %s failed", ipsetname);
+	return 0;
+}
+
+static int _config_ipset(void *data, int argc, char *argv[])
+{
+	char domain[DNS_MAX_CONF_CNAME_LEN];
+	char *value = argv[1];
+
+	if (argc <= 1) {
+		goto errout;
+	}
+
+	if (_get_domain(value, domain, DNS_MAX_CONF_CNAME_LEN, &value) != 0) {
+		goto errout;
+	}
+
+	return _conf_domain_rule_ipset(domain, value);
+errout:
 	tlog(TLOG_ERROR, "add ipset %s failed", value);
 	return 0;
 }

-static int _config_address(void *data, int argc, char *argv[])
+static int _conf_domain_rule_address(char *domain, const char *domain_address)
 {
 	struct dns_address_IPV4 *address_ipv4 = NULL;
 	struct dns_address_IPV6 *address_ipv6 = NULL;
 	void *address = NULL;
-	char *value = argv[1];
 	char ip[MAX_IP_LEN];
-	char domain[DNS_MAX_CONF_CNAME_LEN];
-	char *begin = NULL;
-	char *end = NULL;
-	int len = 0;
 	int port;
 	struct sockaddr_storage addr;
 	socklen_t addr_len = sizeof(addr);
 	enum domain_rule type = 0;
 	unsigned int flag = 0;

-	if (argc <= 1) {
-		goto errout;
-	}
-
-	/* first field */
-	begin = strstr(value, "/");
-	if (begin == NULL) {
-		goto errout;
-	}
-
-	/* second field */
-	begin++;
-	end = strstr(begin, "/");
-	if (end == NULL) {
-		goto errout;
-	}
-
-	/* remove prefix . */
-	while (*begin == '.') {
-		begin++;
-	}
-
-	/* get domain */
-	len = end - begin;
-
-	if (len >= sizeof(domain)) {
-		tlog(TLOG_ERROR, "domain name %s too long", value);
-		goto errout;
-	}
-
-	memcpy(domain, begin, len);
-	domain[len] = 0;
-
-	if (*(end + 1) == '#') {
-		if (strncmp(end + 1, "#4", sizeof("#4")) == 0) {
+	if (*(domain_address) == '#') {
+		if (strncmp(domain_address, "#4", sizeof("#4")) == 0) {
 			flag = DOMAIN_FLAG_ADDR_IPV4_SOA;
-		} else if (strncmp(end + 1, "#6", sizeof("#6")) == 0) {
+		} else if (strncmp(domain_address, "#6", sizeof("#6")) == 0) {
 			flag = DOMAIN_FLAG_ADDR_IPV6_SOA;
-		} else if (strncmp(end + 1, "#", sizeof("#")) == 0) {
+		} else if (strncmp(domain_address, "#", sizeof("#")) == 0) {
 			flag = DOMAIN_FLAG_ADDR_SOA;
 		} else {
 			goto errout;
@@ -641,12 +659,12 @@ static int _config_address(void *data, int argc, char *argv[])
 		}

 		return 0;
-	} else if (*(end + 1) == '-') {
-		if (strncmp(end + 1, "-4", sizeof("-4")) == 0) {
+	} else if (*(domain_address) == '-') {
+		if (strncmp(domain_address, "-4", sizeof("-4")) == 0) {
 			flag = DOMAIN_FLAG_ADDR_IPV4_IGN;
-		} else if (strncmp(end + 1, "-6", sizeof("-6")) == 0) {
+		} else if (strncmp(domain_address, "-6", sizeof("-6")) == 0) {
 			flag = DOMAIN_FLAG_ADDR_IPV6_IGN;
-		} else if (strncmp(end + 1, "-", sizeof("-")) == 0) {
+		} else if (strncmp(domain_address, "-", sizeof("-")) == 0) {
 			flag = DOMAIN_FLAG_ADDR_IGN;
 		} else {
 			goto errout;
@@ -660,7 +678,7 @@ static int _config_address(void *data, int argc, char *argv[])
 		return 0;
 	} else {
 		/* set address to domain */
-		if (parse_ip(end + 1, ip, &port) != 0) {
+		if (parse_ip(domain_address, ip, &port) != 0) {
 			goto errout;
 		}

@@ -718,10 +736,220 @@ errout:
 		free(address);
 	}

+	tlog(TLOG_ERROR, "add address %s, %s  failed", domain, domain_address);
+	return 0;
+}
+
+static int _config_address(void *data, int argc, char *argv[])
+{
+	char *value = argv[1];
+	char domain[DNS_MAX_CONF_CNAME_LEN];
+
+	if (argc <= 1) {
+		goto errout;
+	}
+
+	if (_get_domain(value, domain, DNS_MAX_CONF_CNAME_LEN, &value) != 0) {
+		goto errout;
+	}
+
+	return _conf_domain_rule_address(domain, value);
+errout:
 	tlog(TLOG_ERROR, "add address %s failed", value);
 	return 0;
 }

+static int _config_speed_check_mode_parser(struct dns_domain_check_order *check_order, const char *mode)
+{
+	char tmpbuff[DNS_MAX_OPT_LEN];
+	char *field;
+	char *ptr;
+	int order = 0;
+	int port = 80;
+	int i = 0;
+
+	safe_strncpy(tmpbuff, mode, DNS_MAX_OPT_LEN);
+	memset(check_order, 0, sizeof(*check_order));
+
+	ptr = tmpbuff;
+	do {
+		field = ptr;
+		ptr = strstr(ptr, ",");
+		if (field == NULL || order >= DOMAIN_CHECK_NUM) {
+			return 0;
+		}
+
+		if (ptr) {
+			*ptr = 0;
+		}
+
+		if (strncmp(field, "ping", sizeof("ping")) == 0) {
+			if (dns_has_cap_ping == 0) {
+				if (ptr) {
+					ptr++;
+				}
+				continue;
+			}
+			check_order->order[order] = DOMAIN_CHECK_ICMP;
+		} else if (strstr(field, "tcp") == field) {
+			char *port_str = strstr(field, ":");
+			if (port_str) {
+				port = atoi(port_str + 1);
+				if (port <= 0 || port >= 65535) {
+					port = 80;
+				}
+			}
+
+			check_order->order[order] = DOMAIN_CHECK_TCP;
+			check_order->tcp_port = port;
+		} else if (strncmp(field, "none", sizeof("none")) == 0) {
+			check_order->order[order] = DOMAIN_CHECK_NONE;
+			for (i = order + 1; i < DOMAIN_CHECK_NUM; i++) {
+				check_order->order[i] = DOMAIN_CHECK_NONE;
+			}
+
+			return 0;
+		}
+		order++;
+		if (ptr) {
+			ptr++;
+		}
+
+	} while (ptr);
+
+	return 0;
+}
+
+static int _config_speed_check_mode(void *data, int argc, char *argv[])
+{
+	char mode[DNS_MAX_OPT_LEN];
+
+	if (argc <= 1) {
+		return -1;
+	}
+
+	safe_strncpy(mode, argv[1], sizeof(mode));
+	return _config_speed_check_mode_parser(&dns_conf_check_order, mode);
+}
+
+static int _config_bind_ip(int argc, char *argv[], DNS_BIND_TYPE type)
+{
+	int index = dns_conf_bind_ip_num;
+	struct dns_bind_ip *bind_ip;
+	char *ip = NULL;
+	int opt = 0;
+	char group_name[DNS_GROUP_NAME_LEN];
+	const char *group = NULL;
+	unsigned int server_flag = 0;
+
+	/* clang-format off */
+	static struct option long_options[] = {
+		{"group", required_argument, NULL, 'g'}, /* add to group */
+		{"no-rule-addr", no_argument, NULL, 'A'},   
+		{"no-rule-nameserver", no_argument, NULL, 'N'},   
+		{"no-rule-ipset", no_argument, NULL, 'I'},   
+		{"no-rule-sni-proxy", no_argument, NULL, 'P'},   
+		{"no-rule-soa", no_argument, NULL, 'O'},
+		{"no-speed-check", no_argument, NULL, 'S'},  
+		{"no-cache", no_argument, NULL, 'C'},  
+		{"no-dualstack-selection", no_argument, NULL, 'D'},
+		{"force-aaaa-soa", no_argument, NULL, 'F'},
+		{NULL, no_argument, NULL, 0}
+	};
+	/* clang-format on */
+	if (argc <= 1) {
+		tlog(TLOG_ERROR, "invalid parameter.");
+		goto errout;
+	}
+
+	if (index >= DNS_MAX_SERVERS) {
+		tlog(TLOG_WARN, "exceeds max server number, %s", ip);
+		return 0;
+	}
+
+	bind_ip = &dns_conf_bind_ip[index];
+	bind_ip->type = type;
+	bind_ip->flags = 0;
+	ip = argv[1];
+	safe_strncpy(bind_ip->ip, ip, DNS_MAX_IPLEN);
+
+	/* process extra options */
+	optind = 1;
+	while (1) {
+		opt = getopt_long_only(argc, argv, "", long_options, NULL);
+		if (opt == -1) {
+			break;
+		}
+
+		switch (opt) {
+		case 'g': {
+			safe_strncpy(group_name, optarg, DNS_GROUP_NAME_LEN);
+			group = _dns_conf_get_group_name(group_name);
+			break;
+		}
+		case 'A': {
+			server_flag |= BIND_FLAG_NO_RULE_ADDR;
+			break;
+		}
+		case 'N': {
+			server_flag |= BIND_FLAG_NO_RULE_NAMESERVER;
+			break;
+		}
+		case 'I': {
+			server_flag |= BIND_FLAG_NO_RULE_IPSET;
+			break;
+		}
+		case 'P': {
+			server_flag |= BIND_FLAG_NO_RULE_SNIPROXY;
+			break;
+		}
+		case 'S': {
+			server_flag |= BIND_FLAG_NO_SPEED_CHECK;
+			break;
+		}
+		case 'C': {
+			server_flag |= BIND_FLAG_NO_CACHE;
+			break;
+		}
+		case 'O': {
+			server_flag |= BIND_FLAG_NO_RULE_SOA;
+			break;
+		}
+		case 'D': {
+			server_flag |= BIND_FLAG_NO_DUALSTACK_SELECTION;
+			break;
+		}
+		case 'F': {
+			server_flag |= BIND_FLAG_FORCE_AAAA_SOA;
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
+	/* add new server */
+	bind_ip->flags = server_flag;
+	bind_ip->group = group;
+	dns_conf_bind_ip_num++;
+	tlog(TLOG_DEBUG, "bind ip %s, type:%d, flag: %X", ip, type, server_flag);
+
+	return 0;
+
+errout:
+	return -1;
+}
+
+static int _config_bind_ip_udp(void *data, int argc, char *argv[])
+{
+	return _config_bind_ip(argc, argv, DNS_BIND_TYPE_UDP);
+}
+
+static int _config_bind_ip_tcp(void *data, int argc, char *argv[])
+{
+	return _config_bind_ip(argc, argv, DNS_BIND_TYPE_TCP);
+}
+
 static int _config_server_udp(void *data, int argc, char *argv[])
 {
 	return _config_server(argc, argv, DNS_SERVER_UDP, DEFAULT_DNS_PORT);
@@ -745,56 +973,12 @@ static int _config_server_https(void *data, int argc, char *argv[])
 	return ret;
 }

-static int _config_nameserver(void *data, int argc, char *argv[])
+static int _conf_domain_rule_nameserver(char *domain, const char *group_name)
 {
 	struct dns_nameserver_rule *nameserver_rule = NULL;
-	char domain[DNS_MAX_CONF_CNAME_LEN];
-	char group_name[DNS_GROUP_NAME_LEN];
 	const char *group = NULL;
-	char *begin = NULL;
-	char *end = NULL;
-	int len = 0;
-	char *value = argv[1];

-	if (argc <= 1) {
-		goto errout;
-	}
-
-	/* first field */
-	begin = strstr(value, "/");
-	if (begin == NULL) {
-		goto errout;
-	}
-
-	/* second field */
-	begin++;
-	end = strstr(begin, "/");
-	if (end == NULL) {
-		goto errout;
-	}
-
-	/* remove prefix . */
-	while (*begin == '.') {
-		begin++;
-	}
-
-	len = end - begin;
-
-	if (len >= sizeof(domain)) {
-		tlog(TLOG_ERROR, "domain name %s too long", value);
-		goto errout;
-	}
-
-	memcpy(domain, begin, len);
-	domain[len] = '\0';
-
-	len = strlen(end + 1);
-	if (len <= 0) {
-		goto errout;
-	}
-
-	if (strncmp(end + 1, "-", sizeof("-")) != 0) {
-		strncpy(group_name, end + 1, DNS_GROUP_NAME_LEN);
+	if (strncmp(group_name, "-", sizeof("-")) != 0) {
 		group = _dns_conf_get_group_name(group_name);
 		if (group == NULL) {
 			goto errout;
@@ -825,6 +1009,25 @@ errout:
 		free(nameserver_rule);
 	}

+	tlog(TLOG_ERROR, "add nameserver %s, %s failed", domain, group_name);
+	return 0;
+}
+
+static int _config_nameserver(void *data, int argc, char *argv[])
+{
+	char domain[DNS_MAX_CONF_CNAME_LEN];
+	char *value = argv[1];
+
+	if (argc <= 1) {
+		goto errout;
+	}
+
+	if (_get_domain(value, domain, DNS_MAX_CONF_CNAME_LEN, &value) != 0) {
+		goto errout;
+	}
+
+	return _conf_domain_rule_nameserver(domain, value);
+errout:
 	tlog(TLOG_ERROR, "add nameserver %s failed", value);
 	return 0;
 }
@@ -881,11 +1084,17 @@ static int _config_iplist_rule(char *subnet, enum address_rule rule)
 	case ADDRESS_RULE_BLACKLIST:
 		ip_rule->blacklist = 1;
 		break;
+	case ADDRESS_RULE_WHITELIST:
+		ip_rule->whitelist = 1;
+		break;
 	case ADDRESS_RULE_BOGUS:
 		ip_rule->bogus = 1;
 		break;
 	case ADDRESS_RULE_IP_IGNORE:
 		ip_rule->ip_ignore = 1;
+		break;
+	default:
+		return -1;
 	}

 	return 0;
@@ -918,6 +1127,15 @@ static int _conf_ip_ignore(void *data, int argc, char *argv[])
 	return _config_iplist_rule(argv[1], ADDRESS_RULE_IP_IGNORE);
 }

+static int _conf_whitelist_ip(void *data, int argc, char *argv[])
+{
+	if (argc <= 1) {
+		return -1;
+	}
+
+	return _config_iplist_rule(argv[1], ADDRESS_RULE_WHITELIST);
+}
+
 static int _conf_edns_client_subnet(void *data, int argc, char *argv[])
 {
 	char *slash = NULL;
@@ -958,7 +1176,7 @@ static int _conf_edns_client_subnet(void *data, int argc, char *argv[])
 		goto errout;
 	}

-	strncpy(ecs->ip, value, DNS_MAX_IPLEN);
+	safe_strncpy(ecs->ip, value, DNS_MAX_IPLEN);
 	ecs->subnet = subnet;
 	ecs->enable = 1;

@@ -968,6 +1186,127 @@ errout:
 	return -1;
 }

+static int _conf_domain_rule_speed_check(char *domain, const char *mode)
+{
+	struct dns_domain_check_order *check_order;
+
+	check_order = malloc(sizeof(*check_order));
+	if (check_order == NULL) {
+		goto errout;
+	}
+
+	if (_config_speed_check_mode_parser(check_order, mode) != 0) {
+		goto errout;
+	}
+
+	if (_config_domain_rule_add(domain, DOMAIN_RULE_CHECKSPEED, check_order) != 0) {
+		goto errout;
+	}
+
+	return 0;
+errout:
+	if (check_order) {
+		free(check_order);
+	}
+	return 0;
+}
+
+static int _conf_domain_rules(void *data, int argc, char *argv[])
+{
+	int opt = 0;
+	char domain[DNS_MAX_CONF_CNAME_LEN];
+	char *value = argv[1];
+
+	/* clang-format off */
+	static struct option long_options[] = {
+		{"speed-check-mode", required_argument, NULL, 'c'},
+		{"address", required_argument, NULL, 'a'},
+		{"ipset", required_argument, NULL, 'p'},
+		{"nameserver", required_argument, NULL, 'n'},
+		{NULL, no_argument, NULL, 0}
+	};
+	/* clang-format on */
+
+	if (argc <= 1) {
+		tlog(TLOG_ERROR, "invalid parameter.");
+		goto errout;
+	}
+
+	if (_get_domain(value, domain, DNS_MAX_CONF_CNAME_LEN, &value) != 0) {
+		goto errout;
+	}
+
+	/* process extra options */
+	optind = 1;
+	while (1) {
+		opt = getopt_long_only(argc, argv, "", long_options, NULL);
+		if (opt == -1) {
+			break;
+		}
+
+		switch (opt) {
+		case 'c': {
+			const char *check_mode = optarg;
+			if (check_mode == NULL) {
+				goto errout;
+			}
+
+			if (_conf_domain_rule_speed_check(domain, check_mode) != 0) {
+				tlog(TLOG_ERROR, "add check-speed-rule rule failed.");
+				goto errout;
+			}
+
+			break;
+		}
+		case 'a': {
+			const char *address = optarg;
+			if (address == NULL) {
+				goto errout;
+			}
+
+			if (_conf_domain_rule_address(domain, address) != 0) {
+				tlog(TLOG_ERROR, "add address rule failed.");
+				goto errout;
+			}
+
+			break;
+		}
+		case 'p': {
+			const char *ipsetname = optarg;
+			if (ipsetname == NULL) {
+				goto errout;
+			}
+
+			if (_conf_domain_rule_ipset(domain, ipsetname) != 0) {
+				tlog(TLOG_ERROR, "add ipset rule failed.");
+				goto errout;
+			}
+
+			break;
+		}
+		case 'n': {
+			const char *nameserver_group = optarg;
+			if (nameserver_group == NULL) {
+				goto errout;
+			}
+
+			if (_conf_domain_rule_nameserver(domain, nameserver_group) != 0) {
+				tlog(TLOG_ERROR, "add nameserver rule failed.");
+				goto errout;
+			}
+
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
+	return 0;
+errout:
+	return -1;
+}
+
 static int _config_log_level(void *data, int argc, char *argv[])
 {
 	/* read log level and set */
@@ -985,7 +1324,7 @@ static int _config_log_level(void *data, int argc, char *argv[])
 		dns_conf_log_level = TLOG_ERROR;
 	} else if (strncmp("fatal", value, MAX_LINE_LEN) == 0) {
 		dns_conf_log_level = TLOG_FATAL;
-	}else {
+	} else {
 		return -1;
 	}

@@ -994,8 +1333,8 @@ static int _config_log_level(void *data, int argc, char *argv[])

 static struct config_item _config_item[] = {
 	CONF_STRING("server-name", (char *)dns_conf_server_name, DNS_MAX_SERVER_NAME_LEN),
-	CONF_STRING("bind", dns_conf_server_ip, DNS_MAX_IPLEN),
-	CONF_STRING("bind-tcp", dns_conf_server_tcp_ip, DNS_MAX_IPLEN),
+	CONF_CUSTOM("bind", _config_bind_ip_udp, NULL),
+	CONF_CUSTOM("bind-tcp", _config_bind_ip_tcp, NULL),
 	CONF_CUSTOM("server", _config_server_udp, NULL),
 	CONF_CUSTOM("server-tcp", _config_server_tcp, NULL),
 	CONF_CUSTOM("server-tls", _config_server_tls, NULL),
@@ -1004,9 +1343,12 @@ static struct config_item _config_item[] = {
 	CONF_CUSTOM("address", _config_address, NULL),
 	CONF_YESNO("ipset-timeout", &dns_conf_ipset_timeout_enable),
 	CONF_CUSTOM("ipset", _config_ipset, NULL),
+	CONF_CUSTOM("speed-check-mode", _config_speed_check_mode, NULL),
 	CONF_INT("tcp-idle-time", &dns_conf_tcp_idle_time, 0, 3600),
 	CONF_INT("cache-size", &dns_conf_cachesize, 0, CONF_INT_MAX),
 	CONF_YESNO("prefetch-domain", &dns_conf_prefetch),
+	CONF_YESNO("serve-expired", &dns_conf_serve_expired),
+	CONF_INT("serve-expired-ttl", &dns_conf_serve_expired_ttl, 0, CONF_INT_MAX),
 	CONF_YESNO("dualstack-ip-selection", &dns_conf_dualstack_ip_selection),
 	CONF_INT("dualstack-ip-selection-threshold", &dns_conf_dualstack_ip_selection_threshold, 0, 1000),
 	CONF_CUSTOM("log-level", _config_log_level, NULL),
@@ -1014,6 +1356,7 @@ static struct config_item _config_item[] = {
 	CONF_SIZE("log-size", &dns_conf_log_size, 0, 1024 * 1024 * 1024),
 	CONF_INT("log-num", &dns_conf_log_num, 0, 1024),
 	CONF_YESNO("audit-enable", &dns_conf_audit_enable),
+	CONF_YESNO("audit-SOA", &dns_conf_audit_log_SOA),
 	CONF_STRING("audit-file", (char *)&dns_conf_audit_file, DNS_MAX_PATH),
 	CONF_SIZE("audit-size", &dns_conf_audit_size, 0, 1024 * 1024 * 1024),
 	CONF_INT("audit-num", &dns_conf_audit_num, 0, 1024),
@@ -1022,9 +1365,11 @@ static struct config_item _config_item[] = {
 	CONF_INT("rr-ttl-max", &dns_conf_rr_ttl_max, 0, CONF_INT_MAX),
 	CONF_YESNO("force-AAAA-SOA", &dns_conf_force_AAAA_SOA),
 	CONF_CUSTOM("blacklist-ip", _config_blacklist_ip, NULL),
+	CONF_CUSTOM("whitelist-ip", _conf_whitelist_ip, NULL),
 	CONF_CUSTOM("bogus-nxdomain", _conf_bogus_nxdomain, NULL),
 	CONF_CUSTOM("ignore-ip", _conf_ip_ignore, NULL),
 	CONF_CUSTOM("edns-client-subnet", _conf_edns_client_subnet, NULL),
+	CONF_CUSTOM("domain-rules", _conf_domain_rules, NULL),
 	CONF_CUSTOM("conf-file", config_addtional_file, NULL),
 	CONF_END(),
 };
@@ -1051,11 +1396,13 @@ int config_addtional_file(void *data, int argc, char *argv[])
 	char file_path_dir[DNS_MAX_PATH];

 	if (conf_file[0] != '/') {
-		strncpy(file_path_dir, conf_get_conf_file(), DNS_MAX_PATH);
+		safe_strncpy(file_path_dir, conf_get_conf_file(), DNS_MAX_PATH);
 		dirname(file_path_dir);
-		snprintf(file_path, DNS_MAX_PATH, "%s/%s", file_path_dir, conf_file);
+		if (snprintf(file_path, DNS_MAX_PATH, "%s/%s", file_path_dir, conf_file) < 0) {
+			return -1;
+		}
 	} else {
-		strncpy(file_path, conf_file, DNS_MAX_PATH);
+		safe_strncpy(file_path, conf_file, DNS_MAX_PATH);
 	}

 	if (access(file_path, R_OK) != 0) {
@@ -1093,6 +1440,40 @@ void dns_server_load_exit(void)
 	_config_group_table_destroy();
 }

+static int _dns_conf_speed_check_mode_verify(void)
+{
+	int i, j;
+	int has_cap = has_network_raw_cap();
+	int print_log = 0;
+
+	dns_has_cap_ping = has_cap;
+	if (has_cap == 1) {
+		return 0;
+	}
+
+	for (i = 0; i < DOMAIN_CHECK_NUM; i++) {
+		if (dns_conf_check_order.order[i] == DOMAIN_CHECK_ICMP) {
+			for (j = i + 1; j < DOMAIN_CHECK_NUM; j++) {
+				dns_conf_check_order.order[j - 1] = dns_conf_check_order.order[j];
+			}
+			dns_conf_check_order.order[j - 1] = DOMAIN_CHECK_NONE;
+			print_log = 1;
+		}
+	}
+
+	if (print_log) {
+		tlog(TLOG_WARN, "speed check by ping is disabled because smartdns does not have network raw privileges");
+	}
+
+	return 0;
+}
+
+static int _dns_conf_load_post(void)
+{
+	_dns_conf_speed_check_mode_verify();
+	return 0;
+}
+
 int dns_server_load_conf(const char *file)
 {
 	int ret = 0;
@@ -1100,5 +1481,6 @@ int dns_server_load_conf(const char *file)
 	openlog("smartdns", LOG_CONS | LOG_NDELAY, LOG_LOCAL1);
 	ret = load_conf(file, _config_item, _conf_printf);
 	closelog();
+	_dns_conf_load_post();
 	return ret;
 }
--- a/src/dns_conf.h
+++ b/src/dns_conf.h
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef _DNS_CONF
 #define _DNS_CONF

@@ -10,6 +28,11 @@
 #include "list.h"
 #include "radix.h"

+#ifdef __cpluscplus
+extern "C" {
+#endif
+
+#define DNS_MAX_BIND_IP 16
 #define DNS_MAX_SERVERS 64
 #define DNS_MAX_SERVER_NAME_LEN 128
 #define DNS_MAX_IPSET_NAMELEN 32
@@ -33,9 +56,21 @@ enum domain_rule {
 	DOMAIN_RULE_ADDRESS_IPV6,
 	DOMAIN_RULE_IPSET,
 	DOMAIN_RULE_NAMESERVER,
+	DOMAIN_RULE_CHECKSPEED,
 	DOMAIN_RULE_MAX,
 };

+typedef enum {
+	DNS_BIND_TYPE_UDP,
+	DNS_BIND_TYPE_TCP,
+	DNS_BIND_TYPE_TLS,
+} DNS_BIND_TYPE;
+
+#define DOMAIN_CHECK_NONE 0
+#define DOMAIN_CHECK_ICMP 1
+#define DOMAIN_CHECK_TCP 2
+#define DOMAIN_CHECK_NUM 2
+
 #define DOMAIN_FLAG_ADDR_SOA (1 << 0)
 #define DOMAIN_FLAG_ADDR_IPV4_SOA (1 << 1)
 #define DOMAIN_FLAG_ADDR_IPV6_SOA (1 << 2)
@@ -47,6 +82,16 @@ enum domain_rule {

 #define SERVER_FLAG_EXCLUDE_DEFAULT (1 << 0)

+#define BIND_FLAG_NO_RULE_ADDR (1 << 0)
+#define BIND_FLAG_NO_RULE_NAMESERVER (1 << 1)
+#define BIND_FLAG_NO_RULE_IPSET (1 << 2)
+#define BIND_FLAG_NO_RULE_SNIPROXY (1 << 3)
+#define BIND_FLAG_NO_RULE_SOA (1 << 4)
+#define BIND_FLAG_NO_SPEED_CHECK (1 << 5)
+#define BIND_FLAG_NO_CACHE (1 << 6)
+#define BIND_FLAG_NO_DUALSTACK_SELECTION (1 << 7)
+#define BIND_FLAG_FORCE_AAAA_SOA (1 << 8) 
+
 struct dns_rule_flags {
 	unsigned int flags;
 };
@@ -83,6 +128,11 @@ struct dns_server_groups {
 	struct dns_servers *servers[DNS_MAX_SERVERS];
 };

+struct dns_domain_check_order {
+	char order[DOMAIN_CHECK_NUM];
+	unsigned short tcp_port;
+};
+
 struct dns_group_table {
 	DECLARE_HASHTABLE(group, 8);
 };
@@ -98,6 +148,7 @@ struct dns_servers {
 	char spki[DNS_MAX_SPKI_LEN];
 	char hostname[DNS_MAX_CNAME_LEN];
 	char httphost[DNS_MAX_CNAME_LEN];
+	char tls_host_verify[DNS_MAX_CNAME_LEN];
 	char path[DNS_MAX_URL_LEN];
 };

@@ -114,12 +165,14 @@ struct dns_bogus_ip_address {

 enum address_rule {
 	ADDRESS_RULE_BLACKLIST = 1,
-	ADDRESS_RULE_BOGUS = 2,
-	ADDRESS_RULE_IP_IGNORE = 3,
+	ADDRESS_RULE_WHITELIST = 2,
+	ADDRESS_RULE_BOGUS = 3,
+	ADDRESS_RULE_IP_IGNORE = 4,
 };

 struct dns_ip_address_rule {
 	unsigned int blacklist : 1;
+	unsigned int whitelist : 1;
 	unsigned int bogus : 1;
 	unsigned int ip_ignore : 1;
 };
@@ -135,12 +188,21 @@ struct dns_conf_address_rule {
 	radix_tree_t *ipv6;
 };

-extern char dns_conf_server_ip[DNS_MAX_IPLEN];
-extern char dns_conf_server_tcp_ip[DNS_MAX_IPLEN];
+struct dns_bind_ip {
+	DNS_BIND_TYPE type;
+	uint32_t flags;
+	char ip[DNS_MAX_IPLEN];
+	const char *group;
+};
+
+extern struct dns_bind_ip dns_conf_bind_ip[DNS_MAX_BIND_IP];
+extern int dns_conf_bind_ip_num;

 extern int dns_conf_tcp_idle_time;
 extern int dns_conf_cachesize;
 extern int dns_conf_prefetch;
+extern int dns_conf_serve_expired;
+extern int dns_conf_serve_expired_ttl;
 extern struct dns_servers dns_conf_servers[DNS_MAX_SERVERS];
 extern int dns_conf_server_num;

@@ -149,10 +211,13 @@ extern char dns_conf_log_file[DNS_MAX_PATH];
 extern size_t dns_conf_log_size;
 extern int dns_conf_log_num;

+extern struct dns_domain_check_order dns_conf_check_order;
+
 extern struct dns_server_groups dns_conf_server_groups[DNS_NAX_GROUP_NUMBER];
 extern int dns_conf_server_group_num;

 extern int dns_conf_audit_enable;
+extern int dns_conf_audit_log_SOA;
 extern char dns_conf_audit_file[DNS_MAX_PATH];
 extern size_t dns_conf_audit_size;
 extern int dns_conf_audit_num;
@@ -180,5 +245,7 @@ void dns_server_load_exit(void);
 int dns_server_load_conf(const char *file);

 extern int config_addtional_file(void *data, int argc, char *argv[]);
-
+#ifdef __cpluscplus
+}
+#endif
 #endif // !_DNS_CONF
--- a/src/dns_server.c
+++ b/src/dns_server.c
--- a/src/dns_server.h
+++ b/src/dns_server.h
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef _SMART_DNS_SERVER_H
 #define _SMART_DNS_SERVER_H

--- a/src/fast_ping.c
+++ b/src/fast_ping.c
@@ -1,6 +1,6 @@
 /*************************************************************************
 *
- * Copyright (C) 2018 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
 *
 * smartdns is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -30,6 +30,7 @@
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
 #include <netinet/ip_icmp.h>
+#include <netinet/tcp.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -43,6 +44,9 @@
 #define PING_MAX_HOSTLEN 128
 #define ICMP_PACKET_SIZE (1024 * 64)
 #define ICMP_INPACKET_SIZE 1024
+#define IPV4_ADDR_LEN 4
+#define IPV6_ADDR_LEN 16
+#define SOCKET_PRIORITY (6)

 #ifndef ICMP_FILTER
 #define ICMP_FILTER 1
@@ -215,17 +219,91 @@ static void _fast_ping_install_filter_v4(int sock)
 	}
 }

+static int _fast_ping_sockaddr_ip_cmp(struct sockaddr *first_addr, socklen_t first_addr_len, struct sockaddr *second_addr, socklen_t second_addr_len)
+{
+	if (first_addr_len != second_addr_len) {
+		return -1;
+	}
+
+	if (first_addr->sa_family != second_addr->sa_family) {
+		return -1;
+	}
+
+	switch (first_addr->sa_family) {
+	case AF_INET: {
+		struct sockaddr_in *first_addr_in = (struct sockaddr_in *)first_addr;
+		struct sockaddr_in *second_addr_in = (struct sockaddr_in *)second_addr;
+		if (memcmp(&first_addr_in->sin_addr.s_addr, &second_addr_in->sin_addr.s_addr, IPV4_ADDR_LEN) != 0) {
+			return -1;
+		}
+	} break;
+	case AF_INET6: {
+		struct sockaddr_in6 *first_addr_in6 = (struct sockaddr_in6 *)first_addr;
+		struct sockaddr_in6 *second_addr_in6 = (struct sockaddr_in6 *)second_addr;
+		if (memcmp(&first_addr_in6->sin6_addr.s6_addr, &second_addr_in6->sin6_addr.s6_addr, IPV4_ADDR_LEN) != 0) {
+			return -1;
+		}
+	} break;
+	default:
+		return -1;
+	}
+
+	return 0;
+}
+
+static uint32_t _fast_ping_hash_key(unsigned int sid, struct sockaddr *addr)
+{
+	uint32_t key = 0;
+	void *sin_addr = NULL;
+	unsigned int sin_addr_len = 0;
+
+	switch (addr->sa_family) {
+	case AF_INET: {
+		struct sockaddr_in *addr_in;
+		addr_in = (struct sockaddr_in *)addr;
+		sin_addr = &addr_in->sin_addr.s_addr;
+		sin_addr_len = IPV4_ADDR_LEN;
+	} break;
+	case AF_INET6: {
+		struct sockaddr_in6 *addr_in6;
+		addr_in6 = (struct sockaddr_in6 *)addr;
+		if (IN6_IS_ADDR_V4MAPPED(&addr_in6->sin6_addr)) {
+			sin_addr = addr_in6->sin6_addr.s6_addr + 12;
+			sin_addr_len = IPV4_ADDR_LEN;
+		} else {
+			sin_addr = addr_in6->sin6_addr.s6_addr;
+			sin_addr_len = IPV6_ADDR_LEN;
+		}
+	} break;
+	default:
+		goto errout;
+		break;
+	}
+	if (sin_addr == NULL) {
+		return -1;
+	}
+
+	key = jhash(sin_addr, sin_addr_len, 0);
+	key = jhash(&sid, sizeof(sid), key);
+
+	return key;
+errout:
+	return -1;
+}
+
 static struct addrinfo *_fast_ping_getaddr(const char *host, const char *port, int type, int protocol)
 {
 	struct addrinfo hints;
 	struct addrinfo *result = NULL;
+	int errcode = 0;

 	memset(&hints, 0, sizeof(hints));
 	hints.ai_family = AF_UNSPEC;
 	hints.ai_socktype = type;
 	hints.ai_protocol = protocol;
-	if (getaddrinfo(host, port, &hints, &result) != 0) {
-		tlog(TLOG_ERROR, "get addr info failed. %s\n", strerror(errno));
+	errcode = getaddrinfo(host, port, &hints, &result);
+	if (errcode != 0) {
+		tlog(TLOG_ERROR, "get addr info failed. host:%s, port: %s, error %s\n", host, port, gai_strerror(errcode));
 		goto errout;
 	}

@@ -473,6 +551,9 @@ static int _fast_ping_sendping_tcp(struct ping_host_struct *ping_host)
 	struct epoll_event event;
 	int flags;
 	int fd = -1;
+	int yes = 1;
+	const int priority = SOCKET_PRIORITY;
+	const int ip_tos = IP_TOS;

 	_fast_ping_close_host_sock(ping_host);

@@ -483,6 +564,9 @@ static int _fast_ping_sendping_tcp(struct ping_host_struct *ping_host)

 	flags = fcntl(fd, F_GETFL, 0);
 	fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+	setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes));
+	setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &priority, sizeof(priority));
+	setsockopt(fd, IPPROTO_IP, IP_TOS, &ip_tos, sizeof(ip_tos));

 	ping_host->seq++;
 	if (connect(fd, (struct sockaddr *)&ping_host->addr, ping_host->addr_len) != 0) {
@@ -558,6 +642,7 @@ static int _fast_ping_create_icmp_sock(FAST_PING_TYPE type)
 	socklen_t optlen = sizeof(buffsize);
 	const int val = 255;
 	const int on = 1;
+	const int ip_tos = (IPTOS_LOWDELAY | IPTOS_RELIABILITY);

 	switch (type) {
 	case FAST_PING_ICMP:
@@ -592,6 +677,7 @@ static int _fast_ping_create_icmp_sock(FAST_PING_TYPE type)
 	setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const char *)&buffsize, optlen);
 	setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (const char *)&buffsize, optlen);
 	setsockopt(fd, SOL_IP, IP_TTL, &val, sizeof(val));
+	setsockopt(fd, IPPROTO_IP, IP_TOS, &ip_tos, sizeof(ip_tos));

 	memset(&event, 0, sizeof(event));
 	event.events = EPOLLIN;
@@ -655,6 +741,7 @@ static int _fast_ping_create_udp_sock(FAST_PING_TYPE type)
 	struct epoll_event event;
 	const int val = 255;
 	const int on = 1;
+	const int ip_tos = (IPTOS_LOWDELAY | IPTOS_RELIABILITY);

 	switch (type) {
 	case FAST_PING_UDP:
@@ -686,6 +773,7 @@ static int _fast_ping_create_udp_sock(FAST_PING_TYPE type)

 	setsockopt(fd, SOL_IP, IP_TTL, &val, sizeof(val));
 	setsockopt(fd, IPPROTO_IP, IP_RECVTTL, &on, sizeof(on));
+	setsockopt(fd, IPPROTO_IP, IP_TOS, &ip_tos, sizeof(ip_tos));

 	memset(&event, 0, sizeof(event));
 	event.events = EPOLLIN;
@@ -741,8 +829,8 @@ errout:
 	return -1;
 }

-static void _fast_ping_print_result(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result, struct sockaddr *addr, socklen_t addr_len, int seqno,
-							int ttl, struct timeval *tv, void *userptr)
+static void _fast_ping_print_result(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result, struct sockaddr *addr, socklen_t addr_len,
+									int seqno, int ttl, struct timeval *tv, void *userptr)
 {
 	if (result == PING_RESULT_RESPONSE) {
 		double rtt = tv->tv_sec * 1000.0 + tv->tv_usec / 1000.0;
@@ -754,111 +842,184 @@ static void _fast_ping_print_result(struct ping_host_struct *ping_host, const ch
 	}
 }

+static int _fast_ping_get_addr_by_icmp(const char *ip_str, int port, struct addrinfo **out_gai, FAST_PING_TYPE *out_ping_type)
+{
+	struct addrinfo *gai = NULL;
+	int socktype = 0;
+	int domain = -1;
+	FAST_PING_TYPE ping_type;
+	int sockproto = 0;
+	char *service = NULL;
+
+	socktype = SOCK_RAW;
+	domain = _fast_ping_getdomain(ip_str);
+	if (domain < 0) {
+		goto errout;
+	}
+
+	switch (domain) {
+	case AF_INET:
+		sockproto = IPPROTO_ICMP;
+		ping_type = FAST_PING_ICMP;
+		break;
+	case AF_INET6:
+		sockproto = IPPROTO_ICMPV6;
+		ping_type = FAST_PING_ICMP6;
+		break;
+	default:
+		goto errout;
+		break;
+	}
+
+	if (_fast_ping_create_icmp(ping_type) < 0) {
+		goto errout;
+	}
+
+	gai = _fast_ping_getaddr(ip_str, service, socktype, sockproto);
+	if (gai == NULL) {
+		goto errout;
+	}
+
+	*out_gai = gai;
+	*out_ping_type = ping_type;
+
+	return 0;
+errout:
+	if (gai) {
+		freeaddrinfo(gai);
+	}
+	return -1;
+}
+
+static int _fast_ping_get_addr_by_tcp(const char *ip_str, int port, struct addrinfo **out_gai, FAST_PING_TYPE *out_ping_type)
+{
+	struct addrinfo *gai = NULL;
+	int socktype = 0;
+	FAST_PING_TYPE ping_type;
+	int sockproto = 0;
+	char *service = NULL;
+	char port_str[MAX_IP_LEN];
+
+	if (port <= 0) {
+		port = 80;
+	}
+
+	sockproto = 0;
+	socktype = SOCK_STREAM;
+	snprintf(port_str, MAX_IP_LEN, "%d", port);
+	service = port_str;
+	ping_type = FAST_PING_TCP;
+
+	gai = _fast_ping_getaddr(ip_str, service, socktype, sockproto);
+	if (gai == NULL) {
+		goto errout;
+	}
+
+	*out_gai = gai;
+	*out_ping_type = ping_type;
+
+	return 0;
+errout:
+	if (gai) {
+		freeaddrinfo(gai);
+	}
+	return -1;
+}
+
+static int _fast_ping_get_addr_by_dns(const char *ip_str, int port, struct addrinfo **out_gai, FAST_PING_TYPE *out_ping_type)
+{
+	struct addrinfo *gai = NULL;
+	int socktype = 0;
+	FAST_PING_TYPE ping_type;
+	int sockproto = 0;
+	char port_str[MAX_IP_LEN];
+	int domain = -1;
+	char *service = NULL;
+
+	if (port <= 0) {
+		port = 53;
+	}
+
+	domain = _fast_ping_getdomain(ip_str);
+	if (domain < 0) {
+		goto errout;
+	}
+
+	switch (domain) {
+	case AF_INET:
+		ping_type = FAST_PING_UDP;
+		break;
+	case AF_INET6:
+		ping_type = FAST_PING_UDP6;
+		break;
+	default:
+		goto errout;
+		break;
+	}
+
+	sockproto = 0;
+	socktype = SOCK_DGRAM;
+	snprintf(port_str, MAX_IP_LEN, "%d", port);
+	service = port_str;
+
+	if (_fast_ping_create_udp(ping_type) < 0) {
+		goto errout;
+	}
+
+	gai = _fast_ping_getaddr(ip_str, service, socktype, sockproto);
+	if (gai == NULL) {
+		goto errout;
+	}
+
+	*out_gai = gai;
+	*out_ping_type = ping_type;
+
+	return 0;
+errout:
+	if (gai) {
+		freeaddrinfo(gai);
+	}
+	return -1;
+}
+
+static int _fast_ping_get_addr_by_type(PING_TYPE type, const char *ip_str, int port, struct addrinfo **out_gai, FAST_PING_TYPE *out_ping_type)
+{
+	switch (type) {
+	case PING_TYPE_ICMP:
+		return _fast_ping_get_addr_by_icmp(ip_str, port, out_gai, out_ping_type);
+		break;
+	case PING_TYPE_TCP:
+		return _fast_ping_get_addr_by_tcp(ip_str, port, out_gai, out_ping_type);
+		break;
+	case PING_TYPE_DNS:
+		return _fast_ping_get_addr_by_dns(ip_str, port, out_gai, out_ping_type);
+		break;
+	default:
+		break;
+	}
+
+	return -1;
+}
+
 struct ping_host_struct *fast_ping_start(PING_TYPE type, const char *host, int count, int interval, int timeout, fast_ping_result ping_callback, void *userptr)
 {
 	struct ping_host_struct *ping_host = NULL;
 	struct addrinfo *gai = NULL;
-	int domain = -1;
-	int icmp_proto = 0;
 	uint32_t addrkey;
 	char ip_str[PING_MAX_HOSTLEN];
-	char port_str[MAX_IP_LEN];
-	char *service = NULL;
 	int port = -1;
 	FAST_PING_TYPE ping_type;
-	int socktype = 0;
 	unsigned int seed;
+	int ret = 0;

 	if (parse_ip(host, ip_str, &port) != 0) {
 		goto errout;
 	}

-	switch (type) {
-	case PING_TYPE_ICMP: {
-		socktype = SOCK_RAW;
-		domain = _fast_ping_getdomain(ip_str);
-		if (domain < 0) {
-			return NULL;
-		}
-
-		switch (domain) {
-		case AF_INET:
-			icmp_proto = IPPROTO_ICMP;
-			ping_type = FAST_PING_ICMP;
-			break;
-		case AF_INET6:
-			icmp_proto = IPPROTO_ICMPV6;
-			ping_type = FAST_PING_ICMP6;
-			break;
-		default:
-			return NULL;
-			break;
-		}
-
-		if (_fast_ping_create_icmp(ping_type) < 0) {
-			goto errout;
-		}
-
-		gai = _fast_ping_getaddr(ip_str, service, socktype, icmp_proto);
-		if (gai == NULL) {
-			goto errout;
-		}
-	} break;
-	case PING_TYPE_TCP: {
-		if (port <= 0) {
-			port = 80;
-		}
-
-		icmp_proto = 0;
-		socktype = SOCK_STREAM;
-		snprintf(port_str, MAX_IP_LEN, "%d", port);
-		service = port_str;
-		ping_type = FAST_PING_TCP;
-
-		gai = _fast_ping_getaddr(ip_str, service, socktype, icmp_proto);
-		if (gai == NULL) {
-			goto errout;
-		}
-	} break;
-	case PING_TYPE_DNS: {
-		if (port <= 0) {
-			port = 53;
-		}
-
-		domain = _fast_ping_getdomain(ip_str);
-		if (domain < 0) {
-			return NULL;
-		}
-
-		switch (domain) {
-		case AF_INET:
-			ping_type = FAST_PING_UDP;
-			break;
-		case AF_INET6:
-			ping_type = FAST_PING_UDP6;
-			break;
-		default:
-			return NULL;
-			break;
-		}
-
-		icmp_proto = 0;
-		socktype = SOCK_DGRAM;
-		snprintf(port_str, MAX_IP_LEN, "%d", port);
-		service = port_str;
-
-		if (_fast_ping_create_udp(ping_type) < 0) {
-			goto errout;
-		}
-
-		gai = _fast_ping_getaddr(ip_str, service, socktype, icmp_proto);
-		if (gai == NULL) {
-			goto errout;
-		}
-	} break;
-	default:
+	ret = _fast_ping_get_addr_by_type(type, ip_str, port, &gai, &ping_type);
+	if (ret != 0) {
+		tlog(TLOG_ERROR, "get addr by type failed, host: %s", host);
 		goto errout;
-		break;
 	}

 	ping_host = malloc(sizeof(*ping_host));
@@ -867,7 +1028,7 @@ struct ping_host_struct *fast_ping_start(PING_TYPE type, const char *host, int c
 	}

 	memset(ping_host, 0, sizeof(*ping_host));
-	strncpy(ping_host->host, host, PING_MAX_HOSTLEN);
+	safe_strncpy(ping_host->host, host, PING_MAX_HOSTLEN);
 	ping_host->fd = -1;
 	ping_host->timeout = timeout;
 	ping_host->count = count;
@@ -892,26 +1053,26 @@ struct ping_host_struct *fast_ping_start(PING_TYPE type, const char *host, int c
 		goto errout;
 	}
 	memcpy(&ping_host->addr, gai->ai_addr, gai->ai_addrlen);
-	freeaddrinfo(gai);

 	tlog(TLOG_DEBUG, "ping %s, id = %d", host, ping_host->sid);

-	addrkey = jhash(&ping_host->addr, ping_host->addr_len, 0);
-	addrkey = jhash(&ping_host->sid, sizeof(ping_host->sid), addrkey);
+	addrkey = _fast_ping_hash_key(ping_host->sid, &ping_host->addr);
 	pthread_mutex_lock(&ping.map_lock);
 	_fast_ping_host_get(ping_host);
 	hash_add(ping.addrmap, &ping_host->addr_node, addrkey);
 	pthread_mutex_unlock(&ping.map_lock);

-	_fast_ping_host_get(ping_host);
 	_fast_ping_host_get(ping_host);
 	if (_fast_ping_sendping(ping_host) != 0) {
 		goto errout_remove;
 	}

 	ping_host->run = 1;
-	_fast_ping_host_put(ping_host);
+	freeaddrinfo(gai);
 	return ping_host;
+errout_remove:
+	fast_ping_stop(ping_host);
+	ping_host = NULL;
 errout:
 	if (gai) {
 		freeaddrinfo(gai);
@@ -921,10 +1082,6 @@ errout:
 		free(ping_host);
 	}

-	return NULL;
-errout_remove:
-	fast_ping_stop(ping_host);
-	_fast_ping_host_put(ping_host);
 	return NULL;
 }

@@ -1028,7 +1185,8 @@ static struct fast_ping_packet *_fast_ping_icmp_packet(struct ping_host_struct *
 	return packet;
 }

-static struct fast_ping_packet *_fast_ping_recv_packet(struct ping_host_struct *ping_host, struct msghdr *msg, u_char *inpacket, int len, struct timeval *tvrecv)
+static struct fast_ping_packet *_fast_ping_recv_packet(struct ping_host_struct *ping_host, struct msghdr *msg, u_char *inpacket, int len,
+													   struct timeval *tvrecv)
 {
 	struct fast_ping_packet *packet = NULL;

@@ -1094,17 +1252,16 @@ static int _fast_ping_process_icmp(struct ping_host_struct *ping_host, struct ti
 		goto errout;
 	}

-	addrkey = jhash(&from, from_len, 0);
 	tvsend = &packet->msg.tv;
 	sid = packet->msg.sid;
 	seq = packet->msg.seq;
 	cookie = packet->msg.cookie;
-	addrkey = jhash(&sid, sizeof(sid), addrkey);
+	addrkey = _fast_ping_hash_key(sid, (struct sockaddr *)&from);
 	pthread_mutex_lock(&ping.map_lock);
 	hash_for_each_possible(ping.addrmap, recv_ping_host, addr_node, addrkey)
 	{
-		if (recv_ping_host->addr_len == from_len && memcmp(&recv_ping_host->addr, &from, from_len) == 0 && recv_ping_host->sid == sid &&
-			recv_ping_host->cookie == cookie) {
+		if (_fast_ping_sockaddr_ip_cmp(&recv_ping_host->addr, recv_ping_host->addr_len, (struct sockaddr *)&from, from_len) == 0 &&
+			recv_ping_host->sid == sid && recv_ping_host->cookie == cookie) {
 			_fast_ping_host_get(recv_ping_host);
 			break;
 		}
@@ -1117,8 +1274,8 @@ static int _fast_ping_process_icmp(struct ping_host_struct *ping_host, struct ti
 	}

 	if (recv_ping_host->seq != seq) {
-		_fast_ping_host_put(recv_ping_host);
 		tlog(TLOG_ERROR, "seq num mismatch, expect %u, real %u", recv_ping_host->seq, seq);
+		_fast_ping_host_put(recv_ping_host);
 		return -1;
 	}

@@ -1230,13 +1387,14 @@ static int _fast_ping_process_udp(struct ping_host_struct *ping_host, struct tim
 	if (len < sizeof(*dns_head)) {
 		goto errout;
 	}
-	addrkey = jhash(&from, from_len, 0);
+
 	sid = ntohs(dns_head->id);
-	addrkey = jhash(&sid, sizeof(sid), addrkey);
+	addrkey = _fast_ping_hash_key(sid, (struct sockaddr *)&from);
 	pthread_mutex_lock(&ping.map_lock);
 	hash_for_each_possible(ping.addrmap, recv_ping_host, addr_node, addrkey)
 	{
-		if (recv_ping_host->addr_len == from_len && memcmp(&recv_ping_host->addr, &from, from_len) == 0 && recv_ping_host->sid == sid) {
+		if (_fast_ping_sockaddr_ip_cmp(&recv_ping_host->addr, recv_ping_host->addr_len, (struct sockaddr *)&from, from_len) == 0 &&
+			recv_ping_host->sid == sid) {
 			_fast_ping_host_get(recv_ping_host);
 			break;
 		}
@@ -1323,9 +1481,10 @@ static void _fast_ping_period_run(void)
 	struct hlist_node *tmp = NULL;
 	int i = 0;
 	struct timeval now;
+	struct timezone tz;
 	struct timeval interval;
 	int64_t millisecond;
-	gettimeofday(&now, NULL);
+	gettimeofday(&now, &tz);
 	LIST_HEAD(action);

 	pthread_mutex_lock(&ping.map_lock);
@@ -1486,14 +1645,8 @@ errout:
 	return -1;
 }

-void fast_ping_exit(void)
+static void _fast_ping_close_fds(void)
 {
-	if (ping.tid > 0) {
-		void *ret = NULL;
-		ping.run = 0;
-		pthread_join(ping.tid, &ret);
-	}
-
 	if (ping.fd_icmp > 0) {
 		close(ping.fd_icmp);
 		ping.fd_icmp = -1;
@@ -1504,6 +1657,26 @@ void fast_ping_exit(void)
 		ping.fd_icmp6 = -1;
 	}

+	if (ping.fd_udp > 0) {
+		close(ping.fd_udp);
+		ping.fd_udp = -1;
+	}
+
+	if (ping.fd_udp6 > 0) {
+		close(ping.fd_udp6);
+		ping.fd_udp6 = -1;
+	}
+}
+
+void fast_ping_exit(void)
+{
+	if (ping.tid > 0) {
+		void *ret = NULL;
+		ping.run = 0;
+		pthread_join(ping.tid, &ret);
+	}
+
+	_fast_ping_close_fds();
 	_fast_ping_remove_all();

 	pthread_mutex_destroy(&ping.lock);
--- a/src/fast_ping.h
+++ b/src/fast_ping.h
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef FAST_PING_H
 #define FAST_PING_H

--- a/src/http_parse.c
+++ b/src/http_parse.c
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "http_parse.h"
 #include "hash.h"
 #include "hashtable.h"
@@ -232,7 +250,7 @@ static int _http_head_parse_response(struct http_head *http_head, char *key, cha
 	http_head->code = atol(ret_code);
 	http_head->code_msg = result;
 	http_head->version = key;
-    http_head->head_type = HTTP_HEAD_RESPONSE;
+	http_head->head_type = HTTP_HEAD_RESPONSE;

 	return 0;
 }
--- a/src/http_parse.h
+++ b/src/http_parse.h
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef HTTP_PARSER_H
 #define HTTP_PARSER_H

--- a/src/include/art.h
+++ b/src/include/art.h
@@ -195,6 +195,17 @@ void* art_search(const art_tree *t, const unsigned char *key, int key_len);
 */
 void *art_substring(const art_tree *t, const unsigned char *str, int str_len, unsigned char *key, int *key_len);

+/**
+ * Wakk substring for a value in the ART tree
+ * @arg t The tree
+ * @arg str The key
+ * @arg str_len The length of the key
+ * @return NULL if the item was not found, otherwise
+ * the value pointer is returned.
+ */
+typedef int (*walk_func)(unsigned char *key, uint32_t key_len, void *value, void *arg);
+void art_substring_walk(const art_tree *t, const unsigned char *str, int str_len, walk_func func, void *arg);
+
 /**
 * Returns the minimum valued leaf
 * @return The minimum leaf or NULL
--- a/src/include/atomic.h
+++ b/src/include/atomic.h
@@ -1,3 +1,22 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
 #ifndef _GENERIC_ATOMIC_H
 #define _GENERIC_ATOMIC_H

--- a/src/include/bitmap.h
+++ b/src/include/bitmap.h
@@ -1,3 +1,22 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
 #ifndef _PERF_BITOPS_H
 #define _PERF_BITOPS_H

--- a/src/include/bitops.h
+++ b/src/include/bitops.h
@@ -1,3 +1,22 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
 #ifndef _GENERIC_BITOPS_H_
 #define _GENERIC_BITOPS_H_

--- a/src/include/conf.h
+++ b/src/include/conf.h
@@ -1,3 +1,22 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
 #ifndef _GENERIC_CONF_H
 #define _GENERIC_CONF_H

--- a/src/include/findbit.h
+++ b/src/include/findbit.h
@@ -1,5 +1,24 @@
-#ifndef _TOOLS_LINUX_ASM_GENERIC_BITOPS_FIND_H_
-#define _TOOLS_LINUX_ASM_GENERIC_BITOPS_FIND_H_
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _TOOLS_GENERIC_BITOPS_FIND_H_
+#define _TOOLS_GENERIC_BITOPS_FIND_H_

 #ifndef find_next_bit
 /**
@@ -74,4 +93,4 @@ extern unsigned long find_first_bit(const unsigned long *addr,
 unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size);
 #endif

-#endif /*_TOOLS_LINUX_ASM_GENERIC_BITOPS_FIND_H_ */
+#endif /*_TOOLS_GENERIC_BITOPS_FIND_H_ */
--- a/src/include/gcc_builtin.h
+++ b/src/include/gcc_builtin.h
@@ -1,3 +1,22 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
 #ifndef _TOOLS_LINUX_COMPILER_H_
 #define _TOOLS_LINUX_COMPILER_H_

--- a/src/include/hash.h
+++ b/src/include/hash.h
@@ -1,3 +1,22 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
 #ifndef _GENERIC_HASH_H
 #define _GENERIC_HASH_H

--- a/src/include/hashtable.h
+++ b/src/include/hashtable.h
@@ -1,6 +1,19 @@
-/*
- * Statically sized hash table implementation
- * (C) 2012  Sasha Levin <levinsasha928@gmail.com>
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef _GENERIC_HASHTABLE_H
--- a/src/include/jhash.h
+++ b/src/include/jhash.h
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef _JHASH_H
 #define _JHASH_H

--- a/src/include/list.h
+++ b/src/include/list.h
@@ -1,3 +1,20 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */

 #ifndef _GENERIC_LIST_H
 #define _GENERIC_LIST_H
--- a/src/include/rbtree.h
+++ b/src/include/rbtree.h
@@ -1,3 +1,20 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */

 #ifndef _GENERIC_RBTREE_H
 #define _GENERIC_RBTREE_H
--- a/src/include/stringutil.h
+++ b/src/include/stringutil.h
@@ -0,0 +1,42 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _GENERIC_STRING_UITL_H
+#define _GENERIC_STRING_UITL_H
+
+#include <stddef.h>
+#include <string.h>
+
+static inline char *safe_strncpy(char *dest, const char *src, size_t n) 
+{
+#if __GNUC__  > 7
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-truncation"
+#endif
+	char *ret = strncpy(dest, src, n - 1);
+    if (n > 0) {
+	    dest[n - 1] = '\0';
+    }
+#if __GNUC__  > 7
+#pragma GCC diagnostic pop
+#endif
+	return ret;
+}
+
+
+#endif
--- a/src/lib/art.c
+++ b/src/lib/art.c
@@ -52,23 +52,28 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 static art_node* alloc_node(uint8_t type) {
    art_node* n;
-    switch (type) {
+	void *mem = NULL;
+	switch (type) {
        case NODE4:
-            n = (art_node*)calloc(1, sizeof(art_node4));
+            mem = (art_node*)calloc(1, sizeof(art_node4));
            break;
        case NODE16:
-            n = (art_node*)calloc(1, sizeof(art_node16));
+            mem = (art_node*)calloc(1, sizeof(art_node16));
            break;
        case NODE48:
-            n = (art_node*)calloc(1, sizeof(art_node48));
+            mem = (art_node*)calloc(1, sizeof(art_node48));
            break;
        case NODE256:
-            n = (art_node*)calloc(1, sizeof(art_node256));
+            mem = (art_node*)calloc(1, sizeof(art_node256));
            break;
        default:
            abort();
    }
-    n->type = type;
+    if (mem == NULL) {
+		abort();
+	}
+	n = mem;
+	n->type = type;
    return n;
 }

@@ -385,6 +390,10 @@ art_leaf* art_maximum(art_tree *t) {

 static art_leaf* make_leaf(const unsigned char *key, int key_len, void *value) {
    art_leaf *l = (art_leaf*)calloc(1, sizeof(art_leaf)+key_len+1);
+    if (l == NULL) {
+		return NULL;
+	}
+    
    l->value = value;
    l->key_len = key_len;
    memcpy(l->key, key, key_len);
@@ -1064,3 +1073,57 @@ void *art_substring(const art_tree *t, const unsigned char *str, int str_len, un

    return found->value;
 }
+
+void art_substring_walk(const art_tree *t, const unsigned char *str, int str_len, walk_func func, void *arg)
+{
+    art_node **child;
+    art_node *n = t->root;
+    art_node *m;    
+    art_leaf *found = NULL;
+    int prefix_len, depth = 0;
+	int stop_search = 0;
+
+	while (n && stop_search == 0) {
+        // Might be a leaf
+        if (IS_LEAF(n)) {
+            n = (art_node*)LEAF_RAW(n);
+            // Check if the expanded path matches
+            if (!str_prefix_matches((art_leaf*)n, str, str_len)) {
+                found = (art_leaf*)n;
+				stop_search = func(found->key, found->key_len, found->value, arg);
+			}
+            break;
+        }
+
+        // Check if current is leaf
+    	child = find_child(n, 0);
+    	m = (child) ? *child : NULL;
+    	if (m && IS_LEAF(m)) {
+            m = (art_node*)LEAF_RAW(m);
+            // Check if the expanded path matches
+            if (!str_prefix_matches((art_leaf*)m, str, str_len)) {
+                found = (art_leaf*)m;
+                stop_search = func(found->key, found->key_len, found->value, arg);
+            }
+    	}
+
+        // Bail if the prefix does not match
+        if (n->partial_len) {
+            prefix_len = check_prefix(n, str, str_len, depth);
+            if (prefix_len != min(MAX_PREFIX_LEN, n->partial_len))
+                break;
+            depth = depth + n->partial_len;
+        }
+
+        // Recursively search
+        child = find_child(n, str[depth]);
+        n = (child) ? *child : NULL;
+        depth++;
+    }
+
+    if (found == NULL) {
+        return ;
+    }
+
+    return ;
+}
--- a/src/lib/bitops.c
+++ b/src/lib/bitops.c
@@ -1,3 +1,20 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */

 #include "bitmap.h"
 #include "bitops.h"
--- a/src/lib/conf.c
+++ b/src/lib/conf.c
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "conf.h"
 #include <getopt.h>
 #include <stdio.h>
@@ -117,11 +135,13 @@ void conf_getopt_reset(void)
 	int argc = 2;
 	char *argv[3] = {"reset", "", 0};

-	optind = 1;
+	optind = 0;
 	opterr = 0;
+	optopt = 0;
 	getopt_long(argc, argv, "", long_options, NULL);
-	optind = 1;
+	optind = 0;
 	opterr = 0;
+	optopt = 0;
 }

 int conf_parse_args(char *key, char *value, int *argc, char **argv)
@@ -165,7 +185,6 @@ int conf_parse_args(char *key, char *value, int *argc, char **argv)
 			argv[count] = start;
 			*ptr = '\0';
 			ptr++;
-			start = ptr;
 			count++;
 			sep_flag = ' ';
 			start = NULL;
@@ -181,7 +200,7 @@ int conf_parse_args(char *key, char *value, int *argc, char **argv)
 	}

 	*argc = count;
-	argv[count + 1] = 0;
+	argv[count] = 0;

 	return 0;
 }
--- a/src/lib/radix.c
+++ b/src/lib/radix.c
@@ -281,7 +281,7 @@ static radix_node_t
 *radix_search_best2(radix_tree_t *radix, prefix_t *prefix, int inclusive)
 {
 	radix_node_t *node;
-	radix_node_t *stack[RADIX_MAXBITS + 1];
+	radix_node_t *stack[RADIX_MAXBITS + 1] = {0};
 	unsigned char *addr;
 	unsigned int bitlen;
 	int cnt = 0;
--- a/src/lib/rbtree.c
+++ b/src/lib/rbtree.c
@@ -1,3 +1,20 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */

 #include "rbtree.h"
 #include <stdbool.h>
--- a/src/lib/stringutil.c
+++ b/src/lib/stringutil.c
@@ -0,0 +1,17 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
--- a/src/smartdns.c
+++ b/src/smartdns.c
@@ -1,6 +1,6 @@
 /*************************************************************************
 *
- * Copyright (C) 2018 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
 *
 * smartdns is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -59,7 +59,8 @@ static void _help(void)
 		"  -c [conf]     config file.\n"
 		"  -p [pid]      pid file path\n"
 		"  -S            ignore segment fault signal.\n"
-		"  -v            verbose screent.\n"
+		"  -x            verbose screen.\n"
+		"  -v            dispaly version.\n"
 		"  -h            show this help message.\n"

 		"Online help: http://pymumu.github.io/smartdns\n"
@@ -69,6 +70,20 @@ static void _help(void)
 	printf("%s", help);
 }

+static void _show_version(void)
+{
+	char str_ver[256] = {0};
+#ifdef SMARTDNS_VERION
+	const char *ver = SMARTDNS_VERION;
+	snprintf(str_ver, sizeof(str_ver), "%s", ver);
+#else
+	struct tm tm;
+	get_compiled_time(&tm);
+	snprintf(str_ver, sizeof(str_ver), "1.%.4d%.2d%.2d-%.2d%.2d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);
+#endif
+	printf("smartdns %s\n", str_ver);
+}
+
 static int _smartdns_load_from_resolv(void)
 {
 	FILE *fp = NULL;
@@ -108,7 +123,7 @@ static int _smartdns_load_from_resolv(void)
 			port = DEFAULT_DNS_PORT;
 		}

-		strncpy(dns_conf_servers[dns_conf_server_num].server, ns_ip, DNS_MAX_IPLEN);
+		safe_strncpy(dns_conf_servers[dns_conf_server_num].server, ns_ip, DNS_MAX_IPLEN);
 		dns_conf_servers[dns_conf_server_num].port = port;
 		dns_conf_servers[dns_conf_server_num].type = DNS_SERVER_UDP;
 		dns_conf_server_num++;
@@ -139,16 +154,17 @@ static int _smartdns_add_servers(void)
 		case DNS_SERVER_HTTPS: {
 			struct client_dns_server_flag_https *flag_http = &flags.https;
 			flag_http->spi_len = dns_client_spki_decode(dns_conf_servers[i].spki, (unsigned char *)flag_http->spki);
-			strncpy(flag_http->hostname, dns_conf_servers[i].hostname, sizeof(flag_http->hostname));
-			strncpy(flag_http->path, dns_conf_servers[i].path, sizeof(flag_http->path));
-			strncpy(flag_http->httphost, dns_conf_servers[i].httphost, sizeof(flag_http->httphost));
+			safe_strncpy(flag_http->hostname, dns_conf_servers[i].hostname, sizeof(flag_http->hostname));
+			safe_strncpy(flag_http->path, dns_conf_servers[i].path, sizeof(flag_http->path));
+			safe_strncpy(flag_http->httphost, dns_conf_servers[i].httphost, sizeof(flag_http->httphost));
+			safe_strncpy(flag_http->tls_host_verify, dns_conf_servers[i].tls_host_verify, sizeof(flag_http->tls_host_verify));
 		} break;
 		case DNS_SERVER_TLS: {
 			struct client_dns_server_flag_tls *flag_tls = &flags.tls;
 			flag_tls->spi_len = dns_client_spki_decode(dns_conf_servers[i].spki, (unsigned char *)flag_tls->spki);
-			strncpy(flag_tls->hostname, dns_conf_servers[i].hostname, sizeof(flag_tls->hostname));
+			safe_strncpy(flag_tls->hostname, dns_conf_servers[i].hostname, sizeof(flag_tls->hostname));
+			safe_strncpy(flag_tls->tls_host_verify, dns_conf_servers[i].tls_host_verify, sizeof(flag_tls->tls_host_verify));
 		} break;
-			break;
 		case DNS_SERVER_TCP:
 			break;
 		default:
@@ -206,20 +222,22 @@ static int _smartdns_set_ecs_ip(void)

 static int _smartdns_init_ssl(void)
 {
+#if OPENSSL_API_COMPAT < 0x10100000L
 	SSL_load_error_strings();
 	SSL_library_init();
 	OpenSSL_add_all_algorithms();
 	SSL_CRYPTO_thread_setup();
-
+#endif
 	return 0;
 }

 static int _smartdns_destroy_ssl(void)
 {
+#if OPENSSL_API_COMPAT < 0x10100000L
 	SSL_CRYPTO_thread_cleanup();
 	ERR_free_strings();
 	EVP_cleanup();
-
+#endif
 	return 0;
 }

@@ -232,7 +250,7 @@ static int _smartdns_init(void)
 		logfile = dns_conf_log_file;
 	}

-	ret = tlog_init(logfile, dns_conf_log_size, dns_conf_log_num, 1, 0, 0);
+	ret = tlog_init(logfile, dns_conf_log_size, dns_conf_log_num, 0, 0);
 	if (ret != 0) {
 		tlog(TLOG_ERROR, "start tlog failed.\n");
 		goto errout;
@@ -359,10 +377,10 @@ int main(int argc, char *argv[])
 	char pid_file[MAX_LINE_LEN];
 	int signal_ignore = 0;

-	strncpy(config_file, SMARTDNS_CONF_FILE, MAX_LINE_LEN);
-	strncpy(pid_file, SMARTDNS_PID_FILE, MAX_LINE_LEN);
+	safe_strncpy(config_file, SMARTDNS_CONF_FILE, MAX_LINE_LEN);
+	safe_strncpy(pid_file, SMARTDNS_PID_FILE, MAX_LINE_LEN);

-	while ((opt = getopt(argc, argv, "fhc:p:Sv")) != -1) {
+	while ((opt = getopt(argc, argv, "fhc:p:Svx")) != -1) {
 		switch (opt) {
 		case 'f':
 			is_forground = 1;
@@ -376,9 +394,13 @@ int main(int argc, char *argv[])
 		case 'S':
 			signal_ignore = 1;
 			break;
-		case 'v':
+		case 'x':
 			verbose_screen = 1;
 			break;
+		case 'v':
+			_show_version();
+			return 0;
+			break;
 		case 'h':
 			_help();
 			return 1;
@@ -396,12 +418,12 @@ int main(int argc, char *argv[])
 		_reg_signal();
 	}

-	if (dns_server_load_conf(config_file) != 0) {
-		fprintf(stderr, "load config failed.\n");
+	if (create_pid_file(pid_file) != 0) {
 		goto errout;
 	}

-	if (create_pid_file(pid_file) != 0) {
+	if (dns_server_load_conf(config_file) != 0) {
+		fprintf(stderr, "load config failed.\n");
 		goto errout;
 	}

--- a/src/tlog.c
+++ b/src/tlog.c
--- a/src/tlog.h
+++ b/src/tlog.h
@@ -1,6 +1,6 @@
 /*
 * tinylog
- * Copyright (C) 2018 Ruilin Peng (Nick) <pymumu@gmail.com>
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>
 * https://github.com/pymumu/tinylog
 */

@@ -24,21 +24,44 @@ typedef enum {

 struct tlog_time {
    int year;
-    int mon;
-    int mday;
-    int hour;
-    int min;
-    int sec;
-    int usec;
-};
+    unsigned int usec;
+    unsigned char mon;
+    unsigned char mday;
+    unsigned char hour;
+    unsigned char min;
+    unsigned char sec;
+} __attribute__((packed));
+
+#ifndef TLOG_MAX_LINE_LEN
+#define TLOG_MAX_LINE_LEN (1024)
+#endif
+
+/* TLOG FLAGS LIST */
+/* set tlog not compress file when archive */
+#define TLOG_NOCOMPRESS (1 << 0)
+
+/* Set the segmentation mode to process the log, Used by the callback function to return a full log*/
+#define TLOG_SEGMENT (1 << 1)
+
+/*
+ multiwrite: enable multi process write mode.
+            NOTICE: maxlogsize in all prcesses must be same when enable this mode.
+ */
+#define TLOG_MULTI_WRITE (1 << 2)
+
+/* Not Block if buffer is insufficient. */
+#define TLOG_NONBLOCK (1 << 3)
+
+/* enable log to screen */
+#define TLOG_SCREEN (1 << 4)

 struct tlog_info {
-    const char *level;
+    tlog_level level;
    const char *file;
    const char *func;
    int line;
    struct tlog_time time;
-};
+} __attribute__((packed));

 /*
 Function: Print log
@@ -51,9 +74,12 @@ format: Log formats
 #define tlog(level, format, ...) tlog_ext(level, BASE_FILE_NAME, __LINE__, __func__, NULL, format, ##__VA_ARGS__)

 extern int tlog_ext(tlog_level level, const char *file, int line, const char *func, void *userptr, const char *format, ...)
-    __attribute__((format(printf, 6, 7)));
+    __attribute__((format(printf, 6, 7))) __attribute__((nonnull (6)));
 extern int tlog_vext(tlog_level level, const char *file, int line, const char *func, void *userptr, const char *format, va_list ap);

+/* write buff to log file */
+extern int tlog_write_log(char *buff, int bufflen);
+
 /* set log level */
 extern int tlog_setlevel(tlog_level level);

@@ -63,17 +89,18 @@ extern void tlog_setlogscreen(int enable);
 /* enalbe early log to screen */
 extern void tlog_set_early_printf(int enable);

+/* Get log level in string */
+extern const char *tlog_get_level_string(tlog_level level);
+
 /*
 Function: Initialize log module
 logfile: log file.
 maxlogsize: The maximum size of a single log file.
 maxlogcount: Number of archived logs.
-block: Blocked if buffer is not sufficient.
 buffsize: Buffer size, zero for default (128K)
-multiwrite: enable multi process write mode.
-            NOTICE: maxlogsize in all prcesses must be same when enable this mode.
+flag: read tlog flags
 */
-extern int tlog_init(const char *logfile, int maxlogsize, int maxlogcount, int block, int buffsize, int multiwrite);
+extern int tlog_init(const char *logfile, int maxlogsize, int maxlogcount, int buffsize, unsigned int flag);

 /* flush pending log message, and exit tlog */
 extern void tlog_exit(void);
@@ -89,6 +116,12 @@ read _tlog_format for example.
 typedef int (*tlog_format_func)(char *buff, int maxlen, struct tlog_info *info, void *userptr, const char *format, va_list ap);
 extern int tlog_reg_format_func(tlog_format_func func);

+/* register log output callback 
+ Note: info is invalid when flag TLOG_SEGMENT is not set.
+ */
+typedef int (*tlog_log_output_func)(struct tlog_info *info, char *buff, int bufflen, void *private_data);
+extern int tlog_reg_log_output_func(tlog_log_output_func output, void *private_data);
+
 struct tlog_log;
 typedef struct tlog_log tlog_log;
 /*
@@ -96,15 +129,16 @@ Function: open a new log stream, handler should close by tlog_close
 logfile: log file.
 maxlogsize: The maximum size of a single log file.
 maxlogcount: Number of archived logs.
-block: Blocked if buffer is not sufficient.
 buffsize: Buffer size, zero for default (128K)
-multiwrite: enable multi process write mode.
-            NOTICE: maxlogsize in all prcesses must be same when enable this mode.
-
+flag: read tlog flags
 return: log stream handler.
 */
-extern tlog_log *tlog_open(const char *logfile, int maxlogsize, int maxlogcount, int block, int buffsize, int multiwrite);
+extern tlog_log *tlog_open(const char *logfile, int maxlogsize, int maxlogcount, int buffsize, unsigned int flag);

+/* write buff to log file */
+extern int tlog_write(struct tlog_log *log, char *buff, int bufflen);
+
+/* close log stream */
 extern void tlog_close(tlog_log *log);

 /*
@@ -112,7 +146,7 @@ Function: Print log to log stream
 log: log stream
 format: Log formats
 */
-extern int tlog_printf(tlog_log *log, const char *format, ...) __attribute__((format(printf, 2, 3)));
+extern int tlog_printf(tlog_log *log, const char *format, ...) __attribute__((format(printf, 2, 3))) __attribute__((nonnull (1, 2)));

 /*
 Function: Print log to log stream with ap
@@ -125,6 +159,16 @@ extern int tlog_vprintf(tlog_log *log, const char *format, va_list ap);
 /* enalbe log to screen */
 extern void tlog_logscreen(tlog_log *log, int enable);

+/* register output callback */
+typedef int (*tlog_output_func)(struct tlog_log *log, char *buff, int bufflen);
+extern int tlog_reg_output_func(tlog_log *log, tlog_output_func output);
+
+/* set private data */
+extern void tlog_set_private(tlog_log *log, void *private_data);
+
+/* get private data */
+extern void *tlog_get_private(tlog_log *log);
+
 /* get local time */
 extern int tlog_localtime(struct tlog_time *tm);

--- a/src/util.c
+++ b/src/util.c
@@ -1,3 +1,21 @@
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
@@ -7,9 +25,11 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/netlink.h>
+#include <linux/capability.h>
 #include <openssl/crypto.h>
 #include <openssl/ssl.h>
 #include <pthread.h>
+#include <netinet/tcp.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
@@ -17,6 +37,7 @@
 #include <time.h>
 #include <unistd.h>
 #include <inttypes.h>
+#include <sys/prctl.h>

 #define TMP_BUFF_LEN_32 32

@@ -65,6 +86,7 @@ struct ipset_netlink_msg {
 };

 static int ipset_fd;
+static int pidfile_fd;

 unsigned long get_tick_count(void)
 {
@@ -125,6 +147,7 @@ int getaddr_by_host(char *host, struct sockaddr *addr, socklen_t *addr_len)
 		result->ai_addrlen = *addr_len;
 	}

+	addr->sa_family = result->ai_family;
 	memcpy(addr, result->ai_addr, result->ai_addrlen);
 	*addr_len = result->ai_addrlen;

@@ -138,6 +161,75 @@ errout:
 	return -1;
 }

+int getsocknet_inet(int fd, struct sockaddr *addr, socklen_t *addr_len)
+{
+	struct sockaddr_storage addr_store;
+	socklen_t addr_store_len = sizeof(addr_store);
+	if (getsockname(fd, (struct sockaddr *)&addr_store, &addr_store_len) != 0) {
+		goto errout;
+	}
+
+	switch (addr_store.ss_family) {
+	case AF_INET: {
+		struct sockaddr_in *addr_in;
+		addr_in = (struct sockaddr_in *)addr;
+		addr_in->sin_family = AF_INET;
+		*addr_len = sizeof(struct sockaddr_in);
+		memcpy(addr, addr_in, sizeof(struct sockaddr_in));
+	} break;
+	case AF_INET6: {
+		struct sockaddr_in6 *addr_in6;
+		addr_in6 = (struct sockaddr_in6 *)addr;
+		if (IN6_IS_ADDR_V4MAPPED(&addr_in6->sin6_addr)) {
+			struct sockaddr_in addr_in4;
+			memset(&addr_in4, 0, sizeof(addr_in4));
+			memcpy(&addr_in4.sin_addr.s_addr, addr_in6->sin6_addr.s6_addr + 12, sizeof(addr_in4.sin_addr.s_addr));
+			addr_in4.sin_family = AF_INET;
+			addr_in4.sin_port = 0;
+			*addr_len = sizeof(struct sockaddr_in);
+			memcpy(addr, &addr_in4, sizeof(struct sockaddr_in));
+		} else {
+			addr_in6->sin6_family = AF_INET6;
+			*addr_len = sizeof(struct sockaddr_in6);
+			memcpy(addr, addr_in6, sizeof(struct sockaddr_in6));
+		}
+	} break;
+	default:
+		goto errout;
+		break;
+	}
+	return 0;
+errout:
+	return -1;
+}
+
+int fill_sockaddr_by_ip(unsigned char *ip, int ip_len, int port, struct sockaddr *addr, socklen_t *addr_len)
+{
+	if (ip == NULL || addr == NULL || addr_len == NULL) {
+		return -1;
+	}
+
+	if (ip_len == IPV4_ADDR_LEN) {
+		struct sockaddr_in *addr_in = NULL;
+		addr->sa_family = AF_INET;
+		addr_in = (struct sockaddr_in *)addr;
+		addr_in->sin_port = htons(port);
+		addr_in->sin_family = AF_INET;
+		memcpy(&addr_in->sin_addr.s_addr, ip, ip_len);
+		*addr_len = 16;
+	} else if (ip_len == IPV6_ADDR_LEN) {
+		struct sockaddr_in6 *addr_in6 = NULL;
+		addr->sa_family = AF_INET6;
+		addr_in6 = (struct sockaddr_in6 *)addr;
+		addr_in6->sin6_port = htons(port);
+		addr_in6->sin6_family = AF_INET6;
+		memcpy(addr_in6->sin6_addr.s6_addr, ip, ip_len);
+		*addr_len = 28;
+	}
+
+	return -1;
+}
+
 int parse_ip(const char *value, char *ip, int *port)
 {
 	int offset = 0;
@@ -327,7 +419,7 @@ int parse_uri(char *value, char *scheme, char *host, int *port, char *path)
 	process_ptr += field_len;

 	if (path) {
-		strcpy(path, process_ptr);
+		strncpy(path, process_ptr, PATH_MAX);
 	} 
 	return 0;
 }
@@ -350,7 +442,7 @@ int set_fd_nonblock(int fd, int nonblock)
 	return 0;
 }

-char *reverse_string(char *output, char *input, int len)
+char *reverse_string(char *output, const char *input, int len, int to_lower_case)
 {
 	char *begin = output;
 	if (len <= 0) {
@@ -361,6 +453,12 @@ char *reverse_string(char *output, char *input, int len)
 	len--;
 	while (len >= 0) {
 		*output = *(input + len);
+		if (to_lower_case) {
+			if (*output >= 'A' && *output <= 'Z') {
+				/* To lower case */
+         		*output = *output + 32;
+      		}
+		}
 		output++;
 		len--;
 	}
@@ -473,7 +571,7 @@ static int _ipset_operate(const char *ipsetname, const unsigned char addr[], int
 	nested[0]->len = (void *)buffer + NETLINK_ALIGN(netlink_head->nlmsg_len) - (void *)nested[0];

 	for (;;) {
-		rc = sendto(ipset_fd, buffer, netlink_head->nlmsg_len, 0, (struct sockaddr *)&snl, sizeof(snl));
+		rc = sendto(ipset_fd, buffer, netlink_head->nlmsg_len, 0, (const struct sockaddr *)&snl, sizeof(snl));
 		if (rc >= 0) {
 			break;
 		}
@@ -575,6 +673,12 @@ int create_pid_file(const char *pid_file)
 		goto errout;
 	}

+	if (pidfile_fd > 0) {
+		close(pidfile_fd);
+	}
+
+	pidfile_fd = fd;
+
 	return 0;
 errout:
 	if (fd > 0) {
@@ -583,6 +687,7 @@ errout:
 	return -1;
 }

+#if OPENSSL_API_COMPAT < 0x10100000
 #define THREAD_STACK_SIZE (16 * 1024)
 static pthread_mutex_t *lock_cs;
 static long *lock_count;
@@ -639,6 +744,7 @@ void SSL_CRYPTO_thread_cleanup(void)
 	OPENSSL_free(lock_cs);
 	OPENSSL_free(lock_count);
 }
+#endif

 #define SERVER_NAME_LEN 256
 #define TLS_HEADER_LEN 5
@@ -647,25 +753,10 @@ void SSL_CRYPTO_thread_cleanup(void)
 #ifndef MIN
 #define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
 #endif
-typedef struct Protocol {
-    const char *const name;
-    const uint16_t default_port;
-    int (*const parse_packet)(const char*, size_t, char *, const char **);
-    const char *const abort_message;
-    const size_t abort_message_len;
-} protocol_t;

 static int parse_extensions(const char *, size_t, char *, const char **);
 static int parse_server_name_extension(const char *, size_t, char *, const char **);

-const struct Protocol *const tls_protocol;
-
-static const protocol_t tls_protocol_st = {
-	.default_port = 443,
-	.parse_packet = &parse_tls_header,
-};
-const protocol_t *const tls_protocol = &tls_protocol_st;
-
 /* Parse a TLS packet for the Server Name Indication extension in the client
 * hello handshake, returning the first servername found (pointer to static
 * array)
@@ -833,3 +924,47 @@ static int parse_server_name_extension(const char *data, size_t data_len, char *

 	return -2;
 }
+
+void get_compiled_time(struct tm *tm) 
+{ 
+    char s_month[5];
+    int month, day, year;
+	int hour, min, sec;
+    static const char *month_names = "JanFebMarAprMayJunJulAugSepOctNovDec";
+
+    sscanf(__DATE__, "%5s %d %d", s_month, &day, &year);
+    month = (strstr(month_names, s_month) - month_names) / 3;
+	sscanf(__TIME__, "%d:%d:%d", &hour, &min, &sec);
+    tm->tm_year = year - 1900;
+    tm->tm_mon = month;
+    tm->tm_mday = day;
+    tm->tm_isdst = -1;
+	tm->tm_hour = hour;
+	tm->tm_min = min;
+	tm->tm_sec = sec;
+}
+
+int has_network_raw_cap(void)
+{
+	int fd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+	if (fd < 0) {
+		return 0;
+	}
+
+	close(fd);
+	return 1;
+}
+
+int set_sock_keepalive(int fd, int keepidle, int keepinterval, int keepcnt)
+{
+	const int yes = 1;
+	if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes))!= 0) {
+		return -1;
+	}
+
+	setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepidle, sizeof(keepidle));
+	setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepinterval, sizeof(keepinterval));
+	setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepcnt, sizeof(keepcnt));
+
+	return 0;
+}
--- a/src/util.h
+++ b/src/util.h
@@ -1,9 +1,42 @@
-
+/*************************************************************************
+ *
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ *
+ * smartdns is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * smartdns is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */

 #ifndef SMART_DNS_UTIL_H
 #define SMART_DNS_UTIL_H

 #include <netdb.h>
+#include <time.h>
+#include "stringutil.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /*__cplusplus */
+
+#ifndef TCP_FASTOPEN_CONNECT
+#define TCP_FASTOPEN_CONNECT 30
+#endif
+#ifndef TCP_THIN_LINEAR_TIMEOUTS
+#define TCP_THIN_LINEAR_TIMEOUTS 16 
+#endif
+
+#ifndef TCP_THIN_DUPACK
+#define TCP_THIN_DUPACK		 17 
+#endif

 #define PORT_NOT_DEFINED -1
 #define MAX_IP_LEN 64
@@ -14,6 +47,10 @@ char *gethost_by_addr(char *host, int maxsize, struct sockaddr *addr);

 int getaddr_by_host(char *host, struct sockaddr *addr, socklen_t *addr_len);

+int getsocknet_inet(int fd, struct sockaddr *addr, socklen_t *addr_len);
+
+int fill_sockaddr_by_ip(unsigned char *ip, int ip_len, int port, struct sockaddr *addr, socklen_t *addr_len);
+
 int parse_ip(const char *value, char *ip, int *port);

 int check_is_ipaddr(const char *ip);
@@ -22,7 +59,7 @@ int parse_uri(char *value, char *scheme, char *host, int *port, char *path);

 int set_fd_nonblock(int fd, int nonblock);

-char *reverse_string(char *output, char *input, int len);
+char *reverse_string(char *output, const char *input, int len, int to_lower_case);

 void print_stack(void);

@@ -55,4 +92,13 @@ int create_pid_file(const char *pid_file);
 */
 int parse_tls_header(const char *data, size_t data_len, char *hostname, const char **hostname_ptr);

+void get_compiled_time(struct tm *tm);
+
+int has_network_raw_cap(void);
+
+int set_sock_keepalive(int fd, int keepidle, int keepinterval, int keepcnt);
+
+#ifdef __cplusplus
+}
+#endif /*__cplusplus */
 #endif
Author	SHA1	Message	Date
Nick Peng	0d2d08586a	ReadMe: Update package list information	2020-02-19 23:17:34 +08:00
Nick Peng	c8ab6db39e	BugFix: fix install script issue, and change openwrt script default port for seconddns	2020-02-18 19:39:01 +08:00
Nick Peng	2afd4e7d4a	luci-app-smartdns: Service redirect status is not displayed when smartdns is disabled	2020-02-15 14:48:56 +08:00
Nick Peng	20051a3698	second DNS: change default port 7053 to 6553	2020-02-15 14:35:51 +08:00
Nick Peng	5f9167cf07	bind-option: support force aaaa soa bind option, secondary DNS support Force-AAAA-SOA options	2020-02-14 13:14:03 +08:00
Nick Peng	3cf2d35c13	dualstack-selection: force IPV4 when not found IPV6 in cache	2020-02-14 13:13:47 +08:00
Nick Peng	8990446411	serve-expired: new feature, support cache serve-expired feature	2020-02-14 13:13:22 +08:00
Felix Yan	8f40eba083	smartdns.conf: correct some typos	2020-02-14 09:41:12 +08:00
Nick Peng	4bd6c025db	domain-rules: new feature, support set speed-check-mode	2020-02-05 23:21:59 +08:00
Nick Peng	80174d9da5	luci-app-smartdns: rewrite luci-app in JavaScript	2020-02-01 14:05:05 +08:00
Nick Peng	7d1b850119	luci-app-smartdns: rename luci-app-smartdns to luci-app-smartdns-compat	2020-02-01 11:55:43 +08:00
Nick Peng	744a5409e0	init-script: fix a script typo	2020-01-31 14:16:28 +08:00
Rosen Penev	d965df2c44	run openwrt init script through shellcheck Signed-off-by: Rosen Penev <rosenp@gmail.com>	2020-01-30 13:12:52 +08:00
Nick Peng	2322a9dbd0	ssl: Stop using deprecated Openssl APIs, by neheb.	2020-01-21 22:48:02 +08:00
Nick Peng	aa7237f770	Codesytle: replace CRLF with LF	2020-01-21 20:00:38 +08:00
Soff	50572acc11	Update ReadMe.md `bind` -> `bind-tcp`	2020-01-13 23:59:21 +08:00
Nick Peng	511f8c135c	BugFix: ssl crash issue.	2020-01-04 00:09:57 +08:00
Nick Peng	198d18f18a	BugFix: tcp server process failed	2019-12-28 21:57:56 +08:00
Nick Peng	ba9fbc981f	add some SSL exception check	2019-12-27 00:44:49 +08:00
Nick Peng	5a91e90ee3	update Makefile for openwrt	2019-12-21 11:56:04 +08:00
Nick Peng	982002e836	Modify the detection method of smartdns	2019-12-21 11:28:37 +08:00
Nick Peng	aaeae7167b	Fix shellcheck issues	2019-12-21 11:02:55 +08:00
Nick Peng	0228a79991	Fix smartdns luci typo	2019-12-19 22:38:53 +08:00
Nick Peng	d6c34658af	Add github issue template	2019-12-15 10:32:45 +08:00
Nick Peng	cc93156ee3	Add package build script	2019-12-15 01:28:37 +08:00
Nick Peng	8433729186	Update ReadMe.md	2019-12-15 01:28:37 +08:00
Nick Peng	4464bb982e	update makefile for openwrt	2019-12-15 01:28:36 +08:00
Nick Peng	371aab6d4b	support override CFLAGS and CXXFLAGS	2019-12-15 01:28:35 +08:00
Nick Peng	01e4140722	Add license	2019-12-15 01:28:32 +08:00
Nick Peng	2b08ffee98	Add some log, fix tlog issue	2019-12-15 01:28:31 +08:00
Nick Peng	9f27bb9b70	Fix compile error	2019-12-15 01:28:30 +08:00
Nick Peng	528d5c6ccc	Update tlog	2019-12-15 01:28:30 +08:00
Nick Peng	6bf6315a6d	Fix ssl crash issue	2019-12-15 01:28:29 +08:00
Nick Peng	aaca1c013b	Fix byte alignment issue	2019-12-15 01:28:27 +08:00
Nick Peng	25c6cab4a8	Fix installation issue on arch-linux	2019-12-15 01:28:26 +08:00
Nick Peng	408c199564	create pid before load config file to avoid systemd complain	2019-12-15 01:28:24 +08:00
Nick Peng	044536aef6	optimize tcp connection lag	2019-12-15 01:28:22 +08:00
Nick Peng	1fb5cbbcd9	Fix ignore flags not working issue	2019-12-15 01:28:18 +08:00
Nick Peng	4e0cbc50b3	Update ReadMe.md	2019-12-15 01:28:17 +08:00
Nick Peng	7cbd926ede	optimize log	2019-12-15 01:28:16 +08:00
Nick Peng	fb3b0a7245	disable ping when smartdns run as non-root user	2019-12-15 01:28:15 +08:00
Nick Peng	64abad4077	Fix rule search issue.	2019-12-15 01:28:14 +08:00
Nick Peng	c3501923db	fix /address/# not working when dualstack enabled	2019-12-15 01:28:13 +08:00
Nick Peng	721c56cbec	socket ip priority optimize	2019-12-15 01:28:11 +08:00
Nick Peng	9213f898c3	Fix CNAME buff too short issue	2019-12-15 01:28:07 +08:00
Nick Peng	65e8cd5e61	optimize code	2019-12-15 01:28:04 +08:00
Nick Peng	e05d1f9d17	Enable audit-log SOA	2019-12-15 01:28:02 +08:00
Nick Peng	c4b99a99e7	UI support second DNS server.	2019-12-15 01:27:52 +08:00
Nick Peng	8c96081807	Update readme	2019-12-15 01:27:51 +08:00
Nick Peng	640efd7b86	Fix tcp local address issue	2019-12-15 01:27:50 +08:00
Nick Peng	add8eecead	Fix crash issue caused by unknown http response	2019-12-15 01:27:46 +08:00
Nick Peng	da9ef34588	optimize log	2019-12-15 01:27:46 +08:00
Nick Peng	87f04571b1	minor optimize	2019-12-15 01:27:44 +08:00
Nick Peng	6291c17d6a	Fix tcpping ipv6 address issue	2019-12-15 01:27:40 +08:00
Nick Peng	f801023569	Optimize prefetch hitime	2019-12-15 01:27:39 +08:00
Nick Peng	4e11c13ec0	Support no-soa, no-dualstack-selection for bind flags	2019-12-15 01:27:39 +08:00
Nick Peng	273c2d5100	Fix lint issue	2019-12-15 01:27:37 +08:00
Nick Peng	5082f1ae55	Update tlog	2019-12-15 01:27:36 +08:00
Nick Peng	3f7bc30f65	Support verify TLS hostname	2019-12-15 01:27:35 +08:00
Nick Peng	77bce2e7c6	Fix tcpidle close bind socket issue	2019-12-15 01:27:33 +08:00
Nick Peng	9a23bf6113	optimize code	2019-12-15 01:27:32 +08:00
Nick Peng	1f6e447f86	format code sytle	2019-12-15 01:27:30 +08:00
Nick Peng	b1eafb6491	Support listen multi ip addresses, and support server flags	2019-12-15 01:27:29 +08:00
Nick Peng	81468a3c4f	Optimize answer process function	2019-12-15 01:27:27 +08:00
Nick Peng	9e928983e0	Support config speed-check-mode	2019-12-15 01:27:26 +08:00
Nick Peng	9b8d7de6d3	fix restart dnsmasq issue	2019-12-15 01:27:25 +08:00
Nick Peng	46742fc1d7	refactoring fast_ping.c	2019-12-15 01:27:25 +08:00
Nick Peng	358994e431	force restart dnsmasq when start smartdns	2019-12-15 01:27:24 +08:00
Nick Peng	7427d39476	Update tlog	2019-12-15 01:27:24 +08:00
Nick Peng	751c1e3a98	Fix dnsmasq not found issue	2019-12-15 01:27:23 +08:00
Nick Peng	90d5c7e396	Update tlog	2019-12-15 01:27:22 +08:00
Nick Peng	0a0d0f001e	fix dns_server_query issue	2019-12-15 01:27:20 +08:00
Nick Peng	bc953d0c9b	Minor code optimize	2019-12-15 01:27:19 +08:00
Nick Peng	44c854dfec	_dns_server_recv function refactoring	2019-12-15 01:27:18 +08:00
Nick Peng	301a60f6ed	Fix get opt issue	2019-12-15 01:27:17 +08:00
Nick Peng	4db61f2677	Fix TimeZone issue when static compile	2019-12-15 01:27:14 +08:00
Nick Peng	7746ecb46d	Fix script issue on padavan	2019-12-15 01:27:13 +08:00
Nick Peng	4357847641	Add display version	2019-12-15 01:27:12 +08:00
Nick Peng	e7e0a5d4af	Fix openssl version issue	2019-12-15 01:27:11 +08:00
Nick Peng	57aa9c013d	Fix optware startup script issue	2019-12-15 01:27:10 +08:00
Nick Peng	7216dcf526	Update ReadMe.md	2019-12-15 01:27:09 +08:00
Nick Peng	41e2067628	Fix build issue	2019-12-15 01:27:06 +08:00
Nick Peng	dda785ec5f	Support TLS 1.3	2019-12-15 01:27:05 +08:00
Nick Peng	99972c36ad	Fix ps bug	2019-12-15 01:27:04 +08:00
Nick Peng	ef50ea9c5e	Change rule domain to lowercase	2019-12-15 01:27:03 +08:00
Nick Peng	cb3656cb57	Change config accept-ip to whitelist-ip	2019-12-15 01:27:02 +08:00
Nick Peng	3ef325d75d	Support GCC 8.x and support static compile	2019-12-15 01:27:02 +08:00
Nick Peng	a09e63d333	Support IP accept list	2019-12-15 01:27:01 +08:00