luci-app-smartdns: clean javascript code

Signed-off-by: Rosen Penev <rosenp@gmail.com>

.github/ISSUE_TEMPLATE/feature.md

@@ -0,0 +1,20 @@
+---
+name: 需求建议
+about: 需求建议描述
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**需求应用场景**
+请描述需求应用的场景和方式。
+
+**建议的方案**
+实现上述场景建议的方案。
+
+**设备信息**
+1. 设备信息（CPU，厂家）  
+
+2. 固件信息
+

.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目录下
+

LICENSE

@@ -1,21 +1,23 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
+                       Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
                             Preamble
 
-  The GNU Affero General Public License is a free, copyleft license for
+  The GNU General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
+software and other kinds of works.
-cooperation with the community in the case of network server software.
 
   The licenses for most software and other practical works are designed
 to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
+the GNU General Public License is intended to guarantee your freedom to
 share and change all versions of a program--to make sure it remains free
-software for all its users.
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
 
   When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
@@ -24,34 +26,44 @@ them if you wish), that you receive source code or can get it if you
 want it, that you can change the software or use pieces of it in new
 free programs, and that you know you can do these things.
 
-  Developers that use our General Public Licenses protect your rights
+  To protect your rights, we need to prevent others from denying you
-with two steps: (1) assert copyright on the software, and (2) offer
+these rights or asking you to surrender the rights.  Therefore, you have
-you this License which gives you legal permission to copy, distribute
+certain responsibilities if you distribute copies of the software, or if
-and/or modify the software.
+you modify it: responsibilities to respect the freedom of others.
 
-  A secondary benefit of defending all users' freedom is that
+  For example, if you distribute copies of such a program, whether
-improvements made in alternate versions of the program, if they
+gratis or for a fee, you must pass on to the recipients the same
-receive widespread use, become available for other developers to
+freedoms that you received.  You must make sure that they, too, receive
-incorporate.  Many developers of free software are heartened and
+or can get the source code.  And you must show them these terms so they
-encouraged by the resulting cooperation.  However, in the case of
+know their rights.
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
 
-  The GNU Affero General Public License is designed specifically to
+  Developers that use the GNU GPL protect your rights with two steps:
-ensure that, in such cases, the modified source code becomes available
+(1) assert copyright on the software, and (2) offer you this License
-to the community.  It requires the operator of a network server to
+giving you legal permission to copy, distribute and/or modify it.
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
 
-  An older license, called the Affero General Public License and
+  For the developers' and authors' protection, the GPL clearly explains
-published by Affero, was designed to accomplish similar goals.  This is
+that there is no warranty for this free software.  For both users' and
-a different license, not a version of the Affero GPL, but Affero has
+authors' sake, the GPL requires that modified versions be marked as
-released a new version of the Affero GPL which permits relicensing under
+changed, so that their problems will not be attributed erroneously to
-this license.
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
@@ -60,7 +72,7 @@ modification follow.
 
   0. Definitions.
 
-  "This License" refers to version 3 of the GNU Affero General Public License.
+  "This License" refers to version 3 of the GNU General Public License.
 
   "Copyright" also means copyright-like laws that apply to other kinds of
 works, such as semiconductor masks.
@@ -537,45 +549,35 @@ to collect a royalty for further conveying from those to whom you convey
 the Program, the only way you could satisfy both those terms and this
 License would be to refrain entirely from conveying the Program.
 
-  13. Remote Network Interaction; Use with the GNU General Public License.
+  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
 
   Notwithstanding any other provision of this License, you have
 permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
+under version 3 of the GNU Affero General Public License into a single
 combined work, and to convey the resulting work.  The terms of this
 License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
+but the special requirements of the GNU Affero General Public License,
-3 of the GNU General Public License.
+section 13, concerning interaction through a network will apply to the
+combination as such.
 
   14. Revised Versions of this License.
 
   The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
+the GNU General Public License from time to time.  Such new versions will
-will be similar in spirit to the present version, but may differ in detail to
+be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 
   Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
+Program specifies that a certain numbered version of the GNU General
 Public License "or any later version" applies to it, you have the
 option of following the terms and conditions either of that numbered
 version or of any later version published by the Free Software
 Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
+GNU General Public License, you may choose any version ever published
 by the Free Software Foundation.
 
   If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
+versions of the GNU General Public License can be used, that proxy's
 public statement of acceptance of a version permanently authorizes you
 to choose that version for the Program.
 
@@ -633,29 +635,40 @@ the "copyright" line and a pointer to where the full notice is found.
     Copyright (C) <year>  <name of author>
 
     This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
+    it under the terms of the GNU General Public License as published by
-    by the Free Software Foundation, either version 3 of the License, or
+    the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
     This program 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 Affero General Public License for more details.
+    GNU General Public License for more details.
 
-    You should have received a copy of the GNU Affero General Public License
+    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
-  If your software can interact with users remotely through a computer
+  If the program does terminal interaction, make it output a short
-network, you should also make sure that it provides a way for users to
+notice like this when it starts in an interactive mode:
-get its source.  For example, if your program is a web application, its
+
-interface could display a "Source" link that leads users to an archive
+    <program>  Copyright (C) <year>  <name of author>
-of the code.  There are many ways you could offer source, and different
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-solutions will be better for different programs; see section 13 for the
+    This is free software, and you are welcome to redistribute it
-specific requirements.
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
 
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
+For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

ReadMe.md

@@ -134,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系统(树莓派)| smartdns.xxxxxxxx.arm-debian-all.deb|支持树莓派Raspbian stretch，Debian 9系统。
-|标准Linux系统(Armbian arm64)| smartdns.xxxxxxxx.arm64.deb|支持ARM64的Debian stretch，Debian 9系统。
+|标准Linux系统(Armbian arm64)| smartdns.xxxxxxxx.aarch64-debian-all.deb|支持ARM64的Debian stretch，Debian 9系统。
-|标准Linux系统(x86_64)| smartdns.xxxxxxxx.x86_64.tar.gz|支持x86_64 Linux 系统。
+|标准Linux系统(x86_64)| smartdns.xxxxxxxx.x86_64-linux-all.tar.gz|支持x86_64 Linux 系统。
-|Windows 10 WSL (ubuntu)| smartdns.xxxxxxxx.x86_64.tar.gz|支持Windows 10 WSL ubuntu系统。
+|Windows 10 WSL (ubuntu)| smartdns.xxxxxxxx.x86_64-linux-all.tar.gz|支持Windows 10 WSL ubuntu系统。
-|标准Linux系统(x86)| smartdns.xxxxxxxx.x86.tar.gz|支持x86系统。
+|标准Linux系统(x86)| smartdns.xxxxxxxx.x86-linux-all.tar.gz|支持x86系统。
-|华硕原生固件(optware)|smartdns.xxxxxxx.mipsbig.ipk|支持MIPS大端架构的系统，如RT-AC55U, RT-AC66U.
+|optware|smartdns.xxxxxxxx.mips-optware-all.ipk|支持MIPS大端架构的optware系统。
-|华硕原生固件(optware)|smartdns.xxxxxxx.mipsel.ipk|支持MIPS小端架构的系统。
+|optware|smartdns.xxxxxxxx.mipsel-optware-all.ipk|支持MIPS小端架构的optware系统。
-|华硕原生固件(optware)|smartdns.xxxxxxx.arm.ipk|支持arm小端架构的系统，如RT-AC68U。
+|optware|smartdns.xxxxxxxx.arm-optware-all.ipk|支持arm小端架构的optware系统。
-|Padavan|smartdns.xxxxxxx.mipselsf.ipk|padavan固件。
+|openwrt|smartdns.xxxxxxxx.mips-openwrt-all.ipk|支持MIPS大端架构的openwrt系统。
-|openwrt 15.01|smartdns.xxxxxxxx.ar71xx.ipk|支持AR71XX MIPS系统。
+|openwrt|smartdns.xxxxxxxx.mipsel-openwrt-all.ipk|支持MIPS小端架构的openwrt系统。
-|openwrt 15.01|smartdns.xxxxxxxx.ramips_24kec.ipk|支持MT762X等小端路由器
+|openwrt|smartdns.xxxxxxxx.arm-openwrt-all.ipk|支持arm小端架构的openwrt系统。
-|openwrt 15.01(潘多拉)|smartdns.xxxxxxxx.mipsel_24kec_dsp.ipk|支持MT7620系列的潘多拉固件
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all.ipk|openwrt管理界面。
-|openwrt 15.01(潘多拉)|smartdns.xxxxxxxx.mips_74kc_dsp2.ipk|支持AR71xx系列的潘多拉固件
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all-luci-compat-all|兼容版本openwrt管理界面, openwrt 18.xx及之前版本安装。
-|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管理统一界面
 
-* openwrt系统CPU架构比较多，上述表格未列出所有支持系统，请查看CPU架构后下载。
+* 单独release的软件包为静态编译软件包，无外部依赖，但体积大。若需要小体积软件包，请自行编译或从openwrt/entware仓库获取。
-* merlin梅林固件理论和华硕固件一致，所以根据硬件类型安装相应的ipk包即可。（梅林暂时未验证，有问题提交issue）
+* 因静态编译，软件包未强制判断CPU架构，安装不正确的软件包将会导致服务无法启动，请获取正确的软件包。
-* 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页面下载：[点击此处下载](https://github.com/pymumu/smartdns/releases)**
 
@@ -209,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
@@ -252,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
 
 --------------
 
@@ -277,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`进行配置。
@@ -296,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.
         ```
 
     * **界面提示重定向失败**
@@ -329,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地址返回，则表示未生效，请多尝试几个域名检查。
@@ -393,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. 额外说明
@@ -469,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的文档。
@@ -493,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
@@ -526,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,7 +502,7 @@ https://github.com/pymumu/smartdns/releases
 |--|--|--|--|--|
 |server-name|DNS服务器名称|操作系统主机名/smartdns|符合主机名规格的字符串|server-name smartdns
 |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 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
+|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
@@ -568,12 +526,15 @@ https://github.com/pymumu/smartdns/releases
 |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]
 
@@ -672,6 +633,10 @@ https://github.com/pymumu/smartdns/releases
     通过`prefetch-domain yes`来启用域名预先获取功能，提高查询命中率。  
     配合上述ttl超时时间，smartdns将在域名ttl即将超时使，再次发送查询请求，并缓存查询结果供后续使用。频繁访问的域名将会持续缓存。此功能将在空闲时消耗更多的CPU。
 
+    * 过期缓存服务功能  
+    通过`serve-expired`来启用过期缓存服务功能，可提高缓存命中率的同时，降低CPU占用。  
+    此功能会在TTL超时后，将返回TTL=0给客户端，并且同时再次发送查询请求，并缓存新的结果给后续使用。
+
 1. 第二DNS如何自定义更多行为  
     第二DNS可以作为其他DNS服务器的上游，提供更多的查询行为，通过bind配置支持可以绑定多个端口，不同端口可设置不同的标志，实现不同的功能，如
 

ReadMe_en.md

@@ -129,66 +129,21 @@ 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 (Raspberry Pi)| smartdns.xxxxxxxx.arm-debian-all.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 (Armbian arm64)| smartdns.xxxxxxxx.aarch64-debian-all.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.
+|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.tar.gz|Windows 10 WSL ubuntu.
+|Windows 10 WSL (ubuntu)| smartdns.xxxxxxxx.x86_64-linux-all.tar.gz|Windows 10 WSL ubuntu.
-|Standard Linux system (x86)| smartdns.xxxxxxxx.x86.tar.gz|Support for x86_64 systems.
+|Standard Linux system (x86)| smartdns.xxxxxxxx.x86-linux-all.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.
+|optware|smartdns.xxxxxxxx.mips-optware-all.ipk|Support the MIPS big-endian architecture for optware。
-|ASUS native firmware (optware)|smartdns.xxxxxxx.mipsel.ipk|System that supports the MIPS little endian architecture.
+|optware|smartdns.xxxxxxxx.mipsel-optware-all.ipk|Support the MIPS little-endian architecture for optware。
-|ASUS native firmware (optware)|smartdns.xxxxxxx.arm.ipk|System that supports the ARM small endian architecture, such as the RT-AC88U, RT-AC68U.
+|optware|smartdns.xxxxxxxx.arm-optware-all.ipk|Support the arm architecture for optware。
-|Padavan|smartdns.xxxxxxx.mipselsf.ipk|padavan Firmware.
+|openwrt|smartdns.xxxxxxxx.mips-openwrt-all.ipk|Support the MIPS big-endian architecture for openwrt。
-|openwrt 15.01|smartdns.xxxxxxxx.ar71xx.ipk|Support AR71XX MIPS system.
+|openwrt|smartdns.xxxxxxxx.mipsel-openwrt-all.ipk|Support the MIPS little-endian architecture for openwrt。
-|openwrt 15.01|smartdns.xxxxxxxx.ramips_24kec.ipk|Support small-end routers such as MT762X
+|openwrt|smartdns.xxxxxxxx.arm-openwrt-all.ipk|Support the arm architecture for openwrt。
-|openwrt 15.01(Pandora)|smartdns.xxxxxxxx.mipsel_24kec_dsp.ipk|Support for Pandora firmware of MT7620 series
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all.ipk|Openwrt management interface.
-|openwrt 15.01(Pandora)|smartdns.xxxxxxxx.mips_74kc_dsp2.ipk|Support for Pandora firmware of AR71xx series
+|openwrt LUCI|luci-app-smartdns.xxxxxxxxx.all-luci-compat-all|Compat Openwrt management interface for early openwrt.
-|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
 
-* 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 released packages are statically compiled. If you need a small size package, please compile it yourself or obtain it from the openwrt / entware repository.
-* 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
-    ```
 
 * **Please download from the Release page: [Download here](https://github.com/pymu/smartdns/releases)**
 
@@ -204,16 +159,16 @@ https://github.com/pymumu/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
@@ -247,19 +202,19 @@ https://github.com/pymumu/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
 
 --------------
 
@@ -272,6 +227,8 @@ https://github.com/pymumu/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.
@@ -291,16 +248,16 @@ https://github.com/pymumu/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**
@@ -328,12 +285,12 @@ https://github.com/pymumu/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.
@@ -388,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
@@ -464,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.
@@ -488,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
@@ -521,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
@@ -563,12 +520,15 @@ Note: Merlin firmware is derived from ASUS firmware and can theoretically be use
 |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]
 
@@ -669,6 +629,10 @@ 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
 

etc/init.d/smartdns

@@ -34,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
@@ -57,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

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
@@ -22,6 +22,7 @@
 #   -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: 
 #    bind :53
@@ -43,6 +44,14 @@ 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]
 
@@ -97,7 +106,7 @@ log-level info
 # dns audit
 # audit-enable [yes|no]: enable or disable audit.
 # audit-enable yes
-# audit-SOA [yes|no]: enable or disalbe log soa result.
+# 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
@@ -156,3 +165,12 @@ log-level info
 # ipset /domain/[ipset|-]
 # 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

install

@@ -65,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
 }

package/build-pkg.sh

@@ -13,8 +13,8 @@ showhelp()
 {
 	echo "Usage: $0 [OPTION]"
 	echo "Options:"
-	echo " --platform [luci|debian|openwrt|optware|linux]    build for platform. "
+	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 " --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:"
@@ -26,8 +26,10 @@ showhelp()
 	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 "   $0 --platform debian --arch x86-64"
 	echo " build raspbian pi:"
 	echo "   $0 --platform debian --arch armhf"
 	echo " build optware mips:"
@@ -35,7 +37,7 @@ showhelp()
 	echo " build openwrt mips:"
 	echo "   $0 --platform openwrt --arch mips_24kc"
 	echo " build generic linux:"
-	echo "   $0 --platform linux --arch x86_64"
+	echo "   $0 --platform linux --arch x86-64"
 }
 
 build_smartdns()

package/luci-compat/control/control

@@ -0,0 +1,7 @@
+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
+Description:  A smartdns server

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 $@

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
+}

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 $@

package/luci-compat/debian-binary

@@ -0,0 +1 @@
+2.0

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

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 "捐助"

package/luci-compat/files/luci/model/cbi/smartdns/smartdns.lua

@@ -83,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"
@@ -119,8 +128,8 @@ o.rempty      = false
 
 ---- Port
 o = s:taboption("seconddns", Value, "seconddns_port", translate("Local Port"), translate("Smartdns local server port"))
-o.placeholder = 7053
+o.placeholder = 6553
-o.default     = 7053
+o.default     = 6553
 o.datatype    = "port"
 o.rempty      = false
 
@@ -132,13 +141,6 @@ o.cfgvalue    = function(...)
     return Flag.cfgvalue(...) or "1"
 end
 
-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
-
 ---- 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
@@ -146,6 +148,13 @@ 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
@@ -178,7 +187,7 @@ o.cfgvalue    = function(...)
     return Flag.cfgvalue(...) or "0"
 end
 
-o = s:taboption("seconddns", Flag, "seconddns_no_dualstack_selection", translate("Skip Dualstack Selection"), translate("Skip Sualstack Selection."))
+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(...)
@@ -193,6 +202,14 @@ 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(""), 
@@ -260,13 +277,14 @@ o:value("https", translate("https"))
 o.default     = "udp"
 o.rempty      = false
 
--- Doman addresss
+s = m:section(TypedSection, "smartdns", translate("Advanced Settings"), translate("Advanced Settings"));
-s = m:section(TypedSection, "smartdns", translate("Domain Address"), 
+s.anonymous = true;
-	translate("Set Specific domain ip address."))
-s.anonymous = true
 
----- address
+s:tab("domain-address", translate("Domain Address"), translate("Set Specific domain ip address."));
-addr = s:option(Value, "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."))
 
@@ -283,12 +301,7 @@ function addr.write(self, section, value)
 end
 
 -- IP Blacklist
-s = m:section(TypedSection, "smartdns", translate("IP Blacklist"), 
+addr = s:taboption("blackip-list", Value, "blacklist_ip",
-	translate("Set Specific ip blacklist."))
-s.anonymous = true
-
----- blacklist
-addr = s:option(Value, "blacklist_ip",
 	translate(""), 
 	translate("Configure IP blacklists that will be filtered from the results of specific DNS server."))
 
@@ -304,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

package/luci-compat/files/luci/model/cbi/smartdns/upstream.lua

@@ -55,6 +55,21 @@ o:value("https", translate("https"))
 o.default     = "udp"
 o.rempty      = false
 
+---- server group
+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"
+o.rempty      = true
+
+---- blacklist_ip
+o = s:option(Flag, "blacklist_ip", translate("IP Blacklist Filtering"), translate("Filtering IP with blacklist"))
+o.rmempty     = false
+o.default     = o.disabled
+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     = ""
@@ -78,21 +93,6 @@ 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 office, home."))
-o.rmempty     = true
-o.placeholder = "default"
-o.datatype    = "hostname"
-o.rempty      = true
-
----- blacklist_ip
-o = s:option(Flag, "blacklist_ip", translate("IP Blacklist Filtering"), translate("Filtering IP with blacklist"))
-o.rmempty     = false
-o.default     = o.disabled
-o.cfgvalue    = function(...)
-    return Flag.cfgvalue(...) or "0"
-end
-
 ---- 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
@@ -110,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     = ""

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 $?
+
+

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

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);
+}

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;
+		}
+	}
+}

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

package/luci/control/control

@@ -4,5 +4,4 @@ Depends: libc, smartdns
 Source: feeds/luci/applications/luci-app-smartdns
 Section: luci
 Architecture: all
-Installed-Size: 1040
+Description:  A smartdns server
-Description:  A smartdns server module

package/luci/control/postinst-pkg

@@ -1,4 +0,0 @@
-[ -n "${IPKG_INSTROOT}" ] || {
-	(. /etc/uci-defaults/50_luci-smartdns) && rm -f /etc/uci-defaults/50_luci-smartdns
-	exit 0
-}

package/luci/files/luci/controller/smartdns.lua

@@ -15,7 +15,6 @@
 -- 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
@@ -23,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

package/luci/files/luci/htdocs/luci-static/resources/view/smartdns/smartdns.js

@@ -0,0 +1,485 @@
+/*************************************************************************
+ *
+ * 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 += "<span style=\"color:green;font-weight:bold\">SmartDNS - " + _("RUNNING") + "</span>";
+	} else {
+		renderHTML += "<span style=\"color:red;font-weight:bold\">SmartDNS - " + _("NOT RUNNING") + "</span>";
+		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 /><span style=\"color:red;font-weight:bold\">" + _("Dnsmasq Forwared To Smartdns Failure") + "</span>";
+		}
+	} 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 /><span style=\"color:red;font-weight:bold\">" + _("IPV4 53 Port Redirect Failure") + "</span>";
+			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 /><span style=\"color:red;font-weight:bold\">" + _("IPV6 53 Port Redirect Failure") + "</span>";
+				}
+			}
+		}
+	}
+
+	return renderHTML;
+}
+
+return L.view.extend({
+	load: function () {
+		return Promise.all([
+			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;
+
+		// Domain prefetch load ;
+		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();
+	}
+});
+

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 "重定向"
 
@@ -157,7 +178,7 @@ msgstr "跳过address SOA(#)规则。"
 msgid "Skip Dualstack Selection"
 msgstr "跳过双栈优选"
 
-msgid "Skip Sualstack Selection."
+msgid "Skip Dualstack Selection."
 msgstr "跳过双栈优选。"
 
 msgid "Skip Cache"
@@ -166,6 +187,12 @@ msgstr "跳过cache"
 msgid "Skip Cache."
 msgstr "跳过cache。"
 
+msgid "Force AAAA SOA"
+msgstr "停用IPV6地址解析"
+
+msgid "Force AAAA SOA."
+msgstr "停用IPV6地址解析。"
+
 msgid "Upstream Servers"
 msgstr "上游服务器"
 
@@ -215,7 +242,7 @@ msgid "Server Group"
 msgstr "服务器组"
 
 msgid "DNS Server group belongs to, used with nameserver, such as office, home."
-msgsr "DNS服务器所属组， 配合nameserver使用，例如：office，home。"
+msgstr "DNS服务器所属组， 配合nameserver使用，例如：office，home。"
 
 msgid "IP Blacklist Filtering"
 msgstr "IP黑名单过滤"
@@ -276,7 +303,3 @@ msgstr "捐助smartdns项目"
 
 msgid "Donate"
 msgstr "捐助"
-
-
-
-

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" ]
+			}
+		}
+	}
+}

package/luci/make.sh

@@ -52,14 +52,22 @@ build()
 	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 $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
+
+	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
 
 	#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
+	cp $ROOT/files/usr $ROOT/root/ -avf
 	INST_SIZE="`du -sb $ROOT/root/ | awk '{print $1}'`"
 	
 	sed -i "s/^Architecture.*/Architecture: all/g" $ROOT/control/control
@@ -75,7 +83,7 @@ build()
 	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
+	tar zcf $OUTPUTDIR/luci-app-smartdns.$VER.$FILEARCH.ipk ./control.tar.gz ./data.tar.gz ./debian-binary
 
 	rm -fr $ROOT/
 }

package/openwrt/Makefile

@@ -1,58 +1,42 @@
 #
-# Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+# Copyright (c) 2018-2019 Nick Peng (pymumu@gmail.com)
+# This is free software, licensed under the GNU General Public License v3.
 #
-# 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 $(TOPDIR)/rules.mk
 
 PKG_NAME:=smartdns
+PKG_VERSION:=1.2019.28
+PKG_RELEASE:=1
 
 PKG_SOURCE_PROTO:=git
-PKG_SOURCE_URL:=https://github.com/pymumu/smartdns.git
+PKG_SOURCE_URL:=https://www.github.com/pymumu/smartdns.git
+PKG_SOURCE_VERSION:=982002e836e486fb4e360bc10e84e7e7197caf46
+PKG_MIRROR_HASH:=ae889b521ecf114660ce5597af5c361f5970a7dcb75dadf61b938ba3d2baba54
 
-PKG_REV:=d51f5e6eeba7bfde1b108fe32d540bd429550573
+PKG_MAINTAINER:=Nick Peng <pymumu@gmail.com>
-PKG_VERSION:=1.2019.11.02-1102
+PKG_LICENSE:=GPL-3.0-or-later
-PKG_RELEASE:=1
+PKG_LICENSE_FILES:=LICENSE
-PKG_LICENSE:=GPL-3.0
 
-PKG_SOURCE_VERSION:=$(PKG_REV)
+PKG_BUILD_PARALLEL:=1
-PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
-PKG_SOURCE:=$(PKG_SOURCE_SUBDIR).tar.gz
-PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_SOURCE_SUBDIR)
 
 include $(INCLUDE_DIR)/package.mk
 
-MAKE_ARGS := CFLAGS="$(TARGET_CFLAGS)" CC=$(TARGET_CC)
+MAKE_VARS += VER=$(PKG_VERSION) 
+MAKE_PATH:=src
 
 define Package/smartdns
   SECTION:=net
   CATEGORY:=Network
   TITLE:=smartdns server
-  URL:=http://github.com/pymumu/smartdns/
+  DEPENDS:=+libpthread +libopenssl
-  MAINTAINER:=Nick Peng <pymumu@gmail.com>
+  URL:=https://www.github.com/pymumu/smartdns/
-  DEPENDS:=+libopenssl
 endef
 
 define Package/smartdns/description
-SmartDNS is a local DNS server. SmartDNS accepts DNS query requests from local clients, obtains DNS query results from multiple upstream DNS servers, and returns the fastest access results to clients.
+SmartDNS is a local DNS server which accepts DNS query requests from local network clients,
-endef
+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. 
-define Build/Configure
-	mkdir -p $(PKG_INSTALL_DIR)
-endef
-
-define Build/Compile
-	$(MAKE) -C $(PKG_BUILD_DIR)/src $(MAKE_ARGS) all
 endef
 
 define Package/smartdns/conffiles

package/openwrt/files/etc/init.d/smartdns

@@ -22,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"
@@ -37,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`"
+	OLD_SERVER="$(uci get dhcp.@dnsmasq[0].server 2>/dev/null)"
-	echo $OLD_SERVER | grep "^$addr" >/dev/null 2>&1
+	if echo "$OLD_SERVER" | grep "^$addr" >/dev/null 2>&1; then
-	if [ $? -eq 0 ]; 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
+		[ "$server" = "$addr" ] && continue
-			continue
+		uci add_list dhcp.@dnsmasq[0].server="$server"
-		fi
-		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
@@ -60,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`"
+	OLD_SERVER="$(uci get dhcp.@dnsmasq[0].server 2>/dev/null)"
-	echo $OLD_SERVER | grep "^$addr" >/dev/null 2>&1
+	if echo "$OLD_SERVER" | grep "^$addr" >/dev/null 2>&1; then
-	if [ $? -ne 0 ]; then
 		return
 	fi
 
-	uci del_list dhcp.@dnsmasq[0].server=$addr 2>/dev/null
+	uci del_list dhcp.@dnsmasq[0].server="$addr" 2>/dev/null
-	addrlist="`uci get dhcp.@dnsmasq[0].server 2>/dev/null`"
+	addrlist="$(uci get dhcp.@dnsmasq[0].server 2>/dev/null)"
-	if [ -z "$addrlist" ] ; then
+	[ -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
 }
@@ -81,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
+		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
+			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
+	[ "$ipv6_server" = 0 ] && return
-		return
-	fi
 
-	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
+		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
+			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
 
 }
@@ -109,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 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 tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$OLD_PORT" >/dev/null 2>&1
 	done
 
-	if [ "$ipv6_server" == 0 ]; then
+	[ "$ipv6_server" = 0 ] && return
-		return
-	fi
 
-	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 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 tcp -d "$IP" --dport 53 -j REDIRECT --to-ports "$OLD_PORT" >/dev/null 2>&1
 	done
 
 }
@@ -144,22 +135,15 @@ get_tz()
 {
 	SET_TZ=""
 
-	if [ -e "/etc/localtime" ]; then
+	[ -e "/etc/localtime" ] && return
-		return 
-	fi
 
 	for tzfile in /etc/TZ /var/etc/TZ
 	do
-		if [ ! -e "$tzfile" ]; then
+		[ -e "$tzfile" ] || continue
-			continue
+		tz="$(cat $tzfile 2>/dev/null)"
-		fi
-		
-		tz="`cat $tzfile 2>/dev/null`"
 	done
 
-	if [ -z "$tz" ]; then
+	[ -z "$tz" ] && return
-		return	
-	fi
 
 	SET_TZ=$tz
 }
@@ -170,22 +154,20 @@ load_server()
 	local ADDITIONAL_ARGS=""
 	local DNS_ADDRESS=""
 
-	config_get_bool "enabled" "$section" "enabled" "1"
+	config_get_bool enabled "$section" "enabled" "1"
-	config_get "port" "$section" "port" ""
+	config_get port "$section" "port" ""
-	config_get "type" "$section" "type" "udp"
+	config_get type "$section" "type" "udp"
-	config_get "ip" "$section" "ip" ""
+	config_get ip "$section" "ip" ""
-	config_get "tls_host_verify" "$section" "tls_host_verify" ""
+	config_get tls_host_verify "$section" "tls_host_verify" ""
-	config_get "host_name" "$section" "host_name" ""
+	config_get host_name "$section" "host_name" ""
-	config_get "http_host" "$section" "http_host" ""
+	config_get http_host "$section" "http_host" ""
-	config_get "server_group" "$section" "server_group" ""
+	config_get server_group "$section" "server_group" ""
-	config_get "blacklist_ip" "$section" "blacklist_ip" "0"
+	config_get blacklist_ip "$section" "blacklist_ip" "0"
-	config_get "check_edns" "$section" "check_edns" "0"
+	config_get check_edns "$section" "check_edns" "0"
-	config_get "spki_pin" "$section" "spki_pin" ""
+	config_get spki_pin "$section" "spki_pin" ""
-	config_get "addition_arg" "$section" "addition_arg" ""
+	config_get addition_arg "$section" "addition_arg" ""
 
-	if [ "$enabled" = "0" ]; then
+	[ "$enabled" = "0" ] && return
-		return
-	fi
 
 	if [ -z "$ip" ] || [ -z "$type" ]; then
 		return
@@ -200,49 +182,27 @@ load_server()
 		SERVER="server-https"
 	fi
 
-	if [ ! -z "`echo $ip | grep ":" | grep -v "https://"`" ]; then
+	if echo "$ip" | grep ":" | grep -q -v "https://" >/dev/null 2>&1; then
-		if [ -z "`echo $ip | grep "\["`" ]; then
+		if ! echo "$ip" | grep -q "\\[" >/dev/null 2>&1; then
 			ip="[$ip]"
 		fi
 	fi
 
-	if [ ! -z "$tls_host_verify" ]; then
+	[ -z "$tls_host_verify" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -tls-host-verify $tls_host_verify"
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -tls-host-verify $tls_host_verify"
+	[ -z "$host_name" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -host-name $host_name"
-	fi
+	[ -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 "$host_name" ]; then
+	if [ -z "$port" ]; then
-		ADDITIONAL_ARGS="$ADDITIONAL_ARGS -host-name $host_name"
+		DNS_ADDRESS="$ip"
-	fi
-
-	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"
 	else
-		DNS_ADDRESS="$ip"
+		DNS_ADDRESS="$ip:$port"
 	fi
 
-	if [ "$type" = "https" ]; then
+	[ "$type" = "https" ] && DNS_ADDRESS="$ip"
-		DNS_ADDRESS="$ip"
-	fi
 
 	conf_append "$SERVER" "$DNS_ADDRESS $ADDITIONAL_ARGS $addition_arg"
 }
@@ -253,54 +213,39 @@ load_second_server()
 	local ARGS=""
 	local ADDR=""
 
-	config_get_bool "seconddns_enabled" "$section" "seconddns_enabled" "0"
+	config_get_bool seconddns_enabled "$section" "seconddns_enabled" "0"
-	if [ "$seconddns_enabled" = "0" ]; then
+	[ "$seconddns_enabled" = "0" ] && return
-		return
-	fi
 
-	config_get "seconddns_port" "$section" "seconddns_port" "7053"
+	config_get seconddns_port "$section" "seconddns_port" "6553"
 
-	config_get_bool "seconddns_no_speed_check" "$section" "seconddns_no_speed_check" "0"
+	config_get_bool seconddns_no_speed_check "$section" "seconddns_no_speed_check" "0"
-	if [ "$seconddns_no_speed_check" = "1" ]; then
+	[ "$seconddns_no_speed_check" = "1" ] && ARGS="$ARGS -no-speed-check"
-		ARGS="$ARGS -no-speed-check"
-	fi
 
-	config_get "seconddns_server_group" "$section" "seconddns_server_group" ""
+	config_get seconddns_server_group "$section" "seconddns_server_group" ""
-	if [ ! -z "$seconddns_server_group" ]; then
+	[ -z "$seconddns_server_group" ] || ARGS="$ARGS -group $seconddns_server_group"
-		ARGS="$ARGS -group $seconddns_server_group"
-	fi
 
-	config_get_bool "seconddns_no_rule_addr" "$section" "seconddns_no_rule_addr" "0"
+	config_get_bool seconddns_no_rule_addr "$section" "seconddns_no_rule_addr" "0"
-	if [ "$seconddns_no_rule_addr" = "1" ]; then
+	[ "$seconddns_no_rule_addr" = "1" ] && ARGS="$ARGS -no-rule-addr"
-		ARGS="$ARGS -no-rule-addr"
-	fi
 
-	config_get_bool "seconddns_no_rule_nameserver" "$section" "seconddns_no_rule_nameserver" "0"
+	config_get_bool seconddns_no_rule_nameserver "$section" "seconddns_no_rule_nameserver" "0"
-	if [ "$seconddns_no_rule_nameserver" = "1" ]; then
+	[ "$seconddns_no_rule_nameserver" = "1" ] && ARGS="$ARGS -no-rule-nameserver"
-		ARGS="$ARGS -no-rule-nameserver"
-	fi
 
-	config_get_bool "seconddns_no_rule_ipset" "$section" "seconddns_no_rule_ipset" "0"
+	config_get_bool seconddns_no_rule_ipset "$section" "seconddns_no_rule_ipset" "0"
-	if [ "$seconddns_no_rule_ipset" = "1" ]; then
+	[ "$seconddns_no_rule_ipset" = "1" ] && ARGS="$ARGS -no-rule-ipset"
-		ARGS="$ARGS -no-rule-ipset"
-	fi
 
-	config_get_bool "seconddns_no_rule_soa" "$section" "seconddns_no_rule_soa" "0"
+	config_get_bool seconddns_no_rule_soa "$section" "seconddns_no_rule_soa" "0"
-	if [ "$seconddns_no_rule_soa" = "1" ]; then
+	[ "$seconddns_no_rule_soa" = "1" ] && ARGS="$ARGS -no-rule-soa"
-		ARGS="$ARGS -no-rule-soa"
-	fi
 
-	config_get_bool "seconddns_no_dualstack_selection" "$section" "seconddns_no_dualstack_selection" "0"
+	config_get_bool seconddns_no_dualstack_selection "$section" "seconddns_no_dualstack_selection" "0"
-	if [ "$seconddns_no_dualstack_selection" = "1" ]; then
+	[ "$seconddns_no_dualstack_selection" = "1" ] && ARGS="$ARGS -no-dualstack-selection"
-		ARGS="$ARGS -no-dualstack-selection"
-	fi
 
-	config_get_bool "seconddns_no_cache" "$section" "seconddns_no_cache" "0"
+	config_get_bool seconddns_no_cache "$section" "seconddns_no_cache" "0"
-	if [ "$seconddns_no_cache" = "1" ]; then
+	[ "$seconddns_no_cache" = "1" ] && ARGS="$ARGS -no-cache"
-		ARGS="$ARGS -no-cache"
-	fi
 
-	config_get "ipv6_server" "$section" "ipv6_server" "1"
+	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
@@ -309,9 +254,7 @@ load_second_server()
 
 	conf_append "bind" "$ADDR:$seconddns_port $ARGS"
 	config_get_bool "seconddns_tcp_server" "$section" "seconddns_tcp_server" "1"
-	if [ "$seconddns_tcp_server" = "1" ]; then
+	[ "$seconddns_tcp_server" = "1" ] && conf_append "bind-tcp" "$ADDR:$seconddns_port $ARGS"
-		conf_append "bind-tcp" "$ADDR:$seconddns_port $ARGS"
-	fi
 }
 
 load_service()
@@ -322,100 +265,75 @@ load_service()
 	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" ""
+	config_get server_name "$section" "server_name" ""
-	if [ ! -z "$server_name" ]; then
+	[ -z "$server_name" ] || conf_append "server-name" "$server_name"
-		conf_append "server-name" "$server_name"	
-	fi
 
-	config_get "coredump" "$section" "coredump" "0"
+	config_get coredump "$section" "coredump" "0"
-	if [ "$coredump" = "1" ]; then
+	[ "$coredump" = "1" ] && COREDUMP="1"
-		COREDUMP="1"
-	fi
 
-	config_get "port" "$section" "port" "6053"
+	config_get port "$section" "port" "6053"
-	config_get "ipv6_server" "$section" "ipv6_server" "1"
+	config_get ipv6_server "$section" "ipv6_server" "1"
-	config_get "tcp_server" "$section" "tcp_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"
+	config_get dualstack_ip_selection "$section" "dualstack_ip_selection" "0"
-	if [ "$dualstack_ip_selection" = "1" ]; then
+	[ "$dualstack_ip_selection" = "1" ] && conf_append "dualstack-ip-selection" "yes"
-		conf_append "dualstack-ip-selection" "yes"
-	fi
 
-	config_get "prefetch_domain" "$section" "prefetch_domain" "0"
+	config_get prefetch_domain "$section" "prefetch_domain" "0"
-	if [ "$prefetch_domain" = "1" ]; then
+	[ "$prefetch_domain" = "1" ] && conf_append "prefetch-domain" "yes"
-		conf_append "prefetch-domain" "yes"
+
-	fi
+	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" ""
+	config_get cache_size "$section" "cache_size" ""
-	if [ ! -z "$cache_size" ]; then
+	[ -z "$cache_size" ] || conf_append "cache-size" "$cache_size"
-		conf_append "cache-size" "$cache_size"
-	fi
 
-	config_get "rr_ttl" "$section" "rr_ttl" ""
+	config_get rr_ttl "$section" "rr_ttl" ""
-	if [ ! -z "$rr_ttl" ]; then
+	[ -z "$rr_ttl" ] || conf_append "rr-ttl" "$rr_ttl"
-		conf_append "rr-ttl" "$rr_ttl"
-	fi
 
-	config_get "rr_ttl_min" "$section" "rr_ttl_min" ""
+	config_get rr_ttl_min "$section" "rr_ttl_min" ""
-	if [ ! -z "$rr_ttl_min" ]; then
+	[ -z "$rr_ttl_min" ] || conf_append "rr-ttl-min" "$rr_ttl_min"
-		conf_append "rr-ttl-min" "$rr_ttl_min"
-	fi
 
-	config_get "rr_ttl_max" "$section" "rr_ttl_max" ""
+	config_get rr_ttl_max "$section" "rr_ttl_max" ""
-	if [ ! -z "$rr_ttl_max" ]; then
+	[ -z "$rr_ttl_max" ] || conf_append "rr-ttl-max" "$rr_ttl_max"
-		conf_append "rr-ttl-max" "$rr_ttl_max"
-	fi
 
-	config_get "log_size" "$section" "log_size" "64K"
+	config_get log_size "$section" "log_size" "64K"
-	if [ ! -z "$log_size" ]; then
+	[ -z "$log_size" ] || conf_append "log-size" "$log_size"
-		conf_append "log-size" "$log_size"
-	fi
 
-	config_get "log_num" "$section" "log_num" "1"
+	config_get log_num "$section" "log_num" "1"
-	if [ ! -z "$log_num" ]; then
+	[ -z "$log_num" ] || conf_append "log-num" "$log_num"
-		conf_append "log-num" "$log_num"
-	fi
 
-	config_get "log_level" "$section" "log_level" "error"
+	config_get log_level "$section" "log_level" "error"
-	if [ ! -z "$log_level" ]; then
+	[ -z "$log_level" ]|| conf_append "log-level" "$log_level"
-		conf_append "log-level" "$log_level"
-	fi
 
-	config_get "log_file" "$section" "log_file" ""
+	config_get log_file "$section" "log_file" ""
-	if [ ! -z "$log_file" ]; then
+	[ -z "$log_file" ] || conf_append "log-file" "$log_file"
-		conf_append "log-file" "$log_file"
-	fi
 
-	config_get "redirect" "$section" "redirect" "none"
+	config_get redirect "$section" "redirect" "none"
-	config_get "old_redirect" "$section" "old_redirect" "none"
+	config_get old_redirect "$section" "old_redirect" "none"
-	config_get "old_port" "$section" "old_port" "0"
+	config_get old_port "$section" "old_port" "0"
-	config_get "old_enabled" "$section" "old_enabled" "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
+		[ "$old_redirect" = "none" ] || {
-			if [ "$old_port" != "0" ]; then
+			[ "$old_port" = "0" ] || clear_iptable "$old_port" "$ipv6_server"
-				clear_iptable "$old_port" "$ipv6_server"
+			[ "$old_redirect" = "dnsmasq-upstream" ] && stop_forward_dnsmasq "$old_port"
-			fi
+		}
-			if [ "$old_redirect" == "dnsmasq-upstream" ]; then
-				stop_forward_dnsmasq "$old_port"
-			fi
-		fi
 	fi
 
 	uci delete smartdns.@smartdns[0].old_redirect 2>/dev/null
@@ -438,26 +356,24 @@ load_service()
 
 	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 $ADDRESS_CONF"
-	echo "conf-file $CUSTOM_CONF" >> $SMARTDNS_CONF_TMP
+		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
-	if [ ! -z "$SET_TZ" ]; then
+	[ -z "$SET_TZ" ] || procd_set_param env TZ="$SET_TZ"
-		procd_set_param env TZ="$SET_TZ"
-	fi
 
 	procd_set_param command /usr/sbin/smartdns -f -c $SMARTDNS_CONF $args
-	if [ "$RESPAWN" = "1" ]; then
+	[ "$RESPAWN" = "1" ] &&	procd_set_param respawn ${respawn_threshold:-3600} ${respawn_timeout:-5} ${respawn_retry:-5}
-		procd_set_param respawn ${respawn_threshold:-3600} ${respawn_timeout:-5} ${respawn_retry:-5}
-	fi
 	procd_set_param file "$SMARTDNS_CONF"
 	procd_close_instance
 }

package/optware/S50smartdns

@@ -43,56 +43,56 @@ 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 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 udp -d "$IP" --dport 53 -j REDIRECT --to-ports "$SMARTDNS_PORT" > /dev/null 2>&1
 	done
 	
 }
 
 get_dnsmasq_cmd()
 {
-	CMD="`ps | grep -e '[a-zA-Z]\{0,2\} \{1,\}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 | grep '/usr/sbin/dnsmasq' | grep -v grep 2>/dev/null`"
+	CMD="$(ps 2>/dev/null | grep '/usr/sbin/dnsmasq' | grep -v grep 2>/dev/null)"
 	if [ ! -z "$CMD" ]; then
 		return
 	fi
 
-	CMD="`ps | grep 'dnsmasq' | grep -v grep 2>/dev/null`"
+	CMD="$(ps 2>/dev/null | grep 'dnsmasq' | grep -v grep 2>/dev/null)"
 	if [ ! -z "$CMD" ]; then
 		return
 	fi
 
-	CMD="`ps ax | grep -e '[a-zA-Z]\{0,2\} \{1,\}dnsmasq' | grep -v grep 2>/dev/null`"
+	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 | grep /usr/sbin/dnsmasq | grep -v grep 2>/dev/null`"
+	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 | grep 'dnsmasq' | grep -v grep 2>/dev/null`"
+	CMD="$(ps ax 2>/dev/null | grep 'dnsmasq' | grep -v grep 2>/dev/null)"
 	if [ ! -z "$CMD" ]; then
 		return
 	fi	
@@ -108,15 +108,15 @@ restart_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
 }
@@ -124,21 +124,20 @@ restart_dnsmasq()
 get_server_ip()
 {
 	CONF_FILE=$1
-	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}')"
-	LOCAL_SERVER_IP=""
 	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\".\"}"`
+			ADDR="$(echo "$IP" | awk -F. "{for(i=1;i<="$N";i++)printf \$i\".\"}")"
-			grep "dhcp-range=" $CONF_FILE | grep $ADDR >/dev/null 2>&1
+			grep "dhcp-range=" "$CONF_FILE" | grep "$ADDR" >/dev/null 2>&1
 			if [ $? -eq 0 ]; then
-					SERVER_TAG="`grep "^dhcp-range *=" $CONF_FILE | 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
 
@@ -152,19 +151,20 @@ set_dnsmasq_conf()
 	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
+		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" $CONF_FILE
+			sed -i "/^dhcp-option *=$SERVER_TAG,6,/d" "$CONF_FILE"
-			echo "dhcp-option=$SERVER_TAG,6,$LOCAL_SERVER_IP" >> $CONF_FILE
+			echo "dhcp-option=$SERVER_TAG,6,$LOCAL_SERVER_IP" >> "$CONF_FILE"
 			RESTART_DNSMASQ=1
 		fi
 	fi
 
-	grep "^port *=0" $CONF_FILE > /dev/null 2>&1
+	grep "^port *=0" "$CONF_FILE" > /dev/null 2>&1
 	if [ $? -ne 0 ]; then
-		sed -i "/^port *=/d" $CONF_FILE
+		sed -i "/^port *=/d" "$CONF_FILE"
-		echo "port=0" >> $CONF_FILE
+		echo "port=0" >> "$CONF_FILE"
 		RESTART_DNSMASQ=1
 	fi
 }
@@ -179,7 +179,7 @@ set_dnsmasq()
 			continue
 		fi
 
-		set_dnsmasq_conf $conf
+		set_dnsmasq_conf "$conf"
 	done
 	
 	if [ $RESTART_DNSMASQ -ne 0 ]; then
@@ -193,18 +193,18 @@ clear_dnsmasq_conf()
 	local SERVER_TAG=""
 	local CONF_FILE=$1
 	
-	get_server_ip $CONF_FILE
+	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
+		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
+			sed -i "/^dhcp-option *=$SERVER_TAG,6,/d" "$CONF_FILE"
 			RESTART_DNSMASQ=1
 		fi
 	fi
 
-	grep "^port *=" $CONF_FILE > /dev/null 2>&1
+	grep "^port *=" "$CONF_FILE" > /dev/null 2>&1
 	if [ $? -eq 0 ]; then
-		sed -i "/^port *=/d" $CONF_FILE
+		sed -i "/^port *=/d" "$CONF_FILE"
 		RESTART_DNSMASQ=1
 	fi
 }
@@ -219,7 +219,7 @@ clear_dnsmasq()
 			continue
 		fi
 
-		clear_dnsmasq_conf $conf
+		clear_dnsmasq_conf "$conf"
 	done
 
 	if [ $RESTART_DNSMASQ -ne 0 ]; then
@@ -232,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 .*\\):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-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 .*\\):$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-tcp .*\\):$SMARTDNS_PORT *\\(.*\\)\$/\\1:53 \\2/g" $SMARTDNS_CONF
 	else
 		return 1
 	fi	
@@ -286,7 +286,7 @@ get_tz()
 			continue
 		fi
 		
-		tz="`cat $tzfile 2>/dev/null`"
+		tz="$(cat $tzfile 2>/dev/null)"
 	done
 	
 	if [ -z "$tz" ]; then
@@ -311,7 +311,7 @@ case "$1" in
 	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
@@ -326,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
@@ -336,7 +336,7 @@ case "$1" in
 		return 0;
 	fi
 
-	kill -9 $pid 2>/dev/null
+	kill -9 "$pid" 2>/dev/null
 	;;
 	restart)
 	$0 stop

src/Makefile

@@ -17,18 +17,25 @@
 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
+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 
 override CXXFLAGS +=-Iinclude
+
+# ldflags
 ifeq ($(STATIC), yes)
-LDFLAGS += -lssl -lcrypto -Wl,--whole-archive -lpthread -Wl,--no-whole-archive -ldl -static
+override LDFLAGS += -lssl -lcrypto -Wl,--whole-archive -lpthread -Wl,--no-whole-archive -ldl -static
 else
-LDFLAGS += -lssl -lcrypto -lpthread 
+override LDFLAGS += -lssl -lcrypto -lpthread 
 endif
 
 .PHONY: all

src/dns_cache.c

@@ -28,19 +28,25 @@
 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);
 
@@ -49,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);
 }
 
@@ -92,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;
@@ -136,13 +162,16 @@ int dns_cache_replace(char *domain, char *cname, int cname_ttl, int ttl, dns_typ
 		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);
 	}
@@ -263,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 {
@@ -328,6 +357,27 @@ void dns_cache_update(struct dns_cache *dns_cache)
 	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;
@@ -356,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)
@@ -376,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);

src/dns_cache.h

@@ -55,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);
 

src/dns_client.c

@@ -136,6 +136,7 @@ struct dns_server_pending_group {
 
 struct dns_server_pending {
 	struct list_head list;
+	atomic_t refcnt;
 
 	char host[DNS_HOSTNAME_LEN];
 	char ipv4[DNS_HOSTNAME_LEN];
@@ -879,7 +880,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;
 	}
@@ -961,6 +961,49 @@ static int _dns_client_server_remove(char *server_ip, int port, dns_server_type_
 	return -1;
 }
 
+void _dns_client_server_pending_get(struct dns_server_pending *pending)
+{
+	if (atomic_inc_return(&pending->refcnt) <= 0) {
+		tlog(TLOG_ERROR, "BUG: pending ref is invalid");
+		abort();
+	}
+}
+
+void _dns_client_server_pending_release_lck(struct dns_server_pending *pending)
+{
+	int refcnt = atomic_dec_return(&pending->refcnt);
+
+	if (refcnt) {
+		if (refcnt < 0) {
+			tlog(TLOG_ERROR, "BUG: pending refcnt is %d", refcnt);
+			abort();
+		}
+		return;
+	}
+
+	list_del_init(&pending->list);
+	free(pending);
+}
+
+void _dns_client_server_pending_release(struct dns_server_pending *pending)
+{
+	int refcnt = atomic_dec_return(&pending->refcnt);
+
+	if (refcnt) {
+		if (refcnt < 0) {
+			tlog(TLOG_ERROR, "BUG: pending refcnt is %d", refcnt);
+			abort();
+		}
+		return;
+	}
+
+	pthread_mutex_lock(&pending_server_mutex);
+	list_del_init(&pending->list);
+	pthread_mutex_unlock(&pending_server_mutex);
+
+	free(pending);
+}
+
 static int _dns_client_server_pending(char *server_ip, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags)
 {
 	struct dns_server_pending *pending = NULL;
@@ -981,6 +1024,7 @@ static int _dns_client_server_pending(char *server_ip, int port, dns_server_type
 	pending->ipv6[0] = 0;
 	pending->has_v4 = 0;
 	pending->has_v6 = 0;
+	_dns_client_server_pending_get(pending);
 	INIT_LIST_HEAD(&pending->group_list);
 	memcpy(&pending->flags, flags, sizeof(struct client_dns_server_flags));
 
@@ -1474,11 +1518,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));
-	setsockopt(fd, IPPROTO_TCP, TCP_THIN_DUPACK, &yes, sizeof(yes));
-	setsockopt(fd, IPPROTO_TCP, TCP_THIN_LINEAR_TIMEOUTS, &yes, sizeof(yes));
 
 	if (connect(fd, (struct sockaddr *)&server_info->addr, server_info->ai_addrlen) != 0) {
 		if (errno != EINPROGRESS) {
@@ -1822,6 +1866,10 @@ static int _dns_client_process_tcp_buff(struct dns_server_info *server_info)
 		}
 
 		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) {
@@ -1880,7 +1928,7 @@ 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;
 		}
@@ -1917,6 +1965,9 @@ static int _dns_client_process_tcp(struct dns_server_info *server_info, struct e
 			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);
 		}
@@ -1930,7 +1981,7 @@ 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;
 		}
 	}
@@ -1987,6 +2038,8 @@ static int _dns_client_tls_matchName(const char *host, const char *pattern, int
 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;
@@ -2007,7 +2060,17 @@ 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 */
@@ -2019,8 +2082,14 @@ static int _dns_client_tls_verify(struct dns_server_info *server_info)
 		}
 	}
 
+	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;
@@ -2033,7 +2102,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);
@@ -2056,7 +2125,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);
@@ -2111,7 +2180,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;
 			}
 
@@ -2147,7 +2216,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;
 		}
 	}
@@ -2294,7 +2363,7 @@ static int _dns_client_send_tls(struct dns_server_info *server_info, void *packe
 			/* 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) {
@@ -2344,7 +2413,7 @@ static int _dns_client_send_https(struct dns_server_info *server_info, void *pac
 			/* 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) {
@@ -2589,6 +2658,7 @@ static void _dns_client_check_servers(void)
 static int _dns_client_pending_server_resolve(char *domain, dns_rtcode_t rtcode, dns_type_t addr_type, char *ip, unsigned int ping_time, void *user_ptr)
 {
 	struct dns_server_pending *pending = user_ptr;
+	int ret = 0;
 
 	if (addr_type == DNS_T_A) {
 		pending->has_v4 = 1;
@@ -2605,10 +2675,11 @@ static int _dns_client_pending_server_resolve(char *domain, dns_rtcode_t rtcode,
 			safe_strncpy(pending->ipv6, ip, DNS_HOSTNAME_LEN);
 		}
 	} else {
-		return -1;
+		ret = -1;
 	}
 
-	return 0;
+	_dns_client_server_pending_release(pending);
+	return ret;
 }
 
 static int _dns_client_add_pendings(struct dns_server_pending *pending, char *ip)
@@ -2648,11 +2719,15 @@ static void _dns_client_add_pending_servers(void)
 		/* send dns type A, AAAA query to bootstrap DNS server */
 		if (pending->query_v4 == 0) {
 			pending->query_v4 = 1;
-			dns_server_query(pending->host, DNS_T_A, _dns_client_pending_server_resolve, pending);
+			_dns_client_server_pending_get(pending);
+			if (dns_server_query(pending->host, DNS_T_A, _dns_client_pending_server_resolve, pending) != 0) {
+				_dns_client_server_pending_release_lck(pending);
+			}
 		}
 
 		if (pending->query_v6 == 0) {
 			pending->query_v6 = 1;
+			_dns_client_server_pending_get(pending);
 			dns_server_query(pending->host, DNS_T_AAAA, _dns_client_pending_server_resolve, pending);
 		}
 
@@ -2670,8 +2745,8 @@ static void _dns_client_add_pending_servers(void)
 					tlog(TLOG_WARN, "add pending DNS server %s failed.", pending->host);
 				}
 			}
-			list_del_init(&pending->list);
+
-			free(pending);
+			_dns_client_server_pending_release_lck(pending);
 		}
 
 		/* if has no bootstrap DNS, just call getaddrinfo to get address */
@@ -2682,8 +2757,8 @@ static void _dns_client_add_pending_servers(void)
 				exit(1);
 				return;
 			}
-			list_del_init(&pending->list);
+			
-			free(pending);
+			_dns_client_server_pending_release_lck(pending);
 		}
 	}
 	pthread_mutex_unlock(&pending_server_mutex);

src/dns_conf.c

@@ -48,6 +48,8 @@ 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];
@@ -58,6 +60,7 @@ 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;
@@ -94,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)
 {
@@ -523,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_IPSET_NAMELEN];
 	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 */
-		safe_strncpy(ipsetname, end + 1, DNS_MAX_IPSET_NAMELEN);
 		ipset = _dns_conf_get_ipset(ipsetname);
 		if (ipset == NULL) {
 			goto errout;
@@ -605,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) {
+	if (*(domain_address) == '#') {
-		goto errout;
+		if (strncmp(domain_address, "#4", sizeof("#4")) == 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 >= 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) {
 			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;
@@ -676,12 +659,12 @@ static int _config_address(void *data, int argc, char *argv[])
 		}
 
 		return 0;
-	} else if (*(end + 1) == '-') {
+	} else if (*(domain_address) == '-') {
-		if (strncmp(end + 1, "-4", sizeof("-4")) == 0) {
+		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;
@@ -695,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;
 		}
 
@@ -753,28 +736,45 @@ 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(void *data, int argc, char *argv[])
+static int _config_speed_check_mode_parser(struct dns_domain_check_order *check_order, const char *mode)
 {
-	char mode[DNS_MAX_OPT_LEN];
+	char tmpbuff[DNS_MAX_OPT_LEN];
 	char *field;
 	char *ptr;
 	int order = 0;
 	int port = 80;
 	int i = 0;
 
-	if (argc <= 1) {
+	safe_strncpy(tmpbuff, mode, DNS_MAX_OPT_LEN);
-		return -1;
+	memset(check_order, 0, sizeof(*check_order));
-	}
 
-	safe_strncpy(mode, argv[1], sizeof(mode));
+	ptr = tmpbuff;
-	ptr = mode;
 	do {
 		field = ptr;
-		ptr = strstr(mode, ",");
+		ptr = strstr(ptr, ",");
 		if (field == NULL || order >= DOMAIN_CHECK_NUM) {
 			return 0;
 		}
@@ -784,7 +784,13 @@ static int _config_speed_check_mode(void *data, int argc, char *argv[])
 		}
 
 		if (strncmp(field, "ping", sizeof("ping")) == 0) {
-			dns_conf_check_order.order[order] = DOMAIN_CHECK_ICMP;
+			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) {
@@ -794,12 +800,12 @@ static int _config_speed_check_mode(void *data, int argc, char *argv[])
 				}
 			}
 
-			dns_conf_check_order.order[order] = DOMAIN_CHECK_TCP;
+			check_order->order[order] = DOMAIN_CHECK_TCP;
-			dns_conf_check_order.tcp_port = port;
+			check_order->tcp_port = port;
 		} else if (strncmp(field, "none", sizeof("none")) == 0) {
-			dns_conf_check_order.order[order] = DOMAIN_CHECK_NONE;
+			check_order->order[order] = DOMAIN_CHECK_NONE;
 			for (i = order + 1; i < DOMAIN_CHECK_NUM; i++) {
-				dns_conf_check_order.order[i] = DOMAIN_CHECK_NONE;
+				check_order->order[i] = DOMAIN_CHECK_NONE;
 			}
 
 			return 0;
@@ -809,11 +815,23 @@ static int _config_speed_check_mode(void *data, int argc, char *argv[])
 			ptr++;
 		}
 
-	} while (1);
+	} 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;
@@ -835,6 +853,7 @@ static int _config_bind_ip(int argc, char *argv[], DNS_BIND_TYPE type)
 		{"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 */
@@ -900,6 +919,10 @@ static int _config_bind_ip(int argc, char *argv[], DNS_BIND_TYPE type)
 			server_flag |= BIND_FLAG_NO_DUALSTACK_SELECTION;
 			break;
 		}
+		case 'F': {
+			server_flag |= BIND_FLAG_FORCE_AAAA_SOA;
+			break;
+		}
 		default:
 			break;
 		}
@@ -950,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) {
+	if (strncmp(group_name, "-", sizeof("-")) != 0) {
-		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) {
-		safe_strncpy(group_name, end + 1, DNS_GROUP_NAME_LEN);
 		group = _dns_conf_get_group_name(group_name);
 		if (group == NULL) {
 			goto errout;
@@ -1030,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;
 }
@@ -1188,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 */
@@ -1228,6 +1347,8 @@ static struct config_item _config_item[] = {
 	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),
@@ -1248,6 +1369,7 @@ static struct config_item _config_item[] = {
 	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(),
 };
@@ -1321,9 +1443,9 @@ void dns_server_load_exit(void)
 static int _dns_conf_speed_check_mode_verify(void)
 {
 	int i, j;
-	int has_cap = has_network_raw_cap();
 	int print_log = 0;
-	if (has_cap == 1) {
+
+	if (dns_has_cap_ping == 1) {
 		return 0;
 	}
 
@@ -1344,16 +1466,31 @@ static int _dns_conf_speed_check_mode_verify(void)
 	return 0;
 }
 
+static int _dns_conf_load_pre(void)
+{
+	if (_dns_server_load_conf_init() != 0) {
+		goto errout;
+	}
+
+	dns_has_cap_ping = has_network_raw_cap();
+
+	return 0;
+
+errout:
+	return -1;
+}
+
 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;
-	_dns_server_load_conf_init();
+	_dns_conf_load_pre();
 	openlog("smartdns", LOG_CONS | LOG_NDELAY, LOG_LOCAL1);
 	ret = load_conf(file, _config_item, _conf_printf);
 	closelog();

src/dns_conf.h

@@ -56,6 +56,7 @@ enum domain_rule {
 	DOMAIN_RULE_ADDRESS_IPV6,
 	DOMAIN_RULE_IPSET,
 	DOMAIN_RULE_NAMESERVER,
+	DOMAIN_RULE_CHECKSPEED,
 	DOMAIN_RULE_MAX,
 };
 
@@ -89,6 +90,7 @@ typedef enum {
 #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;
@@ -199,6 +201,8 @@ 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;
 

src/dns_server.c

@@ -183,6 +183,7 @@ struct dns_request {
 	int has_soa;
 
 	atomic_t notified;
+	atomic_t do_callback;
 	atomic_t adblock;
 	atomic_t soa_num;
 
@@ -205,6 +206,8 @@ static struct dns_server server;
 
 static tlog_log *dns_audit;
 
+static int _dns_server_prefetch_request(char *domain, dns_type_t qtype);
+
 static int _dns_server_forward_request(unsigned char *inpacket, int inpacket_len)
 {
 	tlog(TLOG_DEBUG, "forward request.\n");
@@ -259,8 +262,10 @@ static int _dns_server_is_return_soa(struct dns_request *request)
 		return 0;
 	}
 
-	if (dns_conf_force_AAAA_SOA == 1 && request->qtype == DNS_T_AAAA) {
+	if (request->qtype == DNS_T_AAAA) {
-		return 1;
+		if (_dns_server_has_bind_flag(request, BIND_FLAG_FORCE_AAAA_SOA) == 0 || dns_conf_force_AAAA_SOA == 1) {
+			return 1;
+		}
 	}
 
 	rule_flag = request->domain_rule.rules[DOMAIN_RULE_FLAGS];
@@ -548,6 +553,20 @@ static int _dns_reply(struct dns_request *request)
 	return _dns_reply_inpacket(request, inpacket, encode_len);
 }
 
+static int _dns_result_callback_nxdomain(struct dns_request *request)
+{
+	char ip[DNS_MAX_CNAME_LEN];
+	unsigned int ping_time = -1;
+
+
+	ip[0] = 0;
+	if (request->result_callback == NULL) {
+		return 0;
+	}
+
+	return request->result_callback(request->domain, DNS_RC_NXDOMAIN, request->qtype, ip, ping_time, request->user_ptr);
+}
+
 static int _dns_result_callback(struct dns_request *request)
 {
 	char ip[DNS_MAX_CNAME_LEN];
@@ -557,6 +576,10 @@ static int _dns_result_callback(struct dns_request *request)
 		return 0;
 	}
 
+	if (atomic_inc_return(&request->do_callback) != 1) {
+		return 0;
+	}
+
 	ip[0] = 0;
 	if (request->qtype == DNS_T_A) {
 		if (request->has_ipv4 == 0) {
@@ -579,12 +602,12 @@ static int _dns_result_callback(struct dns_request *request)
 		return request->result_callback(request->domain, request->rcode, request->qtype, ip, ping_time, request->user_ptr);
 	}
 
-	request->result_callback(request->domain, DNS_RC_NXDOMAIN, request->qtype, ip, ping_time, request->user_ptr);
+	_dns_result_callback_nxdomain(request);
 
 	return 0;
 out:
 
-	request->result_callback(request->domain, DNS_RC_NXDOMAIN, request->qtype, ip, ping_time, request->user_ptr);
+	_dns_result_callback_nxdomain(request);
 	return 0;
 }
 
@@ -956,6 +979,8 @@ static struct dns_request *_dns_server_new_request(void)
 	atomic_set(&request->adblock, 0);
 	atomic_set(&request->soa_num, 0);
 	atomic_set(&request->refcnt, 0);
+	atomic_set(&request->notified, 0);
+	atomic_set(&request->do_callback, 0);
 	request->ping_ttl_v4 = -1;
 	request->ping_ttl_v6 = -1;
 	request->prefetch = 0;
@@ -1617,6 +1642,7 @@ static int dns_server_resolve_callback(char *domain, dns_result_type rtype, unsi
 
 		/* Not need to wait check result if only has one ip address */
 		if (ip_num == 1 && request_wait == 1) {
+			request->has_ping_result = 1;
 			_dns_server_request_complete(request);
 			_dns_server_request_remove(request);
 		}
@@ -1688,6 +1714,11 @@ static int _dns_server_process_ptr(struct dns_request *request)
 		found = 1;
 	}
 
+	/* Determine if the smartdns service is in effect. */
+	if (found == 0 && strncmp(request->domain, "smartdns", sizeof("smartdns")) == 0) {
+		found = 1;
+	}
+
 	if (found == 0) {
 		goto errout;
 	}
@@ -1930,6 +1961,19 @@ errout:
 	return -1;
 }
 
+static void _dns_server_prolcess_speed_check_rule(struct dns_request *request)
+{
+	struct dns_domain_check_order *check_order = NULL;
+
+	/* get domain rule flag */
+	check_order = request->domain_rule.rules[DOMAIN_RULE_CHECKSPEED];
+	if (check_order == NULL) {
+		return;
+	}
+
+	request->check_order_list = check_order;
+}
+
 static int _dns_server_process_cache(struct dns_request *request)
 {
 	struct dns_cache *dns_cache = NULL;
@@ -1941,6 +1985,15 @@ static int _dns_server_process_cache(struct dns_request *request)
 
 	dns_cache = dns_cache_lookup(request->domain, request->qtype);
 	if (dns_cache == NULL) {
+		if (request->dualstack_selection && request->qtype == DNS_T_AAAA) {
+			dns_cache_A = dns_cache_lookup(request->domain, DNS_T_A);
+			if (dns_cache_A) {
+				tlog(TLOG_DEBUG, "No IPV6 Found, Force IPV4 perfered.");
+				dns_cache_release(dns_cache_A);
+				dns_cache_release(dns_cache);
+				return _dns_server_reply_SOA(DNS_RC_NOERROR, request);
+			}
+		}
 		goto errout;
 	}
 
@@ -1991,7 +2044,11 @@ static int _dns_server_process_cache(struct dns_request *request)
 		_dns_reply(request);
 	}
 
-	dns_cache_update(dns_cache);
+	if (dns_cache_get_ttl(dns_cache) == 0) {
+		_dns_server_prefetch_request(request->domain, request->qtype);
+	} else {
+		dns_cache_update(dns_cache);
+	}
 	dns_cache_release(dns_cache);
 
 	if (dns_cache_A) {
@@ -2104,6 +2161,17 @@ static const char *_dns_server_get_request_groupname(struct dns_request *request
 	return NULL;
 }
 
+static void _dns_server_check_set_passthrough(struct dns_request *request)
+{
+	if (request->check_order_list->order[0] == DOMAIN_CHECK_NONE) {
+		request->passthrough = 1;
+	}
+
+	if (_dns_server_has_bind_flag(request, BIND_FLAG_NO_SPEED_CHECK) == 0) {
+		request->passthrough = 1;
+	}
+}
+
 static int _dns_server_do_query(struct dns_request *request, const char *domain, int qtype)
 {
 	int ret = -1;
@@ -2138,6 +2206,12 @@ static int _dns_server_do_query(struct dns_request *request, const char *domain,
 		goto clean_exit;
 	}
 
+	/* process speed check rule */
+	_dns_server_prolcess_speed_check_rule(request);
+
+	/* check and set passthrough */
+	_dns_server_check_set_passthrough(request);
+
 	/* process cache */
 	if (request->prefetch == 0) {
 		if (_dns_server_process_cache(request) == 0) {
@@ -2181,17 +2255,6 @@ errout:
 	return ret;
 }
 
-static void _dns_server_check_set_passthrough(struct dns_request *request, struct dns_server_conn_head *conn)
-{
-	if (request->check_order_list->order[0] == DOMAIN_CHECK_NONE) {
-		request->passthrough = 1;
-	}
-
-	if (_dns_server_has_bind_flag(request, BIND_FLAG_NO_SPEED_CHECK) == 0) {
-		request->passthrough = 1;
-	}
-}
-
 static int _dns_server_recv(struct dns_server_conn_head *conn, unsigned char *inpacket, int inpacket_len, struct sockaddr_storage *local, socklen_t local_len,
 							struct sockaddr_storage *from, socklen_t from_len)
 {
@@ -2249,7 +2312,6 @@ static int _dns_server_recv(struct dns_server_conn_head *conn, unsigned char *in
 
 	memcpy(&request->localaddr, local, local_len);
 	_dns_server_request_set_client(request, conn);
-	_dns_server_check_set_passthrough(request, conn);
 	_dns_server_request_set_client_addr(request, from, from_len);
 	_dns_server_request_set_id(request, packet->head.id);
 	_dns_server_set_dualstack_selection(request);
@@ -2315,7 +2377,7 @@ int dns_server_query(char *domain, int qtype, dns_result_callback callback, void
 		goto errout;
 	}
 
-	_dns_server_request_release_complete(request, 0);
+	_dns_server_request_release_complete(request, 1);
 	return ret;
 errout:
 	if (request) {
@@ -2496,7 +2558,7 @@ static int _dns_server_tcp_process_one_request(struct dns_server_conn_tcp_client
 			return RECV_ERROR_FAIL;
 		}
 
-		if (request_len > (total_len - proceed_len)) {
+		if (request_len > (total_len - proceed_len - sizeof(unsigned short))) {
 			ret = RECV_ERROR_AGAIN;
 			break;
 		}
@@ -3113,7 +3175,7 @@ int dns_server_init(void)
 		return -1;
 	}
 
-	if (dns_cache_init(dns_conf_cachesize) != 0) {
+	if (dns_cache_init(dns_conf_cachesize, dns_conf_serve_expired, dns_conf_serve_expired_ttl) != 0) {
 		tlog(TLOG_ERROR, "init cache failed.");
 		return -1;
 	}
@@ -3193,3 +3255,4 @@ void dns_server_exit(void)
 
 	dns_cache_destroy();
 }
+

src/smartdns.c

@@ -222,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;
 }
 

src/util.c

@@ -687,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;
@@ -743,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

src/util.h

@@ -27,6 +27,10 @@
 extern "C" {
 #endif /*__cplusplus */
 
+#ifndef TCP_FASTOPEN
+#define TCP_FASTOPEN		 23 
+#endif
+
 #ifndef TCP_FASTOPEN_CONNECT
 #define TCP_FASTOPEN_CONNECT 30
 #endif