dns-client: fix add pending server issue when AAAA record not exists

fix  Download/default is missing the FILE field..  Stop. error on openwrt

.clang-format

@@ -1,9 +1,10 @@
-#http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+#http://clang.llvm.org/docs/ClangFormatStyleOptions.html
-
+
-BasedOnStyle: LLVM
+BasedOnStyle: LLVM
-IndentWidth: 4
+IndentWidth: 4
-TabWidth: 4
+TabWidth: 4
-UseTab: ForContinuationAndIndentation
+UseTab: ForContinuationAndIndentation
-MaxEmptyLinesToKeep: 1
+MaxEmptyLinesToKeep: 1
-AllowShortFunctionsOnASingleLine: Empty
+AllowShortFunctionsOnASingleLine: Empty
-BreakBeforeBraces: Linux
+BreakBeforeBraces: Linux
+ColumnLimit: 120

.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>.

Makefile

@@ -0,0 +1,47 @@
+# 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/>.
+
+PKG_CONFIG := pkg-config
+DESTDIR :=
+PREFIX := /usr
+SBINDIR := $(PREFIX)/sbin
+SYSCONFDIR := /etc
+RUNSTATEDIR := /var/run
+SYSTEMDSYSTEMUNITDIR := $(shell ${PKG_CONFIG} --variable=systemdsystemunitdir systemd)
+SMARTDNS_SYSTEMD = systemd/smartdns.service
+
+.PHONY: all clean install SMARTDNS_BIN
+all: SMARTDNS_BIN 
+
+SMARTDNS_BIN: $(SMARTDNS_SYSTEMD)
+	$(MAKE) $(MFLAGS) -C src all 
+
+$(SMARTDNS_SYSTEMD): systemd/smartdns.service.in
+	cp $< $@
+	sed -i 's|@SBINDIR@|$(SBINDIR)|' $@
+	sed -i 's|@SYSCONFDIR@|$(SYSCONFDIR)|' $@
+	sed -i 's|@RUNSTATEDIR@|$(RUNSTATEDIR)|' $@
+
+clean:
+	$(MAKE) $(MFLAGS) -C src clean  
+	$(RM) $(SMARTDNS_SYSTEMD)
+
+install: SMARTDNS_BIN 
+	install -v -m 0640 -D -t $(DESTDIR)$(SYSCONFDIR)/default etc/default/smartdns
+	install -v -m 0755 -D -t $(DESTDIR)$(SYSCONFDIR)/init.d etc/init.d/smartdns
+	install -v -m 0640 -D -t $(DESTDIR)$(SYSCONFDIR)/smartdns etc/smartdns/smartdns.conf
+	install -v -m 0755 -D -t $(DESTDIR)$(SBINDIR) src/smartdns
+	install -v -m 0644 -D -t $(DESTDIR)$(SYSTEMDSYSTEMUNITDIR) systemd/smartdns.service
+

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,12 +106,20 @@ 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
 # audit-num 2
 
+# certificate file
+# ca-file [file]
+# ca-file /etc/ssl/certs/ca-certificates.crt
+
+# certificate path
+# ca-path [path]
+# ca-path /etc/ss/certs
+
 # remote udp dns server list
 # server [IP]:[PORT] [-blacklist-ip] [-whitelist-ip] [-check-edns] [-group [group] ...] [-exclude-default-group]
 # default port is 53
@@ -121,8 +138,9 @@ log-level info
 # remote tls dns server list
 # server-tls [IP]:[PORT] [-blacklist-ip] [-whitelist-ip] [-spki-pin [sha256-pin]] [-group [group] ...] [-exclude-default-group]
 #   -spki-pin: TLS spki pin to verify.
-#   -tls-host-check: cert hostname to verify.
+#   -tls-host-verify: cert hostname to verify.
-#   -hostname: TLS sni hostname.
+#   -host-name: TLS sni hostname.
+#   -no-check-certificate: no check certificate.
 # Get SPKI with this command:
 #    echo | openssl s_client -connect '[ip]:853' | openssl x509 -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | openssl enc -base64
 # default port is 853
@@ -132,9 +150,10 @@ log-level info
 # remote https dns server list
 # server-https https://[host]:[port]/path [-blacklist-ip] [-whitelist-ip] [-spki-pin [sha256-pin]] [-group [group] ...] [-exclude-default-group]
 #   -spki-pin: TLS spki pin to verify.
-#   -tls-host-check: cert hostname to verify.
+#   -tls-host-verify: cert hostname to verify.
-#   -hostname: TLS sni hostname.
+#   -host-name: TLS sni hostname.
 #   -http-host: http host.
+#   -no-check-certificate: no check certificate.
 # default port is 443
 # server-https https://cloudflare-dns.com/dns-query
 
@@ -156,3 +175,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

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,14 +37,14 @@ 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()
 {
 	if [ "$PLATFORM" != "luci" ]; then
-		make -C $CODE_DIR/src clean 
+		make -C $CODE_DIR clean $MAKE_ARGS
-		make -C $CODE_DIR/src all -j8 VER=$VER $MAKE_ARGS
+		make -C $CODE_DIR all -j8 VER=$VER $MAKE_ARGS
 		if [ $? -ne 0 ]; then
 			echo "make smartdns failed"
 			exit 1

package/linux/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
 }
@@ -77,14 +77,18 @@ install_files()
 		return 1
 	fi
 
-	install -v -m 0755 -t $PREFIX/usr/sbin src/smartdns
+	install -v -m 0755 -t $PREFIX/usr/sbin usr/sbin/smartdns
 	if [ $? -ne 0 ]; then
 		return 1
 	fi
 
-	install -v -m 0640 -t  $PREFIX$SMARTDNS_CONF_DIR etc/smartdns/smartdns.conf
+	if [ -e "$PREFIX$SMARTDNS_CONF_DIR/smartdns.conf" ]; then
-	if [ $? -ne 0 ]; then
+		cp etc/smartdns/smartdns.conf $PREFIX$SMARTDNS_CONF_DIR/smartdns.conf.pkg
-		return 1
+	else 
+		install -v -m 0640 -t  $PREFIX$SMARTDNS_CONF_DIR etc/smartdns/smartdns.conf
+		if [ $? -ne 0 ]; then
+			return 1
+		fi
 	fi
 
 	install -v -m 0640 -t  $PREFIX/etc/default etc/default/smartdns
@@ -118,7 +122,6 @@ uninstall_smartdns()
 	if [ -z "$PREFIX" ]; then
 		stop_service 2>/dev/null
 	fi	
-	rm -f $PREFIX$SMARTDNS_CONF_DIR/smartdns.conf
 	rmdir $PREFIX$SMARTDNS_CONF_DIR 2>/dev/null
 	rm -f $PREFIX/usr/sbin/smartdns
 	rm -f $PREFIX/etc/default/smartdns

package/linux/make.sh

@@ -23,12 +23,17 @@ build()
 	cd $PKG_ROOT/
 
 	# Generic x86_64
-	mkdir $PKG_ROOT/smartdns/src -p
+	mkdir $PKG_ROOT/smartdns/usr/sbin -p
 	mkdir $PKG_ROOT/smartdns/package -p
+	mkdir $PKG_ROOT/smartdns/systemd -p 
+	
 	cd $SMARTDNS_DIR
 	cp package/windows $PKG_ROOT/smartdns/package/ -a
-	cp etc systemd *.md LICENSE install $PKG_ROOT/smartdns/ -a
+	cp etc *.md LICENSE package/linux/install $PKG_ROOT/smartdns/ -a
-	cp src/smartdns $PKG_ROOT/smartdns/src -a
+	cp systemd/smartdns.service $PKG_ROOT/smartdns/systemd
+	cp src/smartdns $PKG_ROOT/smartdns/usr/sbin -a
+	chmod +x $PKG_ROOT/smartdns/install
+
 	if [ $? -ne 0 ]; then
 		echo "copy smartdns file failed"
 		rm -fr $PKG_ROOT

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/i18n/smartdns.zh-cn.po

@@ -0,0 +1,299 @@
+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 "No check certificate"
+msgstr "停用证书校验"
+
+msgid "Do not check certificate."
+msgstr "不校验证书的合法性。"
+
+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     = ""
@@ -63,6 +78,16 @@ o.rempty      = true
 o:depends("type", "tls")
 o:depends("type", "https")
 
+---- certificate verify
+o = s:option(Flag, "no_check_certificate", translate("No check certificate"), translate("Do not check certificate."))
+o.rmempty     = false
+o.default     = o.disabled
+o.cfgvalue    = function(...)
+    return Flag.cfgvalue(...) or "0"
+end
+o:depends("type", "tls")
+o:depends("type", "https")
+
 ---- SNI host name
 o = s:option(Value, "host_name", translate("TLS SNI name"), translate("Sets the server name indication for query."))
 o.default     = ""
@@ -78,21 +103,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 +120,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/i18n/smartdns.zh-cn.po

@@ -1,282 +1,311 @@
-msgid ""
+msgid ""
-msgstr "Content-Type: text/plain; charset=UTF-8\n"
+msgstr "Content-Type: text/plain; charset=UTF-8\n"
-
+
-msgid "SmartDNS"
+msgid "SmartDNS"
-msgstr "SmartDNS"
+msgstr "SmartDNS"
-
+
-msgid "SmartDNS is a local high-performance DNS server"
+msgid "SmartDNS is a local high-performance DNS server"
-msgstr "SmartDNS是一个本地高性能DNS服务器"
+msgstr "SmartDNS是一个本地高性能DNS服务器"
-
+
-msgid "SmartDNS Server"
+msgid "SmartDNS Server"
-msgstr "SmartDNS 服务器"
+msgstr "SmartDNS 服务器"
-
+
-msgid "SmartDNS is a local high-performance DNS server, supports finding fastest IP, supports ad filtering, and supports avoiding DNS poisoning."
+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，支持广告过滤。"
+msgstr "SmartDNS是一个本地高性能DNS服务器，支持返回最快IP，支持广告过滤。"
-
+
-msgid "Custom Settings"
+msgid "Custom Settings"
-msgstr "自定义设置"
+msgstr "自定义设置"
-
+
-msgid "Generate Coredump"
+msgid "General Settings"
-msgstr "生成coredump"
+msgstr "基本设置"
-
+
-msgid "Generate Coredump file when smartdns crash, coredump file is located at /tmp/smartdns.xxx.core."
+msgid "Settings"
-msgstr "当smartdns异常时生成coredump文件，coredump文件在/tmp/smartdns.xxx.core."
+msgstr "设置"
-
+
-msgid "Server Name"
+msgid "Advanced Settings"
-msgstr "服务器名称"
+msgstr "高级设置"
-
+
-msgid "Smartdns server name"
+msgid "RUNNING"
-msgstr "SmartDNS的服务器名称，默认为smartdns，留空为主机名"
+msgstr "运行中"
-
+
-msgid "SmartDNS is a local dns server to find fastest ip."
+msgid "NOT RUNNING"
-msgstr "本地高性能服务器，优化网络访问性能。"
+msgstr "未运行"
-
+
-msgid "Enable or disable smartdns server"
+msgid "Generate Coredump"
-msgstr "启用或禁用SmartDNS服务"
+msgstr "生成coredump"
-
+
-msgid "Local Port"
+msgid "Generate Coredump file when smartdns crash, coredump file is located at /tmp/smartdns.xxx.core."
-msgstr "本地端口"
+msgstr "当smartdns异常时生成coredump文件，coredump文件在/tmp/smartdns.xxx.core."
-
+
-msgid "Smartdns local server port"
+msgid "Server Name"
-msgstr "SmartDNS本地服务端口"
+msgstr "服务器名称"
-
+
-msgid "IPV4 53 Port Redirect Failure"
+msgid "Smartdns server name"
-msgstr "IPV4 53端口重定向失败"
+msgstr "SmartDNS的服务器名称，默认为smartdns，留空为主机名"
-
+
-msgid "IPV6 53 Port Redirect Failure"
+msgid "SmartDNS is a local dns server to find fastest ip."
-msgstr "IPV6 53端口重定向失败"
+msgstr "本地高性能服务器，优化网络访问性能。"
-
+
-msgid "Dnsmasq Forwared To Smartdns Failure"
+msgid "Enable or disable smartdns server"
-msgstr "重定向dnsmasq到smartdns失败"
+msgstr "启用或禁用SmartDNS服务"
-
+
-msgid "TCP Server"
+msgid "Local Port"
-msgstr "TCP服务器"
+msgstr "本地端口"
-
+
-msgid "Enable TCP DNS Server"
+msgid "Smartdns local server port"
-msgstr "启用TCP服务器"
+msgstr "SmartDNS本地服务端口"
-
+
-msgid "IPV6 Server"
+msgid "IPV4 53 Port Redirect Failure"
-msgstr "IPV6服务器"
+msgstr "IPV4 53端口重定向失败"
-
+
-msgid "Enable IPV6 DNS Server"
+msgid "IPV6 53 Port Redirect Failure"
-msgstr "启用IPV6服务器"
+msgstr "IPV6 53端口重定向失败"
-
+
-msgid "Dual-stack IP Selection"
+msgid "Dnsmasq Forwared To Smartdns Failure"
-msgstr "双栈IP优选"
+msgstr "重定向dnsmasq到smartdns失败"
-
+
-msgid "Enable IP selection between IPV4 and IPV6"
+msgid "TCP Server"
-msgstr "启用或禁用IPV4，IPV6间的IP优选策略。"
+msgstr "TCP服务器"
-
+
-msgid "Domain prefetch"
+msgid "Enable TCP DNS Server"
-msgstr "域名预加载"
+msgstr "启用TCP服务器"
-
+
-msgid "Enable domain prefetch, accelerate domain response speed."
+msgid "IPV6 Server"
-msgstr "启用域名预加载，加速域名响应速度。"
+msgstr "IPV6服务器"
-
+
-msgid "Redirect"
+msgid "Enable IPV6 DNS Server"
-msgstr "重定向"
+msgstr "启用IPV6服务器"
-
+
-msgid "SmartDNS redirect mode"
+msgid "Dual-stack IP Selection"
-msgstr "SmartDNS 重定向模式"
+msgstr "双栈IP优选"
-
+
-msgid "Run as dnsmasq upstream server"
+msgid "Enable IP selection between IPV4 and IPV6"
-msgstr "作为dnsmasq的上游服务器"
+msgstr "启用或禁用IPV4，IPV6间的IP优选策略。"
-
+
-msgid "Redirect 53 port to SmartDNS"
+msgid "Domain prefetch"
-msgstr "重定向53端口到SmartDNS"
+msgstr "域名预加载"
-
+
-msgid "Cache Size"
+msgid "Enable domain prefetch, accelerate domain response speed."
-msgstr "缓存大小"
+msgstr "启用域名预加载，加速域名响应速度。"
-
+
-msgid "DNS domain result cache size"
+msgid "Serve expired"
-msgstr "缓存DNS的结果，缓存大小，配置零则不缓存"
+msgstr "缓存过期服务"
-
+
-msgid "Domain TTL"
+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"
+msgstr "查询性能优化，有请求时尝试回应TTL为0的过期记录，以避免查询等待。"
-
+
-msgid "TTL for all domain result."
+msgid "Redirect"
-msgstr "设置所有域名的TTL值"
+msgstr "重定向"
-
+
-msgid "Domain TTL Min"
+msgid "SmartDNS redirect mode"
-msgstr "域名TTL最小值"
+msgstr "SmartDNS 重定向模式"
-
+
-msgid "Minimum TTL for all domain result."
+msgid "Run as dnsmasq upstream server"
-msgstr "设置所有域名的TTL最小值"
+msgstr "作为dnsmasq的上游服务器"
-
+
-msgid "Domain TTL Max"
+msgid "Redirect 53 port to SmartDNS"
-msgstr "域名TTL最大值"
+msgstr "重定向53端口到SmartDNS"
-
+
-msgid "Maximum TTL for all domain result."
+msgid "Cache Size"
-msgstr "设置所有域名的TTL最大值"
+msgstr "缓存大小"
-
+
-msgid "smartdns custom settings"
+msgid "DNS domain result cache size"
-msgstr "smartdns 自定义设置，具体配置参数参考指导"
+msgstr "缓存DNS的结果，缓存大小，配置零则不缓存"
-
+
-msgid "Second Server Settings"
+msgid "Domain TTL"
-msgstr "第二DNS服务器"
+msgstr "域名TTL"
-
+
-msgid "Enable or disable second DNS server."
+msgid "TTL for all domain result."
-msgstr "是否启用第二DNS服务器。"
+msgstr "设置所有域名的TTL值"
-
+
-msgid "Skip Speed Check"
+msgid "Domain TTL Min"
-msgstr "跳过测速"
+msgstr "域名TTL最小值"
-
+
-msgid "Do not check speed."
+msgid "Minimum TTL for all domain result."
-msgstr "禁用测速。"
+msgstr "设置所有域名的TTL最小值"
-
+
-msgid "Server Group"
+msgid "Domain TTL Max"
-msgstr "服务器组"
+msgstr "域名TTL最大值"
-
+
-msgid "Query DNS through specific dns server group, such as office, home."
+msgid "Maximum TTL for all domain result."
-msgstr "使用指定服务器组查询，比如office, home。"
+msgstr "设置所有域名的TTL最大值"
-
+
-msgid "Skip Address Rules"
+msgid "smartdns custom settings"
-msgstr "跳过address规则"
+msgstr "smartdns 自定义设置，具体配置参数参考指导"
-
+
-msgid "Skip address rules."
+msgid "Second Server Settings"
-msgstr "跳过address规则。"
+msgstr "第二DNS服务器"
-
+
-msgid "Skip Nameserver Rule"
+msgid "Enable or disable second DNS server."
-msgstr "跳过Nameserver规则"
+msgstr "是否启用第二DNS服务器。"
-
+
-msgid "Skip nameserver rules."
+msgid "Skip Speed Check"
-msgstr "跳过Nameserver规则。"
+msgstr "跳过测速"
-
+
-msgid "Skip Ipset Rule"
+msgid "Do not check speed."
-msgstr "跳过ipset规则"
+msgstr "禁用测速。"
-
+
-msgid "Skip ipset rules."
+msgid "Server Group"
-msgstr "跳过ipset规则。"
+msgstr "服务器组"
-
+
-msgid "Skip SOA Address Rule"
+msgid "Query DNS through specific dns server group, such as office, home."
-msgstr "跳过address SOA(#)规则"
+msgstr "使用指定服务器组查询，比如office, home。"
-
+
-msgid "Skip SOA address rules."
+msgid "Skip Address Rules"
-msgstr "跳过address SOA(#)规则。"
+msgstr "跳过address规则"
-
+
-msgid "Skip Dualstack Selection"
+msgid "Skip address rules."
-msgstr "跳过双栈优选"
+msgstr "跳过address规则。"
-
+
-msgid "Skip Sualstack Selection."
+msgid "Skip Nameserver Rule"
-msgstr "跳过双栈优选。"
+msgstr "跳过Nameserver规则"
-
+
-msgid "Skip Cache"
+msgid "Skip nameserver rules."
-msgstr "跳过cache"
+msgstr "跳过Nameserver规则。"
-
+
-msgid "Skip Cache."
+msgid "Skip Ipset Rule"
-msgstr "跳过cache。"
+msgstr "跳过ipset规则"
-
+
-msgid "Upstream Servers"
+msgid "Skip ipset rules."
-msgstr "上游服务器"
+msgstr "跳过ipset规则。"
-
+
-msgid "Upstream Servers, support UDP, TCP protocol. Please configure multiple DNS servers, including multiple foreign DNS servers."
+msgid "Skip SOA Address Rule"
-msgstr "上游DNS服务器列表，支持UDP，TCP协议，请配置多个上游DNS服务器，包括多个国内外服务器"
+msgstr "跳过address SOA(#)规则"
-
+
-msgid "DNS Server Name"
+msgid "Skip SOA address rules."
-msgstr "DNS服务器名称"
+msgstr "跳过address SOA(#)规则。"
-
+
-msgid "port"
+msgid "Skip Dualstack Selection"
-msgstr "端口"
+msgstr "跳过双栈优选"
-
+
-msgid "DNS Server port"
+msgid "Skip Dualstack Selection."
-msgstr "DNS服务器端口"
+msgstr "跳过双栈优选。"
-
+
-msgid "DNS Server ip"
+msgid "Skip Cache"
-msgstr "DNS服务器IP"
+msgstr "跳过cache"
-
+
-msgid "type"
+msgid "Skip Cache."
-msgstr "类型"
+msgstr "跳过cache。"
-
+
-msgid "DNS Server type"
+msgid "Force AAAA SOA"
-msgstr "协议类型"
+msgstr "停用IPV6地址解析"
-
+
-msgid "Domain Address"
+msgid "Force AAAA SOA."
-msgstr "域名地址"
+msgstr "停用IPV6地址解析。"
-
+
-msgid "TLS Hostname Verify"
+msgid "Upstream Servers"
-msgstr "校验TLS主机名"
+msgstr "上游服务器"
-
+
-msgid "Set TLS hostname to verify."
+msgid "Upstream Servers, support UDP, TCP protocol. Please configure multiple DNS servers, including multiple foreign DNS servers."
-msgstr "设置校验TLS主机名。"
+msgstr "上游DNS服务器列表，支持UDP，TCP协议，请配置多个上游DNS服务器，包括多个国内外服务器"
-
+
-msgid "TLS SNI name"
+msgid "DNS Server Name"
-msgstr "TLS SNI名称"
+msgstr "DNS服务器名称"
-
+
-msgid "HTTP Host"
+msgid "port"
-msgstr "HTTP主机"
+msgstr "端口"
-
+
-msgid "Sets the server name indication for query."
+msgid "DNS Server port"
-msgstr "设置查询时使用的服务器SNI名称。"
+msgstr "DNS服务器端口"
-
+
-msgid "Set the HTTP host used for the query. Use this parameter when the host of the URL address is an IP address."
+msgid "DNS Server ip"
-msgstr "设置查询时使用的HTTP主机，当URL地址的host是IP地址时，使用此参数。"
+msgstr "DNS服务器IP"
-
+
-msgid "Server Group"
+msgid "type"
-msgstr "服务器组"
+msgstr "类型"
-
+
-msgid "DNS Server group belongs to, used with nameserver, such as office, home."
+msgid "DNS Server type"
-msgsr "DNS服务器所属组， 配合nameserver使用，例如：office，home。"
+msgstr "协议类型"
-
+
-msgid "IP Blacklist Filtering"
+msgid "Domain Address"
-msgstr "IP黑名单过滤"
+msgstr "域名地址"
-
+
-msgid "Anti Answer Forgery"
+msgid "TLS Hostname Verify"
-msgstr "反回答伪造"
+msgstr "校验TLS主机名"
-
+
-msgid "Anti answer forgery, if DNS does not work properly after enabling, please turn off this feature"
+msgid "Set TLS hostname to verify."
-msgstr "反回答伪造，如果启用后DNS工作不正常，请关闭此功能。"
+msgstr "设置校验TLS主机名。"
-
+
-msgid "Filtering IP with blacklist"
+msgid "No check certificate"
-msgstr "使用IP黑名单过滤"
+msgstr "停用证书校验"
-
+
-msgid "TLS SPKI Pinning"
+msgid "Do not check certificate."
-msgstr "TLS SPKI 指纹"
+msgstr "不校验证书的合法性。"
-
+
-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."
+msgid "TLS SNI name"
-msgstr "用于校验TLS服务器的有效性，数值为Base64编码的SPKI指纹, 留空表示不验证TLS的合法性"
+msgstr "TLS SNI名称"
-
+
-msgid "Additional Server Args"
+msgid "HTTP Host"
-msgstr "额外的服务器参数"
+msgstr "HTTP主机"
-
+
-msgid "Additional Args for upstream dns servers"
+msgid "Sets the server name indication for query."
-msgstr "额外的上游DNS服务器参数"
+msgstr "设置查询时使用的服务器SNI名称。"
-
+
-msgid "Upstream DNS Server Configuration"
+msgid "Set the HTTP host used for the query. Use this parameter when the host of the URL address is an IP address."
-msgstr "上游DNS服务器配置"
+msgstr "设置查询时使用的HTTP主机，当URL地址的host是IP地址时，使用此参数。"
-
+
-msgid "Set Specific domain ip address."
+msgid "Server Group"
-msgstr "指定特定域名的IP地址"
+msgstr "服务器组"
-
+
-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."
+msgid "DNS Server group belongs to, used with nameserver, such as office, home."
-msgstr "配置特定域名返回特定的IP地址，域名查询将不到上游服务器请求，直接返回配置的IP地址，可用于广告屏蔽。"
+msgstr "DNS服务器所属组， 配合nameserver使用，例如：office，home。"
-
+
-msgid "IP Blacklist"
+msgid "IP Blacklist Filtering"
-msgstr "IP黑名单"
+msgstr "IP黑名单过滤"
-
+
-msgid "Set Specific ip blacklist."
+msgid "Anti Answer Forgery"
-msgstr "设置IP黑名单列表"
+msgstr "反回答伪造"
-
+
-msgid "Configure IP blacklists that will be filtered from the results of specific DNS server."
+msgid "Anti answer forgery, if DNS does not work properly after enabling, please turn off this feature"
-msgstr "配置需要从指定域名服务器结果过滤的IP黑名单。"
+msgstr "反回答伪造，如果启用后DNS工作不正常，请关闭此功能。"
-
+
-msgid "Technical Support"
+msgid "Filtering IP with blacklist"
-msgstr "技术支持"
+msgstr "使用IP黑名单过滤"
-
+
-msgid "If you like this software, please buy me a cup of coffee."
+msgid "TLS SPKI Pinning"
-msgstr "如果本软件对你有帮助，请给作者加个蛋。"
+msgstr "TLS SPKI 指纹"
-
+
-msgid "SmartDNS official website"
+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 "SmartDNS官方网站"
+msgstr "用于校验TLS服务器的有效性，数值为Base64编码的SPKI指纹, 留空表示不验证TLS的合法性"
-
+
-msgid "open website"
+msgid "Additional Server Args"
-msgstr "打开网站"
+msgstr "额外的服务器参数"
-
+
-msgid "Donate to smartdns"
+msgid "Additional Args for upstream dns servers"
-msgstr "捐助smartdns项目"
+msgstr "额外的上游DNS服务器参数"
-
+
-msgid "Donate"
+msgid "Upstream DNS Server Configuration"
-msgstr "捐助"
+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/files/root/usr/share/luci/menu.d/luci-app-smartdns.json

@@ -0,0 +1,12 @@
+{
+	"admin/services/smartdns": {
+		"title": "SmartDNS",
+		"action": {
+			"type": "view",
+			"path": "smartdns/smartdns"
+		},
+		"depends": {
+			"uci": { "smartdns": true }
+		}
+	}
+}

package/luci/files/root/usr/share/rpcd/acl.d/luci-app-smartdns.json

@@ -0,0 +1,23 @@
+{
+	"luci-app-smartdns": {
+		"description": "Grant access to LuCI app smartdns",
+		"read": {
+			"file": {
+				"/etc/smartdns/*": [ "read" ],
+				"/usr/sbin/iptables -t nat -nL PREROUTING": [ "exec" ],
+				"/usr/sbin/ip6tables -t nat -nL PREROUTING": [ "exec" ],
+				"/usr/sbin/smartdns": [ "exec" ]
+			},
+			"ubus": {
+				"service": [ "list" ]
+			},
+			"uci": [ "smartdns" ]
+		},
+		"write": {
+			"file": {
+				"/etc/smartdns/*": [ "write" ]
+			},
+			"uci": [ "smartdns" ]
+		}
+	}
+}

package/luci/files/root/www/luci-static/resources/view/smartdns/smartdns.js

@@ -0,0 +1,492 @@
+/*************************************************************************
+ *
+ * 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")
+
+		// certificate verify
+		o = s.taboption("advanced", form.Flag, "no_check_certificate", _("No check certificate"),
+			_("Do not check certificate."))
+		o.rmempty = false
+		o.default = o.disabled
+		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/make.sh

@@ -52,14 +52,16 @@ 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 -p
+	mkdir $ROOT/root/usr/share/rpcd/acl.d/ -p
+	cp $ROOT/files/luci/i18n $ROOT/root/usr/lib/lua/luci/ -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/root/* $ROOT/root/ -avf
 	INST_SIZE="`du -sb $ROOT/root/ | awk '{print $1}'`"
 	
 	sed -i "s/^Architecture.*/Architecture: all/g" $ROOT/control/control
@@ -75,7 +77,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,45 @@
 #
-# 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:=$(PKG_NAME)-$(PKG_VERSION).tar.xz
+PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
 
 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/address.conf

@@ -1,16 +1,16 @@
-# Add domains which you want to force to an IP address here.
+# Add domains which you want to force to an IP address here.
-# The example below send any host in example.com to a local webserver.
+# The example below send any host in example.com to a local webserver.
-# address /domain/[ip|-|-4|-6|#|#4|#6]
+# address /domain/[ip|-|-4|-6|#|#4|#6]
-# address /www.example.com/1.2.3.4, return ip 1.2.3.4 to client
+# address /www.example.com/1.2.3.4, return ip 1.2.3.4 to client
-# address /www.example.com/-, ignore address, query from upstream, suffix 4, for ipv4, 6 for ipv6, none for all
+# address /www.example.com/-, ignore address, query from upstream, suffix 4, for ipv4, 6 for ipv6, none for all
-# address /www.example.com/#, return SOA to client, suffix 4, for ipv4, 6 for ipv6, none for all
+# address /www.example.com/#, return SOA to client, suffix 4, for ipv4, 6 for ipv6, none for all
-
+
-# specific ipset to domain
+# specific ipset to domain
-# ipset /domain/[ipset|-]
+# ipset /domain/[ipset|-]
-# ipset /www.example.com/block, set ipset with ipset name of block 
+# ipset /www.example.com/block, set ipset with ipset name of block 
-# ipset /www.example.com/-, ignore this domain
+# ipset /www.example.com/-, ignore this domain
-
+
-# specific nameserver to domain
+# specific nameserver to domain
-# nameserver /domain/[group|-]
+# nameserver /domain/[group|-]
-# nameserver /www.example.com/office, Set the domain name to use the appropriate server group.
+# nameserver /www.example.com/office, Set the domain name to use the appropriate server group.
-# nameserver /www.example.com/-, ignore this domain
+# nameserver /www.example.com/-, ignore this domain

package/openwrt/blacklist-ip.conf

@@ -1,4 +1,4 @@
-# Add IP blacklist which you want to filtering from some DNS server here.
+# Add IP blacklist which you want to filtering from some DNS server here.
-# The example below filtering ip from the result of DNS server which is configured with -blacklist-ip.
+# The example below filtering ip from the result of DNS server which is configured with -blacklist-ip.
-# blacklist-ip [ip/subnet]
+# blacklist-ip [ip/subnet]
 # blacklist-ip 254.0.0.1/16

package/openwrt/custom.conf

@@ -1,14 +1,14 @@
-# Add custom settings here.
+# Add custom settings here.
-
+
-# set log level
+# set log level
-# log-level [level], level=fatal, error, warn, notice, info, debug
+# log-level [level], level=fatal, error, warn, notice, info, debug
-# log-level error
+# log-level error
-
+
-# log-size k,m,g
+# log-size k,m,g
-# log-size 128k
+# log-size 128k
-
+
-# log-file /var/log/smartdns.log
+# log-file /var/log/smartdns.log
-# log-num 2
+# log-num 2
-
+
-# List of hosts that supply bogus NX domain results 
+# List of hosts that supply bogus NX domain results 
 # bogus-nxdomain [ip/subnet]

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,22 +36,18 @@ 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
-	uci commit dhcp 
+	uci commit dhcp
 	/etc/init.d/dnsmasq restart
 }
 
@@ -60,18 +55,16 @@ 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 +74,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,24 +100,22 @@ 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
-	
+
 }
 
 service_triggers() {
@@ -134,7 +123,6 @@ service_triggers() {
 	procd_add_reload_trigger smartdns
 }
 
-
 conf_append()
 {
 	echo "$1 $2" >> $SMARTDNS_CONF_TMP
@@ -144,23 +132,16 @@ 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 +151,21 @@ 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 no_check_certificate "$section" "no_check_certificate" ""
-	config_get "http_host" "$section" "http_host" ""
+	config_get host_name "$section" "host_name" ""
-	config_get "server_group" "$section" "server_group" ""
+	config_get http_host "$section" "http_host" ""
-	config_get "blacklist_ip" "$section" "blacklist_ip" "0"
+	config_get server_group "$section" "server_group" ""
-	config_get "check_edns" "$section" "check_edns" "0"
+	config_get blacklist_ip "$section" "blacklist_ip" "0"
-	config_get "spki_pin" "$section" "spki_pin" ""
+	config_get check_edns "$section" "check_edns" "0"
-	config_get "addition_arg" "$section" "addition_arg" ""
+	config_get spki_pin "$section" "spki_pin" ""
+	config_get addition_arg "$section" "addition_arg" ""
 
-	if [ "$enabled" = "0" ]; then
+	[ "$enabled" = "0" ] && return
-		return
-	fi
 
 	if [ -z "$ip" ] || [ -z "$type" ]; then
 		return
@@ -200,107 +180,71 @@ 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 "$no_check_certificate" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -no-check-certificate"
-	fi
+	[ -z "$host_name" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -host-name $host_name"
+	[ -z "$http_host" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -http-host $http_host"
+	[ -z "$server_group" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -group $server_group"
+	[ "$blacklist_ip" = "0" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -blacklist-ip"
+	[ "$check_edns" = "0" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -check-edns"
+	[ -z "$spki_pin" ] || ADDITIONAL_ARGS="$ADDITIONAL_ARGS -spki-pin $spki_pin"
 
-	if [ ! -z "$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"
 }
 
-load_second_server() 
+load_second_server()
 {
 	local section="$1"
 	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,12 +253,10 @@ 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() 
+load_service()
 {
 	local section="$1"
 	args=""
@@ -322,102 +264,77 @@ 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
 	uci delete smartdns.@smartdns[0].old_port 2>/dev/null
 	uci delete smartdns.@smartdns[0].old_enabled 2>/dev/null
@@ -438,31 +355,29 @@ 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
 }
 
-start_service() 
+start_service()
 {
 	config_load "smartdns"
 	config_foreach load_service "smartdns"

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

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

src/dns.h

@@ -44,7 +44,10 @@ typedef enum dns_rr_type {
 	DNS_RRS_END,
 } dns_rr_type;
 
-typedef enum dns_class { DNS_C_IN = 1, DNS_C_ANY = 255 } dns_class_t;
+typedef enum dns_class {
+	DNS_C_IN = 1, // DNS C IN
+	DNS_C_ANY = 255
+} dns_class_t;
 
 typedef enum dns_type {
 	DNS_T_A = 1,
@@ -63,10 +66,10 @@ typedef enum dns_type {
 	DNS_T_ALL = 255
 } dns_type_t;
 
-typedef enum dns_opt_code { 
+typedef enum dns_opt_code {
-	DNS_OPT_T_ECS = 8, 
+	DNS_OPT_T_ECS = 8, // OPT ECS
 	DNS_OPT_T_TCP_KEEPALIVE = 11,
-	DNS_OPT_T_ALL = 255 
+	DNS_OPT_T_ALL = 255
 } dns_opt_code_t;
 
 typedef enum dns_opcode {
@@ -196,7 +199,8 @@ int dns_get_A(struct dns_rrs *rrs, char *domain, int maxsize, int *ttl, unsigned
 int dns_add_PTR(struct dns_packet *packet, dns_rr_type type, char *domain, int ttl, char *cname);
 int dns_get_PTR(struct dns_rrs *rrs, char *domain, int maxsize, int *ttl, char *cname, int cname_size);
 
-int dns_add_AAAA(struct dns_packet *packet, dns_rr_type type, char *domain, int ttl, unsigned char addr[DNS_RR_AAAA_LEN]);
+int dns_add_AAAA(struct dns_packet *packet, dns_rr_type type, char *domain, int ttl,
+				 unsigned char addr[DNS_RR_AAAA_LEN]);
 int dns_get_AAAA(struct dns_rrs *rrs, char *domain, int maxsize, int *ttl, unsigned char addr[DNS_RR_AAAA_LEN]);
 
 int dns_add_SOA(struct dns_packet *packet, dns_rr_type type, char *domain, int ttl, struct dns_soa *soa);
@@ -212,7 +216,8 @@ int dns_add_OPT_ECS(struct dns_packet *packet, struct dns_opt_ecs *ecs);
 int dns_get_OPT_ECS(struct dns_rrs *rrs, unsigned short *opt_code, unsigned short *opt_len, struct dns_opt_ecs *ecs);
 
 int dns_add_OPT_TCP_KEEYALIVE(struct dns_packet *packet, unsigned short timeout);
-int dns_get_OPT_TCP_KEEYALIVE(struct dns_rrs *rrs, unsigned short *opt_code, unsigned short *opt_len, unsigned short *timeout);
+int dns_get_OPT_TCP_KEEYALIVE(struct dns_rrs *rrs, unsigned short *opt_code, unsigned short *opt_len,
+							  unsigned short *timeout);
 /*
  * Packet operation
  */

src/dns_cache.c

@@ -1,386 +1,452 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#include "dns_cache.h"
+#include "dns_cache.h"
-#include "stringutil.h"
+#include "stringutil.h"
-#include "tlog.h"
+#include "tlog.h"
-#include <pthread.h>
+#include <pthread.h>
-
+
-#define DNS_CACHE_MAX_HITNUM 5000
+#define DNS_CACHE_MAX_HITNUM 5000
-#define DNS_CACHE_HITNUM_STEP 2
+#define DNS_CACHE_HITNUM_STEP 2
-#define DNS_CACHE_HITNUM_STEP_MAX 6
+#define DNS_CACHE_HITNUM_STEP_MAX 6
-
+
-struct dns_cache_head {
+struct dns_cache_head {
-	DECLARE_HASHTABLE(cache_hash, 10);
+	DECLARE_HASHTABLE(cache_hash, 10);
-	struct list_head cache_list;
+	struct list_head cache_list;
-	atomic_t num;
+	struct list_head inactive_list;
-	int size;
+	atomic_t num;
-	pthread_mutex_t lock;
+	int size;
-};
+	int enable_inactive;
-
+	int inactive_list_expired;
-static struct dns_cache_head dns_cache_head;
+	pthread_mutex_t lock;
-
+};
-int dns_cache_init(int size)
+
-{
+static struct dns_cache_head dns_cache_head;
-	INIT_LIST_HEAD(&dns_cache_head.cache_list);
+
-	hash_init(dns_cache_head.cache_hash);
+int dns_cache_init(int size, int enable_inactive, int inactive_list_expired)
-	atomic_set(&dns_cache_head.num, 0);
+{
-	dns_cache_head.size = size;
+	INIT_LIST_HEAD(&dns_cache_head.cache_list);
-
+	INIT_LIST_HEAD(&dns_cache_head.inactive_list);
-	pthread_mutex_init(&dns_cache_head.lock, NULL);
+	hash_init(dns_cache_head.cache_hash);
-
+	atomic_set(&dns_cache_head.num, 0);
-	return 0;
+	dns_cache_head.size = size;
-}
+	dns_cache_head.enable_inactive = enable_inactive;
-
+	dns_cache_head.inactive_list_expired = inactive_list_expired;
-static __attribute__((unused)) struct dns_cache *_dns_cache_last(void)
+
-{
+	pthread_mutex_init(&dns_cache_head.lock, NULL);
-	return list_last_entry(&dns_cache_head.cache_list, struct dns_cache, list);
+
-}
+	return 0;
-
+}
-static struct dns_cache *_dns_cache_first(void)
+
-{
+static __attribute__((unused)) struct dns_cache *_dns_cache_last(void)
-	return list_first_entry_or_null(&dns_cache_head.cache_list, struct dns_cache, list);
+{
-}
+	struct dns_cache *dns_cache = NULL;
-
+
-static void _dns_cache_delete(struct dns_cache *dns_cache)
+	dns_cache = list_last_entry(&dns_cache_head.inactive_list, struct dns_cache, list);
-{
+	if (dns_cache) {
-	hash_del(&dns_cache->node);
+		return dns_cache;
-	list_del_init(&dns_cache->list);
+	}
-	atomic_dec(&dns_cache_head.num);
+
-	free(dns_cache);
+	return list_last_entry(&dns_cache_head.cache_list, struct dns_cache, list);
-}
+}
-
+
-void dns_cache_get(struct dns_cache *dns_cache)
+static struct dns_cache *_dns_cache_first(void)
-{
+{
-	if (atomic_inc_return(&dns_cache->ref) == 1) {
+	struct dns_cache *dns_cache = NULL;
-		tlog(TLOG_ERROR, "BUG: dns_cache is invalid.");
+
-		return;
+	dns_cache = list_first_entry_or_null(&dns_cache_head.inactive_list, struct dns_cache, list);
-	}
+	if (dns_cache) {
-}
+		return dns_cache;
-
+	}
-void dns_cache_release(struct dns_cache *dns_cache)
+
-{
+	return list_first_entry_or_null(&dns_cache_head.cache_list, struct dns_cache, list);
-	if (dns_cache == NULL) {
+}
-		return;
+
-	}
+static void _dns_cache_delete(struct dns_cache *dns_cache)
-	if (!atomic_dec_and_test(&dns_cache->ref)) {
+{
-		return;
+	hash_del(&dns_cache->node);
-	}
+	list_del_init(&dns_cache->list);
-
+	atomic_dec(&dns_cache_head.num);
-	_dns_cache_delete(dns_cache);
+	free(dns_cache);
-}
+}
-
+
-static void _dns_cache_remove(struct dns_cache *dns_cache)
+void dns_cache_get(struct dns_cache *dns_cache)
-{
+{
-	hash_del(&dns_cache->node);
+	if (atomic_inc_return(&dns_cache->ref) == 1) {
-	list_del_init(&dns_cache->list);
+		tlog(TLOG_ERROR, "BUG: dns_cache is invalid.");
-	dns_cache_release(dns_cache);
+		return;
-}
+	}
-
+}
-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)
+
-{
+void dns_cache_release(struct dns_cache *dns_cache)
-	struct dns_cache *dns_cache = NULL;
+{
-
+	if (dns_cache == NULL) {
-	if (dns_cache_head.size <= 0) {
+		return;
-		return 0;
+	}
-	}
+	if (!atomic_dec_and_test(&dns_cache->ref)) {
-
+		return;
-	/* lookup existing cache */
+	}
-	dns_cache = dns_cache_lookup(domain, qtype);
+
-	if (dns_cache == NULL) {
+	_dns_cache_delete(dns_cache);
-		return 0;
+}
-	}
+
-
+static void _dns_cache_remove(struct dns_cache *dns_cache)
-	if (ttl < DNS_CACHE_TTL_MIN) {
+{
-		ttl = DNS_CACHE_TTL_MIN;
+	hash_del(&dns_cache->node);
-	}
+	list_del_init(&dns_cache->list);
-
+	dns_cache_release(dns_cache);
-	/* update cache data */
+}
-	pthread_mutex_lock(&dns_cache_head.lock);
+
-	dns_cache->ttl = ttl;
+static void _dns_cache_move_inactive(struct dns_cache *dns_cache)
-	dns_cache->qtype = qtype;
+{
-	dns_cache->ttl = ttl;
+	list_del_init(&dns_cache->list);
-	dns_cache->del_pending = 0;
+	list_add_tail(&dns_cache->list, &dns_cache_head.inactive_list);
-	dns_cache->speed = speed;
+}
-	time(&dns_cache->insert_time);
+
-	if (qtype == DNS_T_A) {
+int dns_cache_replace(char *domain, char *cname, int cname_ttl, int ttl, dns_type_t qtype, unsigned char *addr,
-		if (addr_len != DNS_RR_A_LEN) {
+					  int addr_len, int speed)
-			goto errout_unlock;
+{
-		}
+	struct dns_cache *dns_cache = NULL;
-		memcpy(dns_cache->addr, addr, DNS_RR_A_LEN);
+
-	} else if (qtype == DNS_T_AAAA) {
+	if (dns_cache_head.size <= 0) {
-		if (addr_len != DNS_RR_AAAA_LEN) {
+		return 0;
-			goto errout_unlock;
+	}
-		}
+
-		memcpy(dns_cache->addr, addr, DNS_RR_AAAA_LEN);
+	/* lookup existing cache */
-	} else {
+	dns_cache = dns_cache_lookup(domain, qtype);
-		goto errout_unlock;
+	if (dns_cache == NULL) {
-	}
+		return 0;
-
+	}
-	if (cname) {
+
-		safe_strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
+	if (ttl < DNS_CACHE_TTL_MIN) {
-		dns_cache->cname_ttl = cname_ttl;
+		ttl = DNS_CACHE_TTL_MIN;
-	}
+	}
-	pthread_mutex_unlock(&dns_cache_head.lock);
+
-
+	/* update cache data */
-	dns_cache_release(dns_cache);
+	pthread_mutex_lock(&dns_cache_head.lock);
-	return 0;
+	dns_cache->ttl = ttl;
-errout_unlock:
+	dns_cache->qtype = qtype;
-	pthread_mutex_unlock(&dns_cache_head.lock);
+	dns_cache->ttl = ttl;
-// errout:
+	dns_cache->del_pending = 0;
-	if (dns_cache) {
+	dns_cache->speed = speed;
-		dns_cache_release(dns_cache);
+	time(&dns_cache->insert_time);
-	}
+	if (qtype == DNS_T_A) {
-	return -1;
+		if (addr_len != DNS_RR_A_LEN) {
-}
+			goto errout_unlock;
-
+		}
-int dns_cache_insert(char *domain, char *cname, int cname_ttl, int ttl, dns_type_t qtype, unsigned char *addr, int addr_len, int speed)
+		memcpy(dns_cache->addr, addr, DNS_RR_A_LEN);
-{
+	} else if (qtype == DNS_T_AAAA) {
-	uint32_t key = 0;
+		if (addr_len != DNS_RR_AAAA_LEN) {
-	struct dns_cache *dns_cache = NULL;
+			goto errout_unlock;
-
+		}
-	if (dns_cache_head.size <= 0) {
+		memcpy(dns_cache->addr, addr, DNS_RR_AAAA_LEN);
-		return 0;
+	} else {
-	}
+		goto errout_unlock;
-
+	}
-	/* if cache already exists, free */
+
-	dns_cache = dns_cache_lookup(domain, qtype);
+	if (cname) {
-	if (dns_cache) {
+		safe_strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
-		dns_cache_delete(dns_cache);
+		dns_cache->cname_ttl = cname_ttl;
-		dns_cache_release(dns_cache);
+	}
-		dns_cache = NULL;
+
-	}
+	list_del_init(&dns_cache->list);
-
+	list_add_tail(&dns_cache->list, &dns_cache_head.cache_list);
-	dns_cache = malloc(sizeof(*dns_cache));
+	pthread_mutex_unlock(&dns_cache_head.lock);
-	if (dns_cache == NULL) {
+
-		goto errout;
+	dns_cache_release(dns_cache);
-	}
+	return 0;
-
+errout_unlock:
-	if (ttl < DNS_CACHE_TTL_MIN) {
+	pthread_mutex_unlock(&dns_cache_head.lock);
-		ttl = DNS_CACHE_TTL_MIN;
+	// errout:
-	}
+	if (dns_cache) {
-
+		dns_cache_release(dns_cache);
-	key = hash_string(domain);
+	}
-	key = jhash(&qtype, sizeof(qtype), key);
+	return -1;
-	safe_strncpy(dns_cache->domain, domain, DNS_MAX_CNAME_LEN);
+}
-	dns_cache->cname[0] = 0;
+
-	dns_cache->qtype = qtype;
+int dns_cache_insert(char *domain, char *cname, int cname_ttl, int ttl, dns_type_t qtype, unsigned char *addr,
-	dns_cache->ttl = ttl;
+					 int addr_len, int speed)
-	atomic_set(&dns_cache->hitnum, 3);
+{
-	dns_cache->hitnum_update_add = DNS_CACHE_HITNUM_STEP;
+	uint32_t key = 0;
-	dns_cache->del_pending = 0;
+	struct dns_cache *dns_cache = NULL;
-	dns_cache->speed = speed;
+
-	atomic_set(&dns_cache->ref, 1);
+	if (dns_cache_head.size <= 0) {
-	time(&dns_cache->insert_time);
+		return 0;
-	if (qtype == DNS_T_A) {
+	}
-		if (addr_len != DNS_RR_A_LEN) {
+
-			goto errout;
+	/* if cache already exists, free */
-		}
+	dns_cache = dns_cache_lookup(domain, qtype);
-		memcpy(dns_cache->addr, addr, DNS_RR_A_LEN);
+	if (dns_cache) {
-	} else if (qtype == DNS_T_AAAA) {
+		dns_cache_delete(dns_cache);
-		if (addr_len != DNS_RR_AAAA_LEN) {
+		dns_cache_release(dns_cache);
-			goto errout;
+		dns_cache = NULL;
-		}
+	}
-		memcpy(dns_cache->addr, addr, DNS_RR_AAAA_LEN);
+
-	} else {
+	dns_cache = malloc(sizeof(*dns_cache));
-		goto errout;
+	if (dns_cache == NULL) {
-	}
+		goto errout;
-
+	}
-	if (cname) {
+
-		safe_strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
+	if (ttl < DNS_CACHE_TTL_MIN) {
-		dns_cache->cname_ttl = cname_ttl;
+		ttl = DNS_CACHE_TTL_MIN;
-	}
+	}
-
+
-	pthread_mutex_lock(&dns_cache_head.lock);
+	key = hash_string(domain);
-	hash_add(dns_cache_head.cache_hash, &dns_cache->node, key);
+	key = jhash(&qtype, sizeof(qtype), key);
-	list_add_tail(&dns_cache->list, &dns_cache_head.cache_list);
+	safe_strncpy(dns_cache->domain, domain, DNS_MAX_CNAME_LEN);
-	INIT_LIST_HEAD(&dns_cache->check_list);
+	dns_cache->cname[0] = 0;
-
+	dns_cache->qtype = qtype;
-	/* Release extra cache, remove oldest cache record */
+	dns_cache->ttl = ttl;
-	if (atomic_inc_return(&dns_cache_head.num) > dns_cache_head.size) {
+	atomic_set(&dns_cache->hitnum, 3);
-		struct dns_cache *del_cache;
+	dns_cache->hitnum_update_add = DNS_CACHE_HITNUM_STEP;
-		del_cache = _dns_cache_first();
+	dns_cache->del_pending = 0;
-		if (del_cache) {
+	dns_cache->speed = speed;
-			_dns_cache_remove(del_cache);
+	atomic_set(&dns_cache->ref, 1);
-		}
+	time(&dns_cache->insert_time);
-	}
+	if (qtype == DNS_T_A) {
-	pthread_mutex_unlock(&dns_cache_head.lock);
+		if (addr_len != DNS_RR_A_LEN) {
-
+			goto errout;
-	return 0;
+		}
-errout:
+		memcpy(dns_cache->addr, addr, DNS_RR_A_LEN);
-	if (dns_cache) {
+	} else if (qtype == DNS_T_AAAA) {
-		free(dns_cache);
+		if (addr_len != DNS_RR_AAAA_LEN) {
-	}
+			goto errout;
-
+		}
-	return -1;
+		memcpy(dns_cache->addr, addr, DNS_RR_AAAA_LEN);
-}
+	} else {
-
+		goto errout;
-struct dns_cache *dns_cache_lookup(char *domain, dns_type_t qtype)
+	}
-{
+
-	uint32_t key = 0;
+	if (cname) {
-	struct dns_cache *dns_cache = NULL;
+		safe_strncpy(dns_cache->cname, cname, DNS_MAX_CNAME_LEN);
-	struct dns_cache *dns_cache_ret = NULL;
+		dns_cache->cname_ttl = cname_ttl;
-	time_t now;
+	}
-
+
-	if (dns_cache_head.size <= 0) {
+	pthread_mutex_lock(&dns_cache_head.lock);
-		return NULL;
+	hash_add(dns_cache_head.cache_hash, &dns_cache->node, key);
-	}
+	list_add_tail(&dns_cache->list, &dns_cache_head.cache_list);
-
+	INIT_LIST_HEAD(&dns_cache->check_list);
-	key = hash_string(domain);
+
-	key = jhash(&qtype, sizeof(qtype), key);
+	/* Release extra cache, remove oldest cache record */
-
+	if (atomic_inc_return(&dns_cache_head.num) > dns_cache_head.size) {
-	time(&now);
+		struct dns_cache *del_cache;
-	/* find cache */
+		del_cache = _dns_cache_first();
-	pthread_mutex_lock(&dns_cache_head.lock);
+		if (del_cache) {
-	hash_for_each_possible(dns_cache_head.cache_hash, dns_cache, node, key)
+			_dns_cache_remove(del_cache);
-	{
+		}
-		if (dns_cache->qtype != qtype) {
+	}
-			continue;
+	pthread_mutex_unlock(&dns_cache_head.lock);
-		}
+
-
+	return 0;
-		if (strncmp(domain, dns_cache->domain, DNS_MAX_CNAME_LEN) != 0) {
+errout:
-			continue;
+	if (dns_cache) {
-		}
+		free(dns_cache);
-
+	}
-		dns_cache_ret = dns_cache;
+
-		break;
+	return -1;
-	}
+}
-
+
-	if (dns_cache_ret) {
+struct dns_cache *dns_cache_lookup(char *domain, dns_type_t qtype)
-		/* Return NULL if the cache times out */
+{
-		if (now - dns_cache_ret->insert_time > dns_cache_ret->ttl) {
+	uint32_t key = 0;
-			_dns_cache_remove(dns_cache_ret);
+	struct dns_cache *dns_cache = NULL;
-			dns_cache_ret = NULL;
+	struct dns_cache *dns_cache_ret = NULL;
-		} else {
+	time_t now;
-			dns_cache_get(dns_cache_ret);
+
-		}
+	if (dns_cache_head.size <= 0) {
-	}
+		return NULL;
-
+	}
-	pthread_mutex_unlock(&dns_cache_head.lock);
+
-
+	key = hash_string(domain);
-	return dns_cache_ret;
+	key = jhash(&qtype, sizeof(qtype), key);
-}
+
-
+	time(&now);
-int dns_cache_get_ttl(struct dns_cache *dns_cache)
+	/* find cache */
-{
+	pthread_mutex_lock(&dns_cache_head.lock);
-	time_t now;
+	hash_for_each_possible(dns_cache_head.cache_hash, dns_cache, node, key)
-	int ttl = 0;
+	{
-	time(&now);
+		if (dns_cache->qtype != qtype) {
-
+			continue;
-	ttl = dns_cache->insert_time + dns_cache->ttl - now;
+		}
-	if (ttl < 0) {
+
-		return 0;
+		if (strncmp(domain, dns_cache->domain, DNS_MAX_CNAME_LEN) != 0) {
-	}
+			continue;
-
+		}
-	return ttl;
+
-}
+		dns_cache_ret = dns_cache;
-
+		break;
-void dns_cache_delete(struct dns_cache *dns_cache)
+	}
-{
+
-	pthread_mutex_lock(&dns_cache_head.lock);
+	if (dns_cache_ret) {
-	_dns_cache_remove(dns_cache);
+		/* Return NULL if the cache times out */
-	pthread_mutex_unlock(&dns_cache_head.lock);
+		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;
-int dns_cache_hitnum_dec_get(struct dns_cache *dns_cache)
+		} else {
-{
+			dns_cache_get(dns_cache_ret);
-	int hitnum = 0;
+		}
-	pthread_mutex_lock(&dns_cache_head.lock);
+	}
-	hitnum = atomic_dec_return(&dns_cache->hitnum);
+
-	if (dns_cache->hitnum_update_add > DNS_CACHE_HITNUM_STEP) {
+	pthread_mutex_unlock(&dns_cache_head.lock);
-		dns_cache->hitnum_update_add--;
+
-	}
+	return dns_cache_ret;
-	pthread_mutex_unlock(&dns_cache_head.lock);
+}
-
+
-	return hitnum;
+int dns_cache_get_ttl(struct dns_cache *dns_cache)
-}
+{
-
+	time_t now;
-void dns_cache_update(struct dns_cache *dns_cache)
+	int ttl = 0;
-{
+	time(&now);
-	pthread_mutex_lock(&dns_cache_head.lock);
+
-	if (!list_empty(&dns_cache->list)) {
+	ttl = dns_cache->insert_time + dns_cache->ttl - now;
-		list_del_init(&dns_cache->list);
+	if (ttl < 0) {
-		list_add_tail(&dns_cache->list, &dns_cache_head.cache_list);
+		return 0;
-		atomic_add(dns_cache->hitnum_update_add, &dns_cache->hitnum);
+	}
-		if (atomic_read(&dns_cache->hitnum) > DNS_CACHE_MAX_HITNUM) {
+
-			atomic_set(&dns_cache->hitnum, DNS_CACHE_MAX_HITNUM);
+	return ttl;
-		}
+}
-
+
-		if (dns_cache->hitnum_update_add < DNS_CACHE_HITNUM_STEP_MAX) {
+void dns_cache_delete(struct dns_cache *dns_cache)
-			dns_cache->hitnum_update_add++;
+{
-		}
+	pthread_mutex_lock(&dns_cache_head.lock);
-	}
+	_dns_cache_remove(dns_cache);
-	pthread_mutex_unlock(&dns_cache_head.lock);
+	pthread_mutex_unlock(&dns_cache_head.lock);
-}
+}
-
+
-void dns_cache_invalidate(dns_cache_preinvalid_callback callback, int ttl_pre)
+int dns_cache_hitnum_dec_get(struct dns_cache *dns_cache)
-{
+{
-	struct dns_cache *dns_cache = NULL;
+	int hitnum = 0;
-	struct dns_cache *tmp;
+	pthread_mutex_lock(&dns_cache_head.lock);
-	time_t now;
+	hitnum = atomic_dec_return(&dns_cache->hitnum);
-	int ttl = 0;
+	if (dns_cache->hitnum_update_add > DNS_CACHE_HITNUM_STEP) {
-	LIST_HEAD(checklist);
+		dns_cache->hitnum_update_add--;
-
+	}
-	if (dns_cache_head.size <= 0) {
+	pthread_mutex_unlock(&dns_cache_head.lock);
-		return;
+
-	}
+	return hitnum;
-
+}
-	time(&now);
+
-	pthread_mutex_lock(&dns_cache_head.lock);
+void dns_cache_update(struct dns_cache *dns_cache)
-	list_for_each_entry_safe(dns_cache, tmp, &dns_cache_head.cache_list, list)
+{
-	{
+	pthread_mutex_lock(&dns_cache_head.lock);
-		ttl = dns_cache->insert_time + dns_cache->ttl - now;
+	if (!list_empty(&dns_cache->list)) {
-		if (ttl > 0 && ttl < ttl_pre) {
+		list_del_init(&dns_cache->list);
-			/* If the TTL time is in the pre-timeout range, call callback function */
+		list_add_tail(&dns_cache->list, &dns_cache_head.cache_list);
-			if (callback && dns_cache->del_pending == 0) {
+		atomic_add(dns_cache->hitnum_update_add, &dns_cache->hitnum);
-				list_add_tail(&dns_cache->check_list, &checklist);
+		if (atomic_read(&dns_cache->hitnum) > DNS_CACHE_MAX_HITNUM) {
-				dns_cache_get(dns_cache);
+			atomic_set(&dns_cache->hitnum, DNS_CACHE_MAX_HITNUM);
-				dns_cache->del_pending = 1;
+		}
-				continue;
+
-			}
+		if (dns_cache->hitnum_update_add < DNS_CACHE_HITNUM_STEP_MAX) {
-		}
+			dns_cache->hitnum_update_add++;
-
+		}
-		if (ttl < 0) {
+	}
-			_dns_cache_remove(dns_cache);
+	pthread_mutex_unlock(&dns_cache_head.lock);
-		}
+}
-	}
+
-	pthread_mutex_unlock(&dns_cache_head.lock);
+void _dns_cache_remove_expired_ttl(time_t *now)
-
+{
-	list_for_each_entry_safe(dns_cache, tmp, &checklist, check_list)
+	struct dns_cache *dns_cache = NULL;
-	{
+	struct dns_cache *tmp;
-		/* run callback */
+	int ttl = 0;
-		if (callback) {
+
-			callback(dns_cache);
+	list_for_each_entry_safe(dns_cache, tmp, &dns_cache_head.inactive_list, list)
-		}
+	{
-		dns_cache_release(dns_cache);
+		ttl = dns_cache->insert_time + dns_cache->ttl - *now;
-	}
+		if (ttl > 0) {
-}
+			continue;
-
+		}
-void dns_cache_destroy(void)
+
-{
+		if (dns_cache_head.inactive_list_expired + ttl > 0) {
-	struct dns_cache *dns_cache = NULL;
+			continue;
-	struct dns_cache *tmp;
+		}
-	pthread_mutex_lock(&dns_cache_head.lock);
+
-	list_for_each_entry_safe(dns_cache, tmp, &dns_cache_head.cache_list, list)
+		_dns_cache_remove(dns_cache);
-	{
+	}
-		_dns_cache_delete(dns_cache);
+}
-	}
+
-	pthread_mutex_unlock(&dns_cache_head.lock);
+void dns_cache_invalidate(dns_cache_preinvalid_callback callback, int ttl_pre)
-
+{
-	pthread_mutex_destroy(&dns_cache_head.lock);
+	struct dns_cache *dns_cache = NULL;
-}
+	struct dns_cache *tmp;
+	time_t now;
+	int ttl = 0;
+	LIST_HEAD(checklist);
+
+	if (dns_cache_head.size <= 0) {
+		return;
+	}
+
+	time(&now);
+	pthread_mutex_lock(&dns_cache_head.lock);
+	list_for_each_entry_safe(dns_cache, tmp, &dns_cache_head.cache_list, list)
+	{
+		ttl = dns_cache->insert_time + dns_cache->ttl - now;
+		if (ttl > 0 && ttl < ttl_pre) {
+			/* If the TTL time is in the pre-timeout range, call callback function */
+			if (callback && dns_cache->del_pending == 0) {
+				list_add_tail(&dns_cache->check_list, &checklist);
+				dns_cache_get(dns_cache);
+				dns_cache->del_pending = 1;
+				continue;
+			}
+		}
+
+		if (ttl < 0) {
+			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)
+	{
+		/* run callback */
+		if (callback) {
+			callback(dns_cache);
+		}
+		dns_cache_release(dns_cache);
+	}
+}
+
+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);
+	}
+	pthread_mutex_unlock(&dns_cache_head.lock);
+
+	pthread_mutex_destroy(&dns_cache_head.lock);
+}

src/dns_cache.h

@@ -1,87 +1,89 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#ifndef _SMARTDNS_CACHE_H
+#ifndef _SMARTDNS_CACHE_H
-#define _SMARTDNS_CACHE_H
+#define _SMARTDNS_CACHE_H
-
+
-#include "atomic.h"
+#include "atomic.h"
-#include "dns.h"
+#include "dns.h"
-#include "hash.h"
+#include "hash.h"
-#include "hashtable.h"
+#include "hashtable.h"
-#include "list.h"
+#include "list.h"
-#include <stdlib.h>
+#include <stdlib.h>
-#include <time.h>
+#include <time.h>
-
+
-#ifdef __cpluscplus
+#ifdef __cpluscplus
-extern "C" {
+extern "C" {
-#endif
+#endif
-
+
-#define DNS_CACHE_TTL_MIN 30
+#define DNS_CACHE_TTL_MIN 30
-
+
-struct dns_cache {
+struct dns_cache {
-	struct hlist_node node;
+	struct hlist_node node;
-	struct list_head list;
+	struct list_head list;
-	struct list_head check_list;
+	struct list_head check_list;
-	atomic_t ref;
+	atomic_t ref;
-	char domain[DNS_MAX_CNAME_LEN];
+	char domain[DNS_MAX_CNAME_LEN];
-	char cname[DNS_MAX_CNAME_LEN];
+	char cname[DNS_MAX_CNAME_LEN];
-	unsigned int cname_ttl;
+	unsigned int cname_ttl;
-	unsigned int ttl;
+	unsigned int ttl;
-	int speed;
+	int speed;
-	atomic_t hitnum;
+	atomic_t hitnum;
-	int hitnum_update_add;
+	int hitnum_update_add;
-	int del_pending;
+	int del_pending;
-	time_t insert_time;
+	time_t insert_time;
-	dns_type_t qtype;
+	dns_type_t qtype;
-	union {
+	union {
-		unsigned char ipv4_addr[DNS_RR_A_LEN];
+		unsigned char ipv4_addr[DNS_RR_A_LEN];
-		unsigned char ipv6_addr[DNS_RR_AAAA_LEN];
+		unsigned char ipv6_addr[DNS_RR_AAAA_LEN];
-		unsigned char addr[0];
+		unsigned char addr[0];
-	};
+	};
-};
+};
-
+
-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);
+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);
-int dns_cache_insert(char *domain, char *cname, int cname_ttl, int ttl, dns_type_t qtype, unsigned char *addr, int addr_len, int speed);
+
-
+int dns_cache_insert(char *domain, char *cname, int cname_ttl, int ttl, dns_type_t qtype, unsigned char *addr,
-struct dns_cache *dns_cache_lookup(char *domain, dns_type_t qtype);
+					 int addr_len, int speed);
-
+
-void dns_cache_delete(struct dns_cache *dns_cache);
+struct dns_cache *dns_cache_lookup(char *domain, dns_type_t qtype);
-
+
-void dns_cache_get(struct dns_cache *dns_cache);
+void dns_cache_delete(struct dns_cache *dns_cache);
-
+
-void dns_cache_release(struct dns_cache *dns_cache);
+void dns_cache_get(struct dns_cache *dns_cache);
-
+
-int dns_cache_hitnum_dec_get(struct dns_cache *dns_cache);
+void dns_cache_release(struct dns_cache *dns_cache);
-
+
-void dns_cache_update(struct dns_cache *dns_cache);
+int dns_cache_hitnum_dec_get(struct dns_cache *dns_cache);
-
+
-typedef void dns_cache_preinvalid_callback(struct dns_cache *dns_cache);
+void dns_cache_update(struct dns_cache *dns_cache);
-
+
-void dns_cache_invalidate(dns_cache_preinvalid_callback callback, int ttl_pre);
+typedef void dns_cache_preinvalid_callback(struct dns_cache *dns_cache);
-
+
-int dns_cache_get_ttl(struct dns_cache *dns_cache);
+void dns_cache_invalidate(dns_cache_preinvalid_callback callback, int ttl_pre);
-
+
-void dns_cache_destroy(void);
+int dns_cache_get_ttl(struct dns_cache *dns_cache);
-
+
-#ifdef __cpluscplus
+void dns_cache_destroy(void);
-}
+
-#endif
+#ifdef __cpluscplus
-#endif // !_SMARTDNS_CACHE_H
+}
+#endif
+#endif // !_SMARTDNS_CACHE_H

src/dns_client.c

@@ -29,8 +29,8 @@
 #include "tlog.h"
 #include "util.h"
 #include <arpa/inet.h>
-#include <errno.h>
 #include <ctype.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <linux/filter.h>
 #include <netdb.h>
@@ -46,7 +46,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/epoll.h>
-#include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -59,11 +58,11 @@
 #define DNS_TCP_IDLE_TIMEOUT (60 * 10)
 #define DNS_TCP_CONNECT_TIMEOUT (5)
 #define DNS_QUERY_TIMEOUT (500)
-#define DNS_QUERY_RETRY (3)
+#define DNS_QUERY_RETRY (6)
+#define DNS_PENDING_SERVER_RETRY 40
 #define SOCKET_PRIORITY (6)
 #define SOCKET_IP_TOS (IPTOS_LOWDELAY | IPTOS_RELIABILITY)
 
-
 /* ECS info */
 struct dns_client_ecs {
 	int enable;
@@ -108,6 +107,7 @@ struct dns_server_info {
 	SSL *ssl;
 	SSL_CTX *ssl_ctx;
 	SSL_SESSION *ssl_session;
+	char skip_check_cert;
 	dns_server_status status;
 
 	struct dns_server_buff send_buff;
@@ -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];
@@ -148,6 +149,7 @@ struct dns_server_pending {
 	unsigned int query_v6;
 	/* server type */
 	dns_server_type_t type;
+	int retry_cnt;
 
 	int port;
 
@@ -246,12 +248,11 @@ static LIST_HEAD(pending_servers);
 static pthread_mutex_t pending_server_mutex = PTHREAD_MUTEX_INITIALIZER;
 static int dns_client_has_bootstrap_dns = 0;
 
-const char *_dns_server_get_type_string(dns_server_type_t type) 
+const char *_dns_server_get_type_string(dns_server_type_t type)
 {
 	const char *type_str = "";
 
-	switch (type)
+	switch (type) {
-	{
 	case DNS_SERVER_UDP:
 		type_str = "udp";
 		break;
@@ -321,8 +322,9 @@ static int _dns_client_server_exist(const char *server_ip, int port, dns_server_
 	return -1;
 }
 
-static void _dns_client_server_update_ttl(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result, struct sockaddr *addr,
+static void _dns_client_server_update_ttl(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result,
-										  socklen_t addr_len, int seqno, int ttl, struct timeval *tv, void *userptr)
+										  struct sockaddr *addr, socklen_t addr_len, int seqno, int ttl,
+										  struct timeval *tv, void *userptr)
 {
 	struct dns_server_info *server_info = userptr;
 	if (result != PING_RESULT_RESPONSE || server_info == NULL) {
@@ -478,7 +480,8 @@ errout:
 }
 
 /* add server to group */
-static int _dns_client_add_to_group_pending(char *group_name, char *server_ip, int port, dns_server_type_t server_type, int ispending)
+static int _dns_client_add_to_group_pending(char *group_name, char *server_ip, int port, dns_server_type_t server_type,
+											int ispending)
 {
 	struct dns_server_info *server_info = NULL;
 
@@ -712,8 +715,42 @@ static char *_dns_client_server_get_spki(struct dns_server_info *server_info, in
 	return spki;
 }
 
+static int _dns_client_set_trusted_cert(SSL_CTX *ssl_ctx)
+{
+	char *cafile = NULL;
+	char *capath = NULL;
+	int cert_path_set = 0;
+
+	if (dns_conf_ca_file[0]) {
+		cafile = dns_conf_ca_file;
+	}
+
+	if (dns_conf_ca_path[0]) {
+		capath = dns_conf_ca_path;
+	}
+
+	if (cafile == NULL && capath == NULL) {
+		if (SSL_CTX_set_default_verify_paths(ssl_ctx)) {
+			cafile = "/etc/ssl/certs/ca-certificates.crt";
+			capath = "/etc/ssl/certs";
+		} else {
+			cert_path_set = 1;
+		}
+	}
+
+	if (cert_path_set == 0) {
+		if (!SSL_CTX_load_verify_locations(ssl_ctx, cafile, capath)) {
+			tlog(TLOG_WARN, "load certificate from %s:%s failed.", cafile, capath);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
 /* add dns server information */
-static int _dns_client_server_add(char *server_ip, char *server_host, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags)
+static int _dns_client_server_add(char *server_ip, char *server_host, int port, dns_server_type_t server_type,
+								  struct client_dns_server_flags *flags)
 {
 	struct dns_server_info *server_info = NULL;
 	struct addrinfo *gai = NULL;
@@ -721,6 +758,7 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 	int ttl = 0;
 	char port_s[8];
 	int sock_type;
+	char skip_check_cert = 0;
 
 	switch (server_type) {
 	case DNS_SERVER_UDP: {
@@ -745,11 +783,13 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 			}
 		}
 		sock_type = SOCK_STREAM;
+		skip_check_cert = flag_https->skip_check_cert;
 	} break;
 	case DNS_SERVER_TLS: {
 		struct client_dns_server_flag_tls *flag_tls = &flags->tls;
 		spki_data_len = flag_tls->spi_len;
 		sock_type = SOCK_STREAM;
+		skip_check_cert = flag_tls->skip_check_cert;
 	} break;
 	case DNS_SERVER_TCP:
 		sock_type = SOCK_STREAM;
@@ -795,6 +835,7 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 	server_info->status = DNS_SERVER_STATUS_INIT;
 	server_info->ttl = ttl;
 	server_info->ttl_range = 0;
+	server_info->skip_check_cert = skip_check_cert;
 	memcpy(&server_info->flags, flags, sizeof(server_info->flags));
 
 	/* exclude this server from default group */
@@ -812,6 +853,11 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 #else
 		server_info->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
 #endif
+		if (_dns_client_set_trusted_cert(server_info->ssl_ctx) != 0) {
+			tlog(TLOG_WARN, "disable check certificate for %s.", server_info->ip);
+			server_info->skip_check_cert = 1;
+		}
+
 		if (server_info->ssl_ctx == NULL) {
 			tlog(TLOG_ERROR, "init ssl failed.");
 			goto errout;
@@ -820,7 +866,8 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 
 	/* safe address info */
 	if (gai->ai_addrlen > sizeof(server_info->in6)) {
-		tlog(TLOG_ERROR, "addr len invalid, %d, %zd, %d", gai->ai_addrlen, sizeof(server_info->addr), server_info->ai_family);
+		tlog(TLOG_ERROR, "addr len invalid, %d, %zd, %d", gai->ai_addrlen, sizeof(server_info->addr),
+			 server_info->ai_family);
 		goto errout;
 	}
 	memcpy(&server_info->addr, gai->ai_addr, gai->ai_addrlen);
@@ -828,7 +875,8 @@ static int _dns_client_server_add(char *server_ip, char *server_host, int port,
 	/* start ping task */
 	if (server_type == DNS_SERVER_UDP) {
 		if (ttl <= 0 && (server_info->flags.result_flag & DNSSERVER_FLAG_CHECK_TTL)) {
-			server_info->ping_host = fast_ping_start(PING_TYPE_DNS, server_ip, 0, 60000, 1000, _dns_client_server_update_ttl, server_info);
+			server_info->ping_host =
+				fast_ping_start(PING_TYPE_DNS, server_ip, 0, 60000, 1000, _dns_client_server_update_ttl, server_info);
 			if (server_info->ping_host == NULL) {
 				tlog(TLOG_ERROR, "start ping failed.");
 				goto errout;
@@ -879,7 +927,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,7 +1008,51 @@ static int _dns_client_server_remove(char *server_ip, int port, dns_server_type_
 	return -1;
 }
 
-static int _dns_client_server_pending(char *server_ip, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags)
+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 +1072,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));
 
@@ -996,8 +1088,8 @@ errout:
 	return -1;
 }
 
-static int _dns_client_add_server_pending(char *server_ip, char *server_host, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags,
+static int _dns_client_add_server_pending(char *server_ip, char *server_host, int port, dns_server_type_t server_type,
-										  int ispending)
+										  struct client_dns_server_flags *flags, int ispending)
 {
 	int ret;
 
@@ -1027,7 +1119,8 @@ errout:
 	return -1;
 }
 
-int dns_client_add_server(char *server_ip, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags)
+int dns_client_add_server(char *server_ip, int port, dns_server_type_t server_type,
+						  struct client_dns_server_flags *flags)
 {
 	return _dns_client_add_server_pending(server_ip, NULL, port, server_type, flags, 1);
 }
@@ -1243,7 +1336,8 @@ static int _dns_replied_check_add(struct dns_query_struct *dns_query, struct soc
 	return 0;
 }
 
-static int _dns_client_recv(struct dns_server_info *server_info, unsigned char *inpacket, int inpacket_len, struct sockaddr *from, socklen_t from_len)
+static int _dns_client_recv(struct dns_server_info *server_info, unsigned char *inpacket, int inpacket_len,
+							struct sockaddr *from, socklen_t from_len)
 {
 	int len;
 	int i;
@@ -1265,8 +1359,8 @@ static int _dns_client_recv(struct dns_server_info *server_info, unsigned char *
 	len = dns_decode(packet, DNS_PACKSIZE, inpacket, inpacket_len);
 	if (len != 0) {
 		char host_name[DNS_MAX_CNAME_LEN];
-		tlog(TLOG_WARN, "decode failed, packet len = %d, tc = %d, id = %d, from = %s\n", inpacket_len, packet->head.tc, packet->head.id,
+		tlog(TLOG_WARN, "decode failed, packet len = %d, tc = %d, id = %d, from = %s\n", inpacket_len, packet->head.tc,
-			 gethost_by_addr(host_name, sizeof(host_name), from));
+			 packet->head.id, gethost_by_addr(host_name, sizeof(host_name), from));
 		return -1;
 	}
 
@@ -1276,9 +1370,12 @@ static int _dns_client_recv(struct dns_server_info *server_info, unsigned char *
 		return -1;
 	}
 
-	tlog(TLOG_DEBUG, "qdcount = %d, ancount = %d, nscount = %d, nrcount = %d, len = %d, id = %d, tc = %d, rd = %d, ra = %d, rcode = %d, payloadsize = %d\n",
+	tlog(TLOG_DEBUG,
-		 packet->head.qdcount, packet->head.ancount, packet->head.nscount, packet->head.nrcount, inpacket_len, packet->head.id, packet->head.tc,
+		 "qdcount = %d, ancount = %d, nscount = %d, nrcount = %d, len = %d, id = %d, tc = %d, rd = %d, ra = %d, rcode "
-		 packet->head.rd, packet->head.ra, packet->head.rcode, dns_get_OPT_payload_size(packet));
+		 "= %d, payloadsize = %d\n",
+		 packet->head.qdcount, packet->head.ancount, packet->head.nscount, packet->head.nrcount, inpacket_len,
+		 packet->head.id, packet->head.tc, packet->head.rd, packet->head.ra, packet->head.rcode,
+		 dns_get_OPT_payload_size(packet));
 
 	/* get question */
 	rrs = dns_get_rrs_start(packet, DNS_RRS_QD, &rr_count);
@@ -1317,7 +1414,8 @@ static int _dns_client_recv(struct dns_server_info *server_info, unsigned char *
 
 	/* notify caller dns query result */
 	if (query->callback) {
-		ret = query->callback(query->domain, DNS_QUERY_RESULT, server_info->flags.result_flag, packet, inpacket, inpacket_len, query->user_ptr);
+		ret = query->callback(query->domain, DNS_QUERY_RESULT, server_info->flags.result_flag, packet, inpacket,
+							  inpacket_len, query->user_ptr);
 		if (request_num == 0 || ret) {
 			/* if all server replied, or done, stop query, release resource */
 			_dns_client_query_remove(query);
@@ -1474,11 +1572,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) {
@@ -1602,7 +1700,8 @@ static int _dns_client_process_udp(struct dns_server_info *server_info, struct e
 		}
 	}
 
-	tlog(TLOG_DEBUG, "recv udp packet from %s, len: %d, ttl: %d", gethost_by_addr(from_host, sizeof(from_host), (struct sockaddr *)&from), len, ttl);
+	tlog(TLOG_DEBUG, "recv udp packet from %s, len: %d, ttl: %d",
+		 gethost_by_addr(from_host, sizeof(from_host), (struct sockaddr *)&from), len, ttl);
 
 	/* update recv time */
 	time(&server_info->last_recv);
@@ -1747,7 +1846,8 @@ static int _dns_client_socket_recv(struct dns_server_info *server_info)
 	if (server_info->type == DNS_SERVER_UDP) {
 		return -1;
 	} else if (server_info->type == DNS_SERVER_TCP) {
-		return recv(server_info->fd, server_info->recv_buff.data + server_info->recv_buff.len, DNS_TCP_BUFFER - server_info->recv_buff.len, 0);
+		return recv(server_info->fd, server_info->recv_buff.data + server_info->recv_buff.len,
+					DNS_TCP_BUFFER - server_info->recv_buff.len, 0);
 	} else if (server_info->type == DNS_SERVER_TLS || server_info->type == DNS_SERVER_HTTPS) {
 		return _dns_client_socket_ssl_recv(server_info->ssl, server_info->recv_buff.data + server_info->recv_buff.len,
 										   DNS_TCP_BUFFER - server_info->recv_buff.len);
@@ -1762,29 +1862,31 @@ static int _dns_client_process_tcp_buff(struct dns_server_info *server_info)
 	int dns_packet_len = 0;
 	struct http_head *http_head = NULL;
 	unsigned char *inpacket_data = NULL;
+	int ret = -1;
 
 	while (1) {
 		if (server_info->type == DNS_SERVER_HTTPS) {
 			http_head = http_head_init(4096);
 			if (http_head == NULL) {
-				goto errout;
+				goto out;
 			}
 
 			len = http_head_parse(http_head, (char *)server_info->recv_buff.data, server_info->recv_buff.len);
 			if (len < 0) {
-				tlog(TLOG_DEBUG, "remote server not supported.");
 				if (len == -1) {
-					break;
+					ret = 0;
+					goto out;
 				}
-				goto errout;
+
+				tlog(TLOG_DEBUG, "remote server not supported.");
+				goto out;
 			}
 
 			if (http_head_get_httpcode(http_head) != 200) {
-				tlog(TLOG_WARN, "http server query from %s:%d failed, server return http code : %d, %s", 
+				tlog(TLOG_WARN, "http server query from %s:%d failed, server return http code : %d, %s",
-					server_info->ip, server_info->port,
+					 server_info->ip, server_info->port, http_head_get_httpcode(http_head),
-					http_head_get_httpcode(http_head),
+					 http_head_get_httpcode_msg(http_head));
-					http_head_get_httpcode_msg(http_head));
+				goto out;
-				goto errout;
 			}
 
 			dns_packet_len = http_head_get_data_len(http_head);
@@ -1797,12 +1899,13 @@ static int _dns_client_process_tcp_buff(struct dns_server_info *server_info)
 			len = ntohs(*((unsigned short *)(inpacket_data)));
 			if (len <= 0 || len >= DNS_IN_PACKSIZE) {
 				/* data len is invalid */
-				goto errout;
+				goto out;
 			}
 
 			if (len > server_info->recv_buff.len - 2) {
 				/* len is not expceded, wait and recv */
-				break;
+				ret = 0;
+				goto out;
 			}
 
 			inpacket_data = server_info->recv_buff.data + 2;
@@ -1812,8 +1915,9 @@ static int _dns_client_process_tcp_buff(struct dns_server_info *server_info)
 
 		tlog(TLOG_DEBUG, "recv tcp packet from %s, len = %d", server_info->ip, len);
 		/* process result */
-		if (_dns_client_recv(server_info, inpacket_data, dns_packet_len, &server_info->addr, server_info->ai_addrlen) != 0) {
+		if (_dns_client_recv(server_info, inpacket_data, dns_packet_len, &server_info->addr, server_info->ai_addrlen) !=
-			goto errout;
+			0) {
+			goto out;
 		}
 
 		if (http_head) {
@@ -1822,21 +1926,26 @@ 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) {
 			memmove(server_info->recv_buff.data, server_info->recv_buff.data + len, server_info->recv_buff.len);
 		} else {
-			break;
+			ret = 0;
+			goto out;
 		}
 	}
 
-	return 0;
+	ret = 0;
-errout:
+out:
 	if (http_head) {
 		http_head_destroy(http_head);
 	}
-	return -1;
+	return ret;
 }
 
 static int _dns_client_process_tcp(struct dns_server_info *server_info, struct epoll_event *event, unsigned long now)
@@ -1880,7 +1989,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 +2026,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 +2042,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;
 		}
 	}
@@ -1980,13 +2092,15 @@ static int _dns_client_tls_matchName(const char *host, const char *pattern, int
 	if (i == size && host[j] == '\0') {
 		match = 0;
 	}
-	
+
 	return match;
 }
 
 static int _dns_client_tls_verify(struct dns_server_info *server_info)
 {
 	X509 *cert = NULL;
+	X509_PUBKEY *pubkey = NULL;
+	X509_NAME *cert_name = NULL;
 	char peer_CN[256];
 	char cert_fingerprint[256];
 	int i = 0;
@@ -2007,20 +2121,45 @@ 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);
+	if (server_info->skip_check_cert == 0) {
+		long res = SSL_get_verify_result(server_info->ssl);
+		if (res != X509_V_OK) {
+			tlog(TLOG_WARN, "peer server certificate verify failed.");
+			goto errout;
+		}
+	}
+
+	cert_name = X509_get_subject_name(cert);
+	if (cert_name == NULL) {
+		tlog(TLOG_ERROR, "get subject name failed.");
+		goto errout;
+	}
+
+	if (X509_NAME_get_text_by_NID(cert_name, NID_commonName, peer_CN, 256) == -1) {
+		tlog(TLOG_ERROR, "cannot found x509 name");
+		goto errout;
+	}
+
 	tlog(TLOG_DEBUG, "peer CN: %s", peer_CN);
 
 	/* check tls host */
 	tls_host_verify = _dns_client_server_get_tls_host_verify(server_info);
 	if (tls_host_verify) {
-		if (_dns_client_tls_matchName(peer_CN, tls_host_verify, strnlen(tls_host_verify, DNS_MAX_CNAME_LEN)) != 0) {
+		if (_dns_client_tls_matchName(tls_host_verify, peer_CN, strnlen(peer_CN, DNS_MAX_CNAME_LEN)) != 0) {
-			tlog(TLOG_INFO, "server %s CN is invalid, peer CN: %s, expect CN: %s", server_info->ip, peer_CN, tls_host_verify);
+			tlog(TLOG_INFO, "server %s CN is invalid, peer CN: %s, expect CN: %s", server_info->ip, peer_CN,
+				 tls_host_verify);
 			goto errout;
 		}
 	}
 
+	pubkey = X509_get_X509_PUBKEY(cert);
+	if (pubkey == NULL) {
+		tlog(TLOG_ERROR, "get pub key failed.");
+		goto errout;
+	}
+
 	/* get spki pin */
-	key_len = i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), NULL);
+	key_len = i2d_X509_PUBKEY(pubkey, NULL);
 	if (key_len <= 0) {
 		tlog(TLOG_ERROR, "get x509 public key failed.");
 		goto errout;
@@ -2033,7 +2172,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 +2195,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 +2250,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 +2286,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;
 		}
 	}
@@ -2290,11 +2429,11 @@ static int _dns_client_send_tls(struct dns_server_info *server_info, void *packe
 
 	send_len = _dns_client_socket_ssl_send(server_info->ssl, inpacket, len);
 	if (send_len < 0) {
-		if (errno == EAGAIN || errno == EPIPE || server_info->ssl == NULL ) {
+		if (errno == EAGAIN || errno == EPIPE || server_info->ssl == NULL) {
 			/* save data to buffer, and retry when EPOLLOUT is available */
 			return _dns_client_send_data_to_buffer(server_info, inpacket, len);
 		} else if (server_info->ssl && errno != ENOMEM) {
-			SSL_shutdown(server_info->ssl);
+			SSL_set_shutdown(server_info->ssl, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
 		}
 		return -1;
 	} else if (send_len < len) {
@@ -2340,11 +2479,11 @@ static int _dns_client_send_https(struct dns_server_info *server_info, void *pac
 
 	send_len = _dns_client_socket_ssl_send(server_info->ssl, inpacket, http_len);
 	if (send_len < 0) {
-		if (errno == EAGAIN || errno == EPIPE || server_info->ssl == NULL ) {
+		if (errno == EAGAIN || errno == EPIPE || server_info->ssl == NULL) {
 			/* save data to buffer, and retry when EPOLLOUT is available */
 			return _dns_client_send_data_to_buffer(server_info, inpacket, http_len);
 		} else if (server_info->ssl && errno != ENOMEM) {
-			SSL_shutdown(server_info->ssl);
+			SSL_set_shutdown(server_info->ssl, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
 		}
 		return -1;
 	} else if (send_len < http_len) {
@@ -2407,9 +2546,11 @@ static int _dns_client_send_packet(struct dns_query_struct *query, void *packet,
 
 		if (ret != 0) {
 			if (send_err != ENOMEM) {
-				tlog(TLOG_ERROR, "send query to %s failed, %s, type: %d", server_info->ip, strerror(send_err), server_info->type);
+				tlog(TLOG_ERROR, "send query to %s failed, %s, type: %d", server_info->ip, strerror(send_err),
+					 server_info->type);
 			} else {
-				tlog(TLOG_DEBUG, "send query to %s failed, %s, type: %d", server_info->ip, strerror(send_err), server_info->type);
+				tlog(TLOG_DEBUG, "send query to %s failed, %s, type: %d", server_info->ip, strerror(send_err),
+					 server_info->type);
 			}
 			atomic_dec(&query->dns_request_sent);
 			continue;
@@ -2586,29 +2727,32 @@ static void _dns_client_check_servers(void)
 	pthread_mutex_unlock(&client.server_list_lock);
 }
 
-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)
+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;
 		pending->ping_time_v4 = -1;
 		if (rtcode == DNS_RC_NOERROR) {
+			pending->has_v4 = 1;
 			pending->ping_time_v4 = ping_time;
 			safe_strncpy(pending->ipv4, ip, DNS_HOSTNAME_LEN);
 		}
 	} else if (addr_type == DNS_T_AAAA) {
-		pending->has_v6 = 1;
 		pending->ping_time_v6 = -1;
 		if (rtcode == DNS_RC_NOERROR) {
+			pending->has_v6 = 1;
 			pending->ping_time_v6 = ping_time;
 			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)
@@ -2641,37 +2785,61 @@ static void _dns_client_add_pending_servers(void)
 	if (++dely < 3) {
 		return;
 	}
+	dely = 0;
 
 	pthread_mutex_lock(&pending_server_mutex);
 	list_for_each_entry_safe(pending, tmp, &pending_servers, list)
 	{
 		/* send dns type A, AAAA query to bootstrap DNS server */
+		int add_success = 0;
+		char *dnsserver_ip = NULL;
+
 		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_server_query(pending->host, DNS_T_AAAA, _dns_client_pending_server_resolve, pending);
+			_dns_client_server_pending_get(pending);
+			if (dns_server_query(pending->host, DNS_T_AAAA, _dns_client_pending_server_resolve, pending) != 0) {
+				_dns_client_server_pending_release_lck(pending);
+			}
 		}
 
 		/* if both A, AAAA has query result, select fastest IP address */
 		if (pending->has_v4 && pending->has_v6) {
-			char *ip = NULL;
-			if (pending->ping_time_v4 <= pending->ping_time_v6 && pending->ipv4[0]) {
-				ip = pending->ipv4;
-			} else {
-				ip = pending->ipv6;
-			}
 
-			if (ip[0]) {
+			if (pending->ping_time_v4 <= pending->ping_time_v6 && pending->ipv4[0]) {
-				if (_dns_client_add_pendings(pending, ip) != 0) {
+				dnsserver_ip = pending->ipv4;
-					tlog(TLOG_WARN, "add pending DNS server %s failed.", pending->host);
+			} else {
-				}
+				dnsserver_ip = pending->ipv6;
 			}
-			list_del_init(&pending->list);
+		} else if (pending->has_v4) {
-			free(pending);
+			dnsserver_ip = pending->ipv4;
+		} else if (pending->has_v6) {
+			dnsserver_ip = pending->ipv6;
+		}
+
+		if (dnsserver_ip && dnsserver_ip[0]) {
+			if (_dns_client_add_pendings(pending, dnsserver_ip) == 0) {
+				add_success = 1;
+			}
+		}
+
+		pending->retry_cnt++;
+		if (pending->retry_cnt >= DNS_PENDING_SERVER_RETRY || add_success) {
+			if (add_success == 0) {
+				tlog(TLOG_WARN, "add pending DNS server %s failed.", pending->host);
+			}
+			_dns_client_server_pending_release_lck(pending);
+		} else {
+			tlog(TLOG_DEBUG, "add pending DNS server %s failed, retry %d...", pending->host, pending->retry_cnt);
+			pending->query_v4 = 0;
+			pending->query_v6 = 0;
 		}
 
 		/* if has no bootstrap DNS, just call getaddrinfo to get address */
@@ -2682,8 +2850,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_client.h

@@ -52,8 +52,9 @@ int dns_client_init(void);
 int dns_client_set_ecs(char *ip, int subnet);
 
 /* query result notify function */
-typedef int (*dns_client_callback)(char *domain, dns_result_type rtype, unsigned int result_flag, struct dns_packet *packet, unsigned char *inpacket,
+typedef int (*dns_client_callback)(char *domain, dns_result_type rtype, unsigned int result_flag,
-								   int inpacket_len, void *user_ptr);
+								   struct dns_packet *packet, unsigned char *inpacket, int inpacket_len,
+								   void *user_ptr);
 
 /* query domain */
 int dns_client_query(char *domain, int qtype, dns_client_callback callback, void *user_ptr, const char *group_name);
@@ -69,6 +70,7 @@ struct client_dns_server_flag_tls {
 	int spi_len;
 	char hostname[DNS_MAX_CNAME_LEN];
 	char tls_host_verify[DNS_MAX_CNAME_LEN];
+	char skip_check_cert;
 };
 
 struct client_dns_server_flag_https {
@@ -78,6 +80,7 @@ struct client_dns_server_flag_https {
 	char httphost[DNS_MAX_CNAME_LEN];
 	char path[DNS_MAX_CNAME_LEN];
 	char tls_host_verify[DNS_MAX_CNAME_LEN];
+	char skip_check_cert;
 };
 
 struct client_dns_server_flags {
@@ -95,7 +98,8 @@ struct client_dns_server_flags {
 int dns_client_spki_decode(const char *spki, unsigned char *spki_data_out);
 
 /* add remote dns server */
-int dns_client_add_server(char *server_ip, int port, dns_server_type_t server_type, struct client_dns_server_flags *flags);
+int dns_client_add_server(char *server_ip, int port, dns_server_type_t server_type,
+						  struct client_dns_server_flags *flags);
 
 /* remove remote dns server */
 int dns_client_remove_server(char *server_ip, int port, dns_server_type_t server_type);

src/dns_conf.h

@@ -1,247 +1,255 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#ifndef _DNS_CONF
+#ifndef _DNS_CONF
-#define _DNS_CONF
+#define _DNS_CONF
-
+
-#include "art.h"
+#include "art.h"
-#include "conf.h"
+#include "conf.h"
-#include "dns.h"
+#include "dns.h"
-#include "dns_client.h"
+#include "dns_client.h"
-#include "hash.h"
+#include "hash.h"
-#include "hashtable.h"
+#include "hashtable.h"
-#include "list.h"
+#include "list.h"
-#include "radix.h"
+#include "radix.h"
-
+
-#ifdef __cpluscplus
+#ifdef __cpluscplus
-extern "C" {
+extern "C" {
-#endif
+#endif
-
+
-#define DNS_MAX_BIND_IP 16
+#define DNS_MAX_BIND_IP 16
-#define DNS_MAX_SERVERS 64
+#define DNS_MAX_SERVERS 64
-#define DNS_MAX_SERVER_NAME_LEN 128
+#define DNS_MAX_SERVER_NAME_LEN 128
-#define DNS_MAX_IPSET_NAMELEN 32
+#define DNS_MAX_IPSET_NAMELEN 32
-#define DNS_GROUP_NAME_LEN 32
+#define DNS_GROUP_NAME_LEN 32
-#define DNS_NAX_GROUP_NUMBER 16
+#define DNS_NAX_GROUP_NUMBER 16
-#define DNS_MAX_IPLEN 64
+#define DNS_MAX_IPLEN 64
-#define DNS_MAX_SPKI_LEN 64
+#define DNS_MAX_SPKI_LEN 64
-#define DNS_MAX_URL_LEN 256
+#define DNS_MAX_URL_LEN 256
-#define DNS_MAX_PATH 1024
+#define DNS_MAX_PATH 1024
-#define DEFAULT_DNS_PORT 53
+#define DEFAULT_DNS_PORT 53
-#define DEFAULT_DNS_TLS_PORT 853
+#define DEFAULT_DNS_TLS_PORT 853
-#define DEFAULT_DNS_HTTPS_PORT 443
+#define DEFAULT_DNS_HTTPS_PORT 443
-#define DNS_MAX_CONF_CNAME_LEN 256
+#define DNS_MAX_CONF_CNAME_LEN 256
-#define SMARTDNS_CONF_FILE "/etc/smartdns/smartdns.conf"
+#define SMARTDNS_CONF_FILE "/etc/smartdns/smartdns.conf"
-#define SMARTDNS_LOG_FILE "/var/log/smartdns.log"
+#define SMARTDNS_LOG_FILE "/var/log/smartdns.log"
-#define SMARTDNS_AUDIT_FILE "/var/log/smartdns-audit.log"
+#define SMARTDNS_AUDIT_FILE "/var/log/smartdns-audit.log"
-
+
-enum domain_rule {
+enum domain_rule {
-	DOMAIN_RULE_FLAGS = 0,
+	DOMAIN_RULE_FLAGS = 0,
-	DOMAIN_RULE_ADDRESS_IPV4,
+	DOMAIN_RULE_ADDRESS_IPV4,
-	DOMAIN_RULE_ADDRESS_IPV6,
+	DOMAIN_RULE_ADDRESS_IPV6,
-	DOMAIN_RULE_IPSET,
+	DOMAIN_RULE_IPSET,
-	DOMAIN_RULE_NAMESERVER,
+	DOMAIN_RULE_NAMESERVER,
-	DOMAIN_RULE_MAX,
+	DOMAIN_RULE_CHECKSPEED,
-};
+	DOMAIN_RULE_MAX,
-
+};
-typedef enum {
+
-	DNS_BIND_TYPE_UDP,
+typedef enum {
-	DNS_BIND_TYPE_TCP,
+	DNS_BIND_TYPE_UDP,
-	DNS_BIND_TYPE_TLS,
+	DNS_BIND_TYPE_TCP,
-} DNS_BIND_TYPE;
+	DNS_BIND_TYPE_TLS,
-
+} DNS_BIND_TYPE;
-#define DOMAIN_CHECK_NONE 0
+
-#define DOMAIN_CHECK_ICMP 1
+#define DOMAIN_CHECK_NONE 0
-#define DOMAIN_CHECK_TCP 2
+#define DOMAIN_CHECK_ICMP 1
-#define DOMAIN_CHECK_NUM 2
+#define DOMAIN_CHECK_TCP 2
-
+#define DOMAIN_CHECK_NUM 2
-#define DOMAIN_FLAG_ADDR_SOA (1 << 0)
+
-#define DOMAIN_FLAG_ADDR_IPV4_SOA (1 << 1)
+#define DOMAIN_FLAG_ADDR_SOA (1 << 0)
-#define DOMAIN_FLAG_ADDR_IPV6_SOA (1 << 2)
+#define DOMAIN_FLAG_ADDR_IPV4_SOA (1 << 1)
-#define DOMAIN_FLAG_ADDR_IGN (1 << 3)
+#define DOMAIN_FLAG_ADDR_IPV6_SOA (1 << 2)
-#define DOMAIN_FLAG_ADDR_IPV4_IGN (1 << 4)
+#define DOMAIN_FLAG_ADDR_IGN (1 << 3)
-#define DOMAIN_FLAG_ADDR_IPV6_IGN (1 << 5)
+#define DOMAIN_FLAG_ADDR_IPV4_IGN (1 << 4)
-#define DOMAIN_FLAG_IPSET_IGNORE (1 << 6)
+#define DOMAIN_FLAG_ADDR_IPV6_IGN (1 << 5)
-#define DOMAIN_FLAG_NAMESERVER_IGNORE (1 << 7)
+#define DOMAIN_FLAG_IPSET_IGNORE (1 << 6)
-
+#define DOMAIN_FLAG_NAMESERVER_IGNORE (1 << 7)
-#define SERVER_FLAG_EXCLUDE_DEFAULT (1 << 0)
+
-
+#define SERVER_FLAG_EXCLUDE_DEFAULT (1 << 0)
-#define BIND_FLAG_NO_RULE_ADDR (1 << 0)
+
-#define BIND_FLAG_NO_RULE_NAMESERVER (1 << 1)
+#define BIND_FLAG_NO_RULE_ADDR (1 << 0)
-#define BIND_FLAG_NO_RULE_IPSET (1 << 2)
+#define BIND_FLAG_NO_RULE_NAMESERVER (1 << 1)
-#define BIND_FLAG_NO_RULE_SNIPROXY (1 << 3)
+#define BIND_FLAG_NO_RULE_IPSET (1 << 2)
-#define BIND_FLAG_NO_RULE_SOA (1 << 4)
+#define BIND_FLAG_NO_RULE_SNIPROXY (1 << 3)
-#define BIND_FLAG_NO_SPEED_CHECK (1 << 5)
+#define BIND_FLAG_NO_RULE_SOA (1 << 4)
-#define BIND_FLAG_NO_CACHE (1 << 6)
+#define BIND_FLAG_NO_SPEED_CHECK (1 << 5)
-#define BIND_FLAG_NO_DUALSTACK_SELECTION (1 << 7)
+#define BIND_FLAG_NO_CACHE (1 << 6)
-
+#define BIND_FLAG_NO_DUALSTACK_SELECTION (1 << 7)
-struct dns_rule_flags {
+#define BIND_FLAG_FORCE_AAAA_SOA (1 << 8) 
-	unsigned int flags;
+
-};
+struct dns_rule_flags {
-
+	unsigned int flags;
-struct dns_address_IPV4 {
+};
-	unsigned char ipv4_addr[DNS_RR_A_LEN];
+
-};
+struct dns_address_IPV4 {
-
+	unsigned char ipv4_addr[DNS_RR_A_LEN];
-struct dns_address_IPV6 {
+};
-	unsigned char ipv6_addr[DNS_RR_AAAA_LEN];
+
-};
+struct dns_address_IPV6 {
-
+	unsigned char ipv6_addr[DNS_RR_AAAA_LEN];
-struct dns_ipset_name {
+};
-	struct hlist_node node;
+
-	char ipsetname[DNS_MAX_IPSET_NAMELEN];
+struct dns_ipset_name {
-};
+	struct hlist_node node;
-
+	char ipsetname[DNS_MAX_IPSET_NAMELEN];
-struct dns_ipset_rule {
+};
-	const char *ipsetname;
+
-};
+struct dns_ipset_rule {
-
+	const char *ipsetname;
-struct dns_domain_rule {
+};
-	void *rules[DOMAIN_RULE_MAX];
+
-};
+struct dns_domain_rule {
-
+	void *rules[DOMAIN_RULE_MAX];
-struct dns_nameserver_rule {
+};
-	const char *group_name;
+
-};
+struct dns_nameserver_rule {
-
+	const char *group_name;
-struct dns_server_groups {
+};
-	struct hlist_node node;
+
-	char group_name[DNS_GROUP_NAME_LEN];
+struct dns_server_groups {
-	int server_num;
+	struct hlist_node node;
-	struct dns_servers *servers[DNS_MAX_SERVERS];
+	char group_name[DNS_GROUP_NAME_LEN];
-};
+	int server_num;
-
+	struct dns_servers *servers[DNS_MAX_SERVERS];
-struct dns_domain_check_order {
+};
-	char order[DOMAIN_CHECK_NUM];
+
-	unsigned short tcp_port;
+struct dns_domain_check_order {
-};
+	char order[DOMAIN_CHECK_NUM];
-
+	unsigned short tcp_port;
-struct dns_group_table {
+};
-	DECLARE_HASHTABLE(group, 8);
+
-};
+struct dns_group_table {
-extern struct dns_group_table dns_group_table;
+	DECLARE_HASHTABLE(group, 8);
-
+};
-struct dns_servers {
+extern struct dns_group_table dns_group_table;
-	char server[DNS_MAX_IPLEN];
+
-	unsigned short port;
+struct dns_servers {
-	unsigned int result_flag;
+	char server[DNS_MAX_IPLEN];
-	unsigned int server_flag;
+	unsigned short port;
-	int ttl;
+	unsigned int result_flag;
-	dns_server_type_t type;
+	unsigned int server_flag;
-	char spki[DNS_MAX_SPKI_LEN];
+	int ttl;
-	char hostname[DNS_MAX_CNAME_LEN];
+	dns_server_type_t type;
-	char httphost[DNS_MAX_CNAME_LEN];
+	char skip_check_cert;
-	char tls_host_verify[DNS_MAX_CNAME_LEN];
+	char spki[DNS_MAX_SPKI_LEN];
-	char path[DNS_MAX_URL_LEN];
+	char hostname[DNS_MAX_CNAME_LEN];
-};
+	char httphost[DNS_MAX_CNAME_LEN];
-
+	char tls_host_verify[DNS_MAX_CNAME_LEN];
-/* ip address lists of domain */
+	char path[DNS_MAX_URL_LEN];
-struct dns_bogus_ip_address {
+};
-	struct hlist_node node;
+
-	dns_type_t addr_type;
+/* ip address lists of domain */
-	union {
+struct dns_bogus_ip_address {
-		unsigned char ipv4_addr[DNS_RR_A_LEN];
+	struct hlist_node node;
-		unsigned char ipv6_addr[DNS_RR_AAAA_LEN];
+	dns_type_t addr_type;
-		unsigned char addr[0];
+	union {
-	};
+		unsigned char ipv4_addr[DNS_RR_A_LEN];
-};
+		unsigned char ipv6_addr[DNS_RR_AAAA_LEN];
-
+		unsigned char addr[0];
-enum address_rule {
+	};
-	ADDRESS_RULE_BLACKLIST = 1,
+};
-	ADDRESS_RULE_WHITELIST = 2,
+
-	ADDRESS_RULE_BOGUS = 3,
+enum address_rule {
-	ADDRESS_RULE_IP_IGNORE = 4,
+	ADDRESS_RULE_BLACKLIST = 1,
-};
+	ADDRESS_RULE_WHITELIST = 2,
-
+	ADDRESS_RULE_BOGUS = 3,
-struct dns_ip_address_rule {
+	ADDRESS_RULE_IP_IGNORE = 4,
-	unsigned int blacklist : 1;
+};
-	unsigned int whitelist : 1;
+
-	unsigned int bogus : 1;
+struct dns_ip_address_rule {
-	unsigned int ip_ignore : 1;
+	unsigned int blacklist : 1;
-};
+	unsigned int whitelist : 1;
-
+	unsigned int bogus : 1;
-struct dns_edns_client_subnet {
+	unsigned int ip_ignore : 1;
-	int enable;
+};
-	char ip[DNS_MAX_IPLEN];
+
-	int subnet;
+struct dns_edns_client_subnet {
-};
+	int enable;
-
+	char ip[DNS_MAX_IPLEN];
-struct dns_conf_address_rule {
+	int subnet;
-	radix_tree_t *ipv4;
+};
-	radix_tree_t *ipv6;
+
-};
+struct dns_conf_address_rule {
-
+	radix_tree_t *ipv4;
-struct dns_bind_ip {
+	radix_tree_t *ipv6;
-	DNS_BIND_TYPE type;
+};
-	uint32_t flags;
+
-	char ip[DNS_MAX_IPLEN];
+struct dns_bind_ip {
-	const char *group;
+	DNS_BIND_TYPE type;
-};
+	uint32_t flags;
-
+	char ip[DNS_MAX_IPLEN];
-extern struct dns_bind_ip dns_conf_bind_ip[DNS_MAX_BIND_IP];
+	const char *group;
-extern int dns_conf_bind_ip_num;
+};
-
+
-extern int dns_conf_tcp_idle_time;
+extern struct dns_bind_ip dns_conf_bind_ip[DNS_MAX_BIND_IP];
-extern int dns_conf_cachesize;
+extern int dns_conf_bind_ip_num;
-extern int dns_conf_prefetch;
+
-extern struct dns_servers dns_conf_servers[DNS_MAX_SERVERS];
+extern int dns_conf_tcp_idle_time;
-extern int dns_conf_server_num;
+extern int dns_conf_cachesize;
-
+extern int dns_conf_prefetch;
-extern int dns_conf_log_level;
+extern int dns_conf_serve_expired;
-extern char dns_conf_log_file[DNS_MAX_PATH];
+extern int dns_conf_serve_expired_ttl;
-extern size_t dns_conf_log_size;
+extern struct dns_servers dns_conf_servers[DNS_MAX_SERVERS];
-extern int dns_conf_log_num;
+extern int dns_conf_server_num;
-
+
-extern struct dns_domain_check_order dns_conf_check_order;
+extern int dns_conf_log_level;
-
+extern char dns_conf_log_file[DNS_MAX_PATH];
-extern struct dns_server_groups dns_conf_server_groups[DNS_NAX_GROUP_NUMBER];
+extern size_t dns_conf_log_size;
-extern int dns_conf_server_group_num;
+extern int dns_conf_log_num;
-
+
-extern int dns_conf_audit_enable;
+extern char dns_conf_ca_file[DNS_MAX_PATH];
-extern int dns_conf_audit_log_SOA;
+extern char dns_conf_ca_path[DNS_MAX_PATH];
-extern char dns_conf_audit_file[DNS_MAX_PATH];
+
-extern size_t dns_conf_audit_size;
+extern struct dns_domain_check_order dns_conf_check_order;
-extern int dns_conf_audit_num;
+
-
+extern struct dns_server_groups dns_conf_server_groups[DNS_NAX_GROUP_NUMBER];
-extern char dns_conf_server_name[DNS_MAX_SERVER_NAME_LEN];
+extern int dns_conf_server_group_num;
-extern art_tree dns_conf_domain_rule;
+
-extern struct dns_conf_address_rule dns_conf_address_rule;
+extern int dns_conf_audit_enable;
-
+extern int dns_conf_audit_log_SOA;
-extern int dns_conf_dualstack_ip_selection;
+extern char dns_conf_audit_file[DNS_MAX_PATH];
-extern int dns_conf_dualstack_ip_selection_threshold;
+extern size_t dns_conf_audit_size;
-
+extern int dns_conf_audit_num;
-extern int dns_conf_rr_ttl;
+
-extern int dns_conf_rr_ttl_min;
+extern char dns_conf_server_name[DNS_MAX_SERVER_NAME_LEN];
-extern int dns_conf_rr_ttl_max;
+extern art_tree dns_conf_domain_rule;
-extern int dns_conf_force_AAAA_SOA;
+extern struct dns_conf_address_rule dns_conf_address_rule;
-extern int dns_conf_ipset_timeout_enable;
+
-
+extern int dns_conf_dualstack_ip_selection;
-extern struct dns_edns_client_subnet dns_conf_ipv4_ecs;
+extern int dns_conf_dualstack_ip_selection_threshold;
-extern struct dns_edns_client_subnet dns_conf_ipv6_ecs;
+
-
+extern int dns_conf_rr_ttl;
-extern char dns_conf_sni_proxy_ip[DNS_MAX_IPLEN];
+extern int dns_conf_rr_ttl_min;
-
+extern int dns_conf_rr_ttl_max;
-void dns_server_load_exit(void);
+extern int dns_conf_force_AAAA_SOA;
-
+extern int dns_conf_ipset_timeout_enable;
-int dns_server_load_conf(const char *file);
+
-
+extern struct dns_edns_client_subnet dns_conf_ipv4_ecs;
-extern int config_addtional_file(void *data, int argc, char *argv[]);
+extern struct dns_edns_client_subnet dns_conf_ipv6_ecs;
-#ifdef __cpluscplus
+
-}
+extern char dns_conf_sni_proxy_ip[DNS_MAX_IPLEN];
-#endif
+
-#endif // !_DNS_CONF
+void dns_server_load_exit(void);
+
+int dns_server_load_conf(const char *file);
+
+extern int config_addtional_file(void *data, int argc, char *argv[]);
+#ifdef __cpluscplus
+}
+#endif
+#endif // !_DNS_CONF

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];
@@ -294,12 +299,15 @@ static void _dns_server_audit_log(struct dns_request *request)
 	}
 
 	if (request->qtype == DNS_T_AAAA && request->has_ipv6) {
-		snprintf(req_result, sizeof(req_result), "%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", request->ipv6_addr[0],
+		snprintf(req_result, sizeof(req_result),
-				 request->ipv6_addr[1], request->ipv6_addr[2], request->ipv6_addr[3], request->ipv6_addr[4], request->ipv6_addr[5], request->ipv6_addr[6],
+				 "%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", request->ipv6_addr[0],
-				 request->ipv6_addr[7], request->ipv6_addr[8], request->ipv6_addr[9], request->ipv6_addr[10], request->ipv6_addr[11], request->ipv6_addr[12],
+				 request->ipv6_addr[1], request->ipv6_addr[2], request->ipv6_addr[3], request->ipv6_addr[4],
+				 request->ipv6_addr[5], request->ipv6_addr[6], request->ipv6_addr[7], request->ipv6_addr[8],
+				 request->ipv6_addr[9], request->ipv6_addr[10], request->ipv6_addr[11], request->ipv6_addr[12],
 				 request->ipv6_addr[13], request->ipv6_addr[14], request->ipv6_addr[15]);
 	} else if (request->qtype == DNS_T_A && request->has_ipv4) {
-		snprintf(req_result, sizeof(req_result), "%d.%d.%d.%d", request->ipv4_addr[0], request->ipv4_addr[1], request->ipv4_addr[2], request->ipv4_addr[3]);
+		snprintf(req_result, sizeof(req_result), "%d.%d.%d.%d", request->ipv4_addr[0], request->ipv4_addr[1],
+				 request->ipv4_addr[2], request->ipv4_addr[3]);
 	} else if (request->has_soa) {
 		if (!dns_conf_audit_log_SOA) {
 			return;
@@ -312,9 +320,11 @@ static void _dns_server_audit_log(struct dns_request *request)
 	gethost_by_addr(req_host, sizeof(req_host), &request->addr);
 	tlog_localtime(&tm);
 
-	snprintf(req_time, sizeof(req_time), "[%.4d-%.2d-%.2d %.2d:%.2d:%.2d,%.3d]", tm.year, tm.mon, tm.mday, tm.hour, tm.min, tm.sec, tm.usec / 1000);
+	snprintf(req_time, sizeof(req_time), "[%.4d-%.2d-%.2d %.2d:%.2d:%.2d,%.3d]", tm.year, tm.mon, tm.mday, tm.hour,
+			 tm.min, tm.sec, tm.usec / 1000);
 
-	tlog_printf(dns_audit, "%s %s query %s, type %d, result %s\n", req_time, req_host, request->domain, request->qtype, req_result);
+	tlog_printf(dns_audit, "%s %s query %s, type %d, result %s\n", req_time, req_host, request->domain, request->qtype,
+				req_result);
 }
 
 static int _dns_add_rrs(struct dns_packet *packet, struct dns_request *request)
@@ -432,7 +442,8 @@ static int _dns_server_reply_tcp_to_buffer(struct dns_server_conn_tcp_client *tc
 	return 0;
 }
 
-static int _dns_server_reply_tcp(struct dns_request *request, struct dns_server_conn_tcp_client *tcpclient, void *packet, unsigned short len)
+static int _dns_server_reply_tcp(struct dns_request *request, struct dns_server_conn_tcp_client *tcpclient,
+								 void *packet, unsigned short len)
 {
 	int send_len = 0;
 	unsigned char inpacket_data[DNS_IN_PACKSIZE];
@@ -460,10 +471,12 @@ static int _dns_server_reply_tcp(struct dns_request *request, struct dns_server_
 	return 0;
 }
 
-static int _dns_server_reply_udp(struct dns_request *request, struct dns_server_conn_udp *udpserver, unsigned char *inpacket, int inpacket_len)
+static int _dns_server_reply_udp(struct dns_request *request, struct dns_server_conn_udp *udpserver,
+								 unsigned char *inpacket, int inpacket_len)
 {
 	int send_len = 0;
-	send_len = sendto(udpserver->head.fd, inpacket, inpacket_len, 0, (struct sockaddr *)&request->addr, request->addr_len);
+	send_len =
+		sendto(udpserver->head.fd, inpacket, inpacket_len, 0, (struct sockaddr *)&request->addr, request->addr_len);
 	if (send_len != inpacket_len) {
 		tlog(TLOG_ERROR, "send failed.");
 		return -1;
@@ -548,6 +561,19 @@ 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,34 +583,42 @@ 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) {
 			goto out;
 		}
 
-		sprintf(ip, "%d.%d.%d.%d", request->ipv4_addr[0], request->ipv4_addr[1], request->ipv4_addr[2], request->ipv4_addr[3]);
+		sprintf(ip, "%d.%d.%d.%d", request->ipv4_addr[0], request->ipv4_addr[1], request->ipv4_addr[2],
+				request->ipv4_addr[3]);
 		ping_time = request->ping_ttl_v4;
-		return request->result_callback(request->domain, request->rcode, request->qtype, ip, ping_time, request->user_ptr);
+		return request->result_callback(request->domain, request->rcode, request->qtype, ip, ping_time,
+										request->user_ptr);
 	} else if (request->qtype == DNS_T_AAAA) {
 		if (request->has_ipv6 == 0) {
 			goto out;
 		}
 
-		sprintf(ip, "%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", request->ipv6_addr[0], request->ipv6_addr[1],
+		sprintf(ip, "%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", request->ipv6_addr[0],
-				request->ipv6_addr[2], request->ipv6_addr[3], request->ipv6_addr[4], request->ipv6_addr[5], request->ipv6_addr[6], request->ipv6_addr[7],
+				request->ipv6_addr[1], request->ipv6_addr[2], request->ipv6_addr[3], request->ipv6_addr[4],
-				request->ipv6_addr[8], request->ipv6_addr[9], request->ipv6_addr[10], request->ipv6_addr[11], request->ipv6_addr[12], request->ipv6_addr[13],
+				request->ipv6_addr[5], request->ipv6_addr[6], request->ipv6_addr[7], request->ipv6_addr[8],
-				request->ipv6_addr[14], request->ipv6_addr[15]);
+				request->ipv6_addr[9], request->ipv6_addr[10], request->ipv6_addr[11], request->ipv6_addr[12],
+				request->ipv6_addr[13], request->ipv6_addr[14], request->ipv6_addr[15]);
 		ping_time = request->ping_ttl_v6;
-		return request->result_callback(request->domain, request->rcode, request->qtype, ip, ping_time, request->user_ptr);
+		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;
 }
 
@@ -672,8 +706,8 @@ static int _dns_server_request_complete_A(struct dns_request *request)
 		return 0;
 	}
 
-	tlog(TLOG_INFO, "result: %s, rcode: %d,  %d.%d.%d.%d\n", request->domain, request->rcode, request->ipv4_addr[0], request->ipv4_addr[1],
+	tlog(TLOG_INFO, "result: %s, rcode: %d,  %d.%d.%d.%d\n", request->domain, request->rcode, request->ipv4_addr[0],
-		 request->ipv4_addr[2], request->ipv4_addr[3]);
+		 request->ipv4_addr[1], request->ipv4_addr[2], request->ipv4_addr[3]);
 
 	request->has_soa = 0;
 	if (request->has_ping_result == 0 && request->ttl_v4 > DNS_SERVER_TMOUT_TTL) {
@@ -686,10 +720,12 @@ static int _dns_server_request_complete_A(struct dns_request *request)
 
 	/* if doing prefetch, update cache only */
 	if (request->prefetch) {
-		dns_cache_replace(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr, DNS_RR_A_LEN, request->ping_ttl_v4);
+		dns_cache_replace(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr, DNS_RR_A_LEN,
+						  request->ping_ttl_v4);
 	} else {
 		/* insert result to cache */
-		dns_cache_insert(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr, DNS_RR_A_LEN, request->ping_ttl_v4);
+		dns_cache_insert(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr, DNS_RR_A_LEN,
+						 request->ping_ttl_v4);
 	}
 
 	return 0;
@@ -706,10 +742,13 @@ static int _dns_server_request_complete_AAAA(struct dns_request *request)
 	}
 
 	if (request->has_ipv6) {
-		tlog(TLOG_INFO, "result: %s, rcode: %d,  %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", request->domain, request->rcode,
+		tlog(TLOG_INFO,
-			 request->ipv6_addr[0], request->ipv6_addr[1], request->ipv6_addr[2], request->ipv6_addr[3], request->ipv6_addr[4], request->ipv6_addr[5],
+			 "result: %s, rcode: %d,  %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x",
-			 request->ipv6_addr[6], request->ipv6_addr[7], request->ipv6_addr[8], request->ipv6_addr[9], request->ipv6_addr[10], request->ipv6_addr[11],
+			 request->domain, request->rcode, request->ipv6_addr[0], request->ipv6_addr[1], request->ipv6_addr[2],
-			 request->ipv6_addr[12], request->ipv6_addr[13], request->ipv6_addr[14], request->ipv6_addr[15]);
+			 request->ipv6_addr[3], request->ipv6_addr[4], request->ipv6_addr[5], request->ipv6_addr[6],
+			 request->ipv6_addr[7], request->ipv6_addr[8], request->ipv6_addr[9], request->ipv6_addr[10],
+			 request->ipv6_addr[11], request->ipv6_addr[12], request->ipv6_addr[13], request->ipv6_addr[14],
+			 request->ipv6_addr[15]);
 
 		if (request->has_ping_result == 0 && request->ttl_v6 > DNS_SERVER_TMOUT_TTL) {
 			request->ttl_v6 = DNS_SERVER_TMOUT_TTL;
@@ -718,10 +757,12 @@ static int _dns_server_request_complete_AAAA(struct dns_request *request)
 		/* if doing prefetch, update cache only */
 		if (_dns_server_has_bind_flag(request, BIND_FLAG_NO_CACHE) != 0) {
 			if (request->prefetch) {
-				dns_cache_replace(request->domain, cname, cname_ttl, request->ttl_v6, DNS_T_AAAA, request->ipv6_addr, DNS_RR_AAAA_LEN, request->ping_ttl_v6);
+				dns_cache_replace(request->domain, cname, cname_ttl, request->ttl_v6, DNS_T_AAAA, request->ipv6_addr,
+								  DNS_RR_AAAA_LEN, request->ping_ttl_v6);
 			} else {
 				/* insert result to cache */
-				dns_cache_insert(request->domain, cname, cname_ttl, request->ttl_v6, DNS_T_AAAA, request->ipv6_addr, DNS_RR_AAAA_LEN, request->ping_ttl_v6);
+				dns_cache_insert(request->domain, cname, cname_ttl, request->ttl_v6, DNS_T_AAAA, request->ipv6_addr,
+								 DNS_RR_AAAA_LEN, request->ping_ttl_v6);
 			}
 		}
 
@@ -729,17 +770,20 @@ static int _dns_server_request_complete_AAAA(struct dns_request *request)
 	}
 
 	if (request->has_ipv4 && (request->ping_ttl_v4 > 0)) {
-		tlog(TLOG_INFO, "result: %s, rcode: %d,  %d.%d.%d.%d\n", request->domain, request->rcode, request->ipv4_addr[0], request->ipv4_addr[1],
+		tlog(TLOG_INFO, "result: %s, rcode: %d,  %d.%d.%d.%d\n", request->domain, request->rcode, request->ipv4_addr[0],
-			 request->ipv4_addr[2], request->ipv4_addr[3]);
+			 request->ipv4_addr[1], request->ipv4_addr[2], request->ipv4_addr[3]);
 
 		/* if ipv4 is fasting than ipv6, add ipv4 to cache, and return SOA for AAAA request */
-		if ((request->ping_ttl_v4 + (dns_conf_dualstack_ip_selection_threshold * 10)) < request->ping_ttl_v6 || request->ping_ttl_v6 < 0) {
+		if ((request->ping_ttl_v4 + (dns_conf_dualstack_ip_selection_threshold * 10)) < request->ping_ttl_v6 ||
+			request->ping_ttl_v6 < 0) {
 			tlog(TLOG_DEBUG, "Force IPV4 perfered.");
 			if (_dns_server_has_bind_flag(request, BIND_FLAG_NO_CACHE) != 0) {
 				if (request->prefetch) {
-					dns_cache_replace(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr, DNS_RR_A_LEN, request->ping_ttl_v4);
+					dns_cache_replace(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr,
+									  DNS_RR_A_LEN, request->ping_ttl_v4);
 				} else {
-					dns_cache_insert(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr, DNS_RR_A_LEN, request->ping_ttl_v4);
+					dns_cache_insert(request->domain, cname, cname_ttl, request->ttl_v4, DNS_T_A, request->ipv4_addr,
+									 DNS_RR_A_LEN, request->ping_ttl_v4);
 				}
 			}
 
@@ -868,16 +912,19 @@ static void _dns_server_select_possible_ipaddress(struct dns_request *request)
 	case DNS_T_A: {
 		memcpy(request->ipv4_addr, selected_addr_map->ipv4_addr, DNS_RR_A_LEN);
 		request->ttl_v4 = DNS_SERVER_TMOUT_TTL;
-		tlog(TLOG_DEBUG, "possible result: %s, rcode: %d,  %d.%d.%d.%d\n", request->domain, request->rcode, request->ipv4_addr[0], request->ipv4_addr[1],
+		tlog(TLOG_DEBUG, "possible result: %s, rcode: %d,  %d.%d.%d.%d\n", request->domain, request->rcode,
-			 request->ipv4_addr[2], request->ipv4_addr[3]);
+			 request->ipv4_addr[0], request->ipv4_addr[1], request->ipv4_addr[2], request->ipv4_addr[3]);
 	} break;
 	case DNS_T_AAAA: {
 		memcpy(request->ipv6_addr, selected_addr_map->ipv6_addr, DNS_RR_AAAA_LEN);
 		request->ttl_v6 = DNS_SERVER_TMOUT_TTL;
-		tlog(TLOG_DEBUG, "possible result: %s, rcode: %d,  %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", request->domain,
+		tlog(TLOG_DEBUG,
-			 request->rcode, request->ipv6_addr[0], request->ipv6_addr[1], request->ipv6_addr[2], request->ipv6_addr[3], request->ipv6_addr[4],
+			 "possible result: %s, rcode: %d,  %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x",
-			 request->ipv6_addr[5], request->ipv6_addr[6], request->ipv6_addr[7], request->ipv6_addr[8], request->ipv6_addr[9], request->ipv6_addr[10],
+			 request->domain, request->rcode, request->ipv6_addr[0], request->ipv6_addr[1], request->ipv6_addr[2],
-			 request->ipv6_addr[11], request->ipv6_addr[12], request->ipv6_addr[13], request->ipv6_addr[14], request->ipv6_addr[15]);
+			 request->ipv6_addr[3], request->ipv6_addr[4], request->ipv6_addr[5], request->ipv6_addr[6],
+			 request->ipv6_addr[7], request->ipv6_addr[8], request->ipv6_addr[9], request->ipv6_addr[10],
+			 request->ipv6_addr[11], request->ipv6_addr[12], request->ipv6_addr[13], request->ipv6_addr[14],
+			 request->ipv6_addr[15]);
 	} break;
 	default:
 		break;
@@ -956,6 +1003,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;
@@ -973,8 +1022,9 @@ errout:
 	return NULL;
 }
 
-static void _dns_server_ping_result(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result, struct sockaddr *addr, socklen_t addr_len,
+static void _dns_server_ping_result(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result,
-									int seqno, int ttl, struct timeval *tv, void *userptr)
+									struct sockaddr *addr, socklen_t addr_len, int seqno, int ttl, struct timeval *tv,
+									void *userptr)
 {
 	struct dns_request *request = userptr;
 	int may_complete = 0;
@@ -1156,7 +1206,8 @@ static int _dns_server_get_conf_ttl(int ttl)
 	return ttl;
 }
 
-static int _dns_server_ip_rule_check(struct dns_request *request, unsigned char *addr, int addr_len, dns_type_t addr_type, int result_flag)
+static int _dns_server_ip_rule_check(struct dns_request *request, unsigned char *addr, int addr_len,
+									 dns_type_t addr_type, int result_flag)
 {
 	prefix_t prefix;
 	radix_node_t *node = NULL;
@@ -1241,7 +1292,8 @@ static int _dns_server_is_adblock_ipv6(unsigned char addr[16])
 	return -1;
 }
 
-static int _dns_server_process_answer_A(struct dns_rrs *rrs, struct dns_request *request, char *domain, unsigned int result_flag, int ping_timeout)
+static int _dns_server_process_answer_A(struct dns_rrs *rrs, struct dns_request *request, char *domain,
+										unsigned int result_flag, int ping_timeout)
 {
 	int ttl;
 	int ip_check_result = 0;
@@ -1314,7 +1366,8 @@ static int _dns_server_process_answer_A(struct dns_rrs *rrs, struct dns_request
 	return 0;
 }
 
-static int _dns_server_process_answer_AAAA(struct dns_rrs *rrs, struct dns_request *request, char *domain, unsigned int result_flag, int ping_timeout)
+static int _dns_server_process_answer_AAAA(struct dns_rrs *rrs, struct dns_request *request, char *domain,
+										   unsigned int result_flag, int ping_timeout)
 {
 	unsigned char addr[16];
 	char name[DNS_MAX_CNAME_LEN] = {0};
@@ -1329,8 +1382,9 @@ static int _dns_server_process_answer_AAAA(struct dns_rrs *rrs, struct dns_reque
 	_dns_server_request_get(request);
 	dns_get_AAAA(rrs, name, DNS_MAX_CNAME_LEN, &ttl, addr);
 
-	tlog(TLOG_DEBUG, "domain: %s TTL: %d IP: %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", name, ttl, addr[0], addr[1], addr[2],
+	tlog(TLOG_DEBUG, "domain: %s TTL: %d IP: %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x",
-		 addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15]);
+		 name, ttl, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10],
+		 addr[11], addr[12], addr[13], addr[14], addr[15]);
 
 	ip_check_result = _dns_server_ip_rule_check(request, addr, 16, DNS_T_AAAA, result_flag);
 	if (ip_check_result == 0) {
@@ -1374,8 +1428,9 @@ static int _dns_server_process_answer_AAAA(struct dns_rrs *rrs, struct dns_reque
 		return -1;
 	}
 
-	sprintf(ip, "[%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x]", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6],
+	sprintf(ip, "[%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x]", addr[0], addr[1], addr[2],
-			addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15]);
+			addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13],
+			addr[14], addr[15]);
 
 	/* start ping */
 	if (_dns_server_check_speed(request, ip, 0, ping_timeout) != 0) {
@@ -1385,7 +1440,8 @@ static int _dns_server_process_answer_AAAA(struct dns_rrs *rrs, struct dns_reque
 	return 0;
 }
 
-static int _dns_server_process_answer(struct dns_request *request, char *domain, struct dns_packet *packet, unsigned int result_flag)
+static int _dns_server_process_answer(struct dns_request *request, char *domain, struct dns_packet *packet,
+									  unsigned int result_flag)
 {
 	int ttl;
 	char name[DNS_MAX_CNAME_LEN] = {0};
@@ -1452,9 +1508,11 @@ static int _dns_server_process_answer(struct dns_request *request, char *domain,
 				request->has_soa = 1;
 				request->rcode = packet->head.rcode;
 				dns_get_SOA(rrs, name, 128, &ttl, &request->soa);
-				tlog(TLOG_DEBUG, "domain: %s, qtype: %d, SOA: mname: %s, rname: %s, serial: %d, refresh: %d, retry: %d, expire: %d, minimum: %d", domain,
+				tlog(TLOG_DEBUG,
-					 request->qtype, request->soa.mname, request->soa.rname, request->soa.serial, request->soa.refresh, request->soa.retry, request->soa.expire,
+					 "domain: %s, qtype: %d, SOA: mname: %s, rname: %s, serial: %d, refresh: %d, retry: %d, expire: "
-					 request->soa.minimum);
+					 "%d, minimum: %d",
+					 domain, request->qtype, request->soa.mname, request->soa.rname, request->soa.serial,
+					 request->soa.refresh, request->soa.retry, request->soa.expire, request->soa.minimum);
 				if (atomic_inc_return(&request->soa_num) >= (dns_server_num() / 2)) {
 					_dns_server_request_complete(request);
 				}
@@ -1483,7 +1541,8 @@ static int dns_server_update_reply_packet_id(struct dns_request *request, unsign
 	return 0;
 }
 
-static int _dns_server_passthrough_rule_check(struct dns_request *request, char *domain, struct dns_packet *packet, unsigned int result_flag)
+static int _dns_server_passthrough_rule_check(struct dns_request *request, char *domain, struct dns_packet *packet,
+											  unsigned int result_flag)
 {
 	int ttl;
 	char name[DNS_MAX_CNAME_LEN] = {0};
@@ -1542,8 +1601,10 @@ static int _dns_server_passthrough_rule_check(struct dns_request *request, char
 				_dns_server_request_get(request);
 				dns_get_AAAA(rrs, name, DNS_MAX_CNAME_LEN, &ttl, addr);
 
-				tlog(TLOG_DEBUG, "domain: %s TTL: %d IP: %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x", name, ttl, addr[0], addr[1],
+				tlog(TLOG_DEBUG,
-					 addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15]);
+					 "domain: %s TTL: %d IP: %.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x",
+					 name, ttl, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8],
+					 addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15]);
 
 				ip_check_result = _dns_server_ip_rule_check(request, addr, 16, DNS_T_AAAA, result_flag);
 				if (ip_check_result == 0) {
@@ -1566,7 +1627,8 @@ static int _dns_server_passthrough_rule_check(struct dns_request *request, char
 	return -1;
 }
 
-static int _dns_server_reply_passthrouth(struct dns_request *request, struct dns_packet *packet, unsigned char *inpacket, int inpacket_len)
+static int _dns_server_reply_passthrouth(struct dns_request *request, struct dns_packet *packet,
+										 unsigned char *inpacket, int inpacket_len)
 {
 	int ret = 0;
 
@@ -1574,6 +1636,10 @@ static int _dns_server_reply_passthrouth(struct dns_request *request, struct dns
 		return 0;
 	}
 
+	if (request->conn == NULL) {
+		return 0;
+	}
+
 	/* When passthrough, modify the id to be the id of the client request. */
 	dns_server_update_reply_packet_id(request, inpacket, inpacket_len);
 	ret = _dns_reply_inpacket(request, inpacket, inpacket_len);
@@ -1581,8 +1647,9 @@ static int _dns_server_reply_passthrouth(struct dns_request *request, struct dns
 	return ret;
 }
 
-static int dns_server_resolve_callback(char *domain, dns_result_type rtype, unsigned int result_flag, struct dns_packet *packet, unsigned char *inpacket,
+static int dns_server_resolve_callback(char *domain, dns_result_type rtype, unsigned int result_flag,
-									   int inpacket_len, void *user_ptr)
+									   struct dns_packet *packet, unsigned char *inpacket, int inpacket_len,
+									   void *user_ptr)
 {
 	struct dns_request *request = user_ptr;
 	int ip_num = 0;
@@ -1617,6 +1684,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);
 		}
@@ -1653,23 +1721,28 @@ static int _dns_server_process_ptr(struct dns_request *request)
 			struct sockaddr_in *addr_in;
 			addr_in = (struct sockaddr_in *)ifa->ifa_addr;
 			addr = (unsigned char *)&(addr_in->sin_addr.s_addr);
-			snprintf(reverse_addr, sizeof(reverse_addr), "%d.%d.%d.%d.in-addr.arpa", addr[3], addr[2], addr[1], addr[0]);
+			snprintf(reverse_addr, sizeof(reverse_addr), "%d.%d.%d.%d.in-addr.arpa", addr[3], addr[2], addr[1],
+					 addr[0]);
 		} break;
 		case AF_INET6: {
 			struct sockaddr_in6 *addr_in6;
 			addr_in6 = (struct sockaddr_in6 *)ifa->ifa_addr;
 			if (IN6_IS_ADDR_V4MAPPED(&addr_in6->sin6_addr)) {
 				addr = addr_in6->sin6_addr.s6_addr + 12;
-				snprintf(reverse_addr, sizeof(reverse_addr), "%d.%d.%d.%d.in-addr.arpa", addr[3], addr[2], addr[1], addr[0]);
+				snprintf(reverse_addr, sizeof(reverse_addr), "%d.%d.%d.%d.in-addr.arpa", addr[3], addr[2], addr[1],
+						 addr[0]);
 			} else {
 				addr = addr_in6->sin6_addr.s6_addr;
 				snprintf(reverse_addr, sizeof(reverse_addr),
-						 "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.ip6.arpa", addr[15] & 0xF,
+						 "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x."
-						 (addr[15] >> 4) & 0xF, addr[14] & 0xF, (addr[14] >> 4) & 0xF, addr[13] & 0xF, (addr[13] >> 4) & 0xF, addr[12] & 0xF,
+						 "%x.ip6.arpa",
-						 (addr[12] >> 4) & 0xF, addr[11] & 0xF, (addr[11] >> 4) & 0xF, addr[10] & 0xF, (addr[10] >> 4) & 0xF, addr[9] & 0xF,
+						 addr[15] & 0xF, (addr[15] >> 4) & 0xF, addr[14] & 0xF, (addr[14] >> 4) & 0xF, addr[13] & 0xF,
-						 (addr[9] >> 4) & 0xF, addr[8] & 0xF, (addr[8] >> 4) & 0xF, addr[7] & 0xF, (addr[7] >> 4) & 0xF, addr[6] & 0xF, (addr[6] >> 4) & 0xF,
+						 (addr[13] >> 4) & 0xF, addr[12] & 0xF, (addr[12] >> 4) & 0xF, addr[11] & 0xF,
-						 addr[5] & 0xF, (addr[5] >> 4) & 0xF, addr[4] & 0xF, (addr[4] >> 4) & 0xF, addr[3] & 0xF, (addr[3] >> 4) & 0xF, addr[2] & 0xF,
+						 (addr[11] >> 4) & 0xF, addr[10] & 0xF, (addr[10] >> 4) & 0xF, addr[9] & 0xF,
-						 (addr[2] >> 4) & 0xF, addr[1] & 0xF, (addr[1] >> 4) & 0xF, addr[0] & 0xF, (addr[0] >> 4) & 0xF);
+						 (addr[9] >> 4) & 0xF, addr[8] & 0xF, (addr[8] >> 4) & 0xF, addr[7] & 0xF, (addr[7] >> 4) & 0xF,
+						 addr[6] & 0xF, (addr[6] >> 4) & 0xF, addr[5] & 0xF, (addr[5] >> 4) & 0xF, addr[4] & 0xF,
+						 (addr[4] >> 4) & 0xF, addr[3] & 0xF, (addr[3] >> 4) & 0xF, addr[2] & 0xF, (addr[2] >> 4) & 0xF,
+						 addr[1] & 0xF, (addr[1] >> 4) & 0xF, addr[0] & 0xF, (addr[0] >> 4) & 0xF);
 			}
 		} break;
 		default:
@@ -1688,6 +1761,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;
 	}
@@ -1705,7 +1783,8 @@ errout:
 	return -1;
 }
 
-static void _dns_server_log_rule(const char *domain, enum domain_rule rule_type, unsigned char *rule_key, int rule_key_len)
+static void _dns_server_log_rule(const char *domain, enum domain_rule rule_type, unsigned char *rule_key,
+								 int rule_key_len)
 {
 	char rule_name[DNS_MAX_CNAME_LEN];
 
@@ -1720,8 +1799,7 @@ static void _dns_server_log_rule(const char *domain, enum domain_rule rule_type,
 
 static void _dns_server_update_rule_by_flags(struct dns_request *request)
 {
-	struct dns_rule_flags *rule_flag =
+	struct dns_rule_flags *rule_flag = (struct dns_rule_flags *)request->domain_rule.rules[0];
-		(struct dns_rule_flags *)request->domain_rule.rules[0];
 	unsigned int flags = 0;
 
 	if (rule_flag == NULL) {
@@ -1797,7 +1875,8 @@ void _dns_server_get_domain_rule(struct dns_request *request)
 	domain_key[domain_len] = 0;
 
 	/* find domain rule */
-	art_substring_walk(&dns_conf_domain_rule, (unsigned char *)domain_key, domain_len, _dns_server_get_rules, &walk_args);
+	art_substring_walk(&dns_conf_domain_rule, (unsigned char *)domain_key, domain_len, _dns_server_get_rules,
+					   &walk_args);
 	if (likely(dns_conf_log_level > TLOG_DEBUG)) {
 		return;
 	}
@@ -1930,6 +2009,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 +2033,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;
 	}
 
@@ -1951,7 +2052,8 @@ static int _dns_server_process_cache(struct dns_request *request)
 	if (request->dualstack_selection && request->qtype == DNS_T_AAAA) {
 		dns_cache_A = dns_cache_lookup(request->domain, DNS_T_A);
 		if (dns_cache_A && (dns_cache_A->speed > 0)) {
-			if ((dns_cache_A->speed + (dns_conf_dualstack_ip_selection_threshold * 10)) < dns_cache->speed || dns_cache->speed < 0) {
+			if ((dns_cache_A->speed + (dns_conf_dualstack_ip_selection_threshold * 10)) < dns_cache->speed ||
+				dns_cache->speed < 0) {
 				tlog(TLOG_DEBUG, "Force IPV4 perfered.");
 				dns_cache_release(dns_cache_A);
 				dns_cache_release(dns_cache);
@@ -1991,7 +2093,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) {
@@ -2027,7 +2133,8 @@ static void _dns_server_request_set_enable_prefetch(struct dns_request *request)
 	request->prefetch = 1;
 }
 
-static int _dns_server_request_set_client_addr(struct dns_request *request, struct sockaddr_storage *from, socklen_t from_len)
+static int _dns_server_request_set_client_addr(struct dns_request *request, struct sockaddr_storage *from,
+											   socklen_t from_len)
 {
 	switch (from->ss_family) {
 	case AF_INET:
@@ -2104,6 +2211,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 +2256,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,19 +2305,9 @@ errout:
 	return ret;
 }
 
-static void _dns_server_check_set_passthrough(struct dns_request *request, struct dns_server_conn_head *conn)
+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,
-	if (request->check_order_list->order[0] == DOMAIN_CHECK_NONE) {
+							socklen_t from_len)
-		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)
 {
 	int decode_len;
 	int ret = -1;
@@ -2209,16 +2323,19 @@ static int _dns_server_recv(struct dns_server_conn_head *conn, unsigned char *in
 	int qtype = DNS_T_ALL;
 
 	/* decode packet */
-	tlog(TLOG_DEBUG, "recv query packet from %s, len = %d", gethost_by_addr(name, sizeof(name), (struct sockaddr *)from), inpacket_len);
+	tlog(TLOG_DEBUG, "recv query packet from %s, len = %d",
+		 gethost_by_addr(name, sizeof(name), (struct sockaddr *)from), inpacket_len);
 	decode_len = dns_decode(packet, DNS_PACKSIZE, inpacket, inpacket_len);
 	if (decode_len < 0) {
 		tlog(TLOG_DEBUG, "decode failed.\n");
 		goto errout;
 	}
 
-	tlog(TLOG_DEBUG, "request qdcount = %d, ancount = %d, nscount = %d, nrcount = %d, len = %d, id = %d, tc = %d, rd = %d, ra = %d, rcode = %d\n",
+	tlog(TLOG_DEBUG,
-		 packet->head.qdcount, packet->head.ancount, packet->head.nscount, packet->head.nrcount, inpacket_len, packet->head.id, packet->head.tc,
+		 "request qdcount = %d, ancount = %d, nscount = %d, nrcount = %d, len = %d, id = %d, tc = %d, rd = %d, ra = "
-		 packet->head.rd, packet->head.ra, packet->head.rcode);
+		 "%d, rcode = %d\n",
+		 packet->head.qdcount, packet->head.ancount, packet->head.nscount, packet->head.nrcount, inpacket_len,
+		 packet->head.id, packet->head.tc, packet->head.rd, packet->head.ra, packet->head.rcode);
 
 	if (packet->head.qr != DNS_QR_QUERY) {
 		goto errout;
@@ -2249,7 +2366,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 +2431,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) {
@@ -2390,7 +2506,8 @@ static int _dns_server_client_close(struct dns_server_conn_head *conn)
 	return 0;
 }
 
-static int _dns_server_tcp_accept(struct dns_server_conn_tcp_server *tcpserver, struct epoll_event *event, unsigned long now)
+static int _dns_server_tcp_accept(struct dns_server_conn_tcp_server *tcpserver, struct epoll_event *event,
+								  unsigned long now)
 {
 	struct sockaddr_storage addr;
 	struct dns_server_conn_tcp_client *tcpclient = NULL;
@@ -2454,7 +2571,8 @@ static int _dns_server_tcp_recv(struct dns_server_conn_tcp_client *tcpclient)
 			return 0;
 		}
 
-		len = recv(tcpclient->head.fd, tcpclient->recvbuff.buf + tcpclient->recvbuff.size, sizeof(tcpclient->recvbuff.buf) - tcpclient->recvbuff.size, 0);
+		len = recv(tcpclient->head.fd, tcpclient->recvbuff.buf + tcpclient->recvbuff.size,
+				   sizeof(tcpclient->recvbuff.buf) - tcpclient->recvbuff.size, 0);
 		if (len < 0) {
 			if (errno == EAGAIN) {
 				return RECV_ERROR_AGAIN;
@@ -2496,7 +2614,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;
 		}
@@ -2504,8 +2622,8 @@ static int _dns_server_tcp_process_one_request(struct dns_server_conn_tcp_client
 		request_data = (unsigned char *)(tcpclient->recvbuff.buf + proceed_len + sizeof(unsigned short));
 
 		/* process one record */
-		if (_dns_server_recv(&tcpclient->head, request_data, request_len, &tcpclient->localaddr, tcpclient->localaddr_len, &tcpclient->addr,
+		if (_dns_server_recv(&tcpclient->head, request_data, request_len, &tcpclient->localaddr,
-							 tcpclient->addr_len) != 0) {
+							 tcpclient->localaddr_len, &tcpclient->addr, tcpclient->addr_len) != 0) {
 			tlog(TLOG_ERROR, "process tcp request failed.");
 			return RECV_ERROR_FAIL;
 		}
@@ -2588,7 +2706,8 @@ static int _dns_server_tcp_send(struct dns_server_conn_tcp_client *tcpclient)
 	return 0;
 }
 
-static int _dns_server_process_tcp(struct dns_server_conn_tcp_client *dnsserver, struct epoll_event *event, unsigned long now)
+static int _dns_server_process_tcp(struct dns_server_conn_tcp_client *dnsserver, struct epoll_event *event,
+								   unsigned long now)
 {
 	int ret = 0;
 
@@ -2662,16 +2781,18 @@ static void _dns_server_second_ping_check(struct dns_request *request)
 		switch (addr_map->addr_type) {
 		case DNS_T_A: {
 			_dns_server_request_get(request);
-			sprintf(ip, "%d.%d.%d.%d", addr_map->ipv4_addr[0], addr_map->ipv4_addr[1], addr_map->ipv4_addr[2], addr_map->ipv4_addr[3]);
+			sprintf(ip, "%d.%d.%d.%d", addr_map->ipv4_addr[0], addr_map->ipv4_addr[1], addr_map->ipv4_addr[2],
+					addr_map->ipv4_addr[3]);
 			if (_dns_server_check_speed(request, ip, 1, DNS_PING_SECOND_TIMEOUT) != 0) {
 				_dns_server_request_release(request);
 			}
 		} break;
 		case DNS_T_AAAA: {
 			_dns_server_request_get(request);
-			sprintf(ip, "[%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x]", addr_map->ipv6_addr[0], addr_map->ipv6_addr[1],
+			sprintf(ip, "[%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x:%.2x%.2x]",
-					addr_map->ipv6_addr[2], addr_map->ipv6_addr[3], addr_map->ipv6_addr[4], addr_map->ipv6_addr[5], addr_map->ipv6_addr[6],
+					addr_map->ipv6_addr[0], addr_map->ipv6_addr[1], addr_map->ipv6_addr[2], addr_map->ipv6_addr[3],
-					addr_map->ipv6_addr[7], addr_map->ipv6_addr[8], addr_map->ipv6_addr[9], addr_map->ipv6_addr[10], addr_map->ipv6_addr[11],
+					addr_map->ipv6_addr[4], addr_map->ipv6_addr[5], addr_map->ipv6_addr[6], addr_map->ipv6_addr[7],
+					addr_map->ipv6_addr[8], addr_map->ipv6_addr[9], addr_map->ipv6_addr[10], addr_map->ipv6_addr[11],
 					addr_map->ipv6_addr[12], addr_map->ipv6_addr[13], addr_map->ipv6_addr[14], addr_map->ipv6_addr[15]);
 
 			if (_dns_server_check_speed(request, ip, 1, DNS_PING_SECOND_TIMEOUT) != 0) {
@@ -2696,7 +2817,8 @@ static void _dns_server_prefetch_domain(struct dns_cache *dns_cache)
 	}
 
 	/* start prefetch domain */
-	tlog(TLOG_DEBUG, "prefetch by cache %s, qtype %d, ttl %d, hitnum %d", dns_cache->domain, dns_cache->qtype, dns_cache->ttl, hitnum);
+	tlog(TLOG_DEBUG, "prefetch by cache %s, qtype %d, ttl %d, hitnum %d", dns_cache->domain, dns_cache->qtype,
+		 dns_cache->ttl, hitnum);
 	if (_dns_server_prefetch_request(dns_cache->domain, dns_cache->qtype) != 0) {
 		tlog(TLOG_ERROR, "prefetch domain %s, qtype %d, failed.", dns_cache->domain, dns_cache->qtype);
 	}
@@ -2928,7 +3050,8 @@ static int _dns_create_socket(const char *host_ip, int type)
 
 	fd = socket(gai->ai_family, gai->ai_socktype, gai->ai_protocol);
 	if (fd < 0) {
-		tlog(TLOG_ERROR, "create socket failed, family = %d, type = %d, proto = %d, %s\n", gai->ai_family, gai->ai_socktype, gai->ai_protocol, strerror(errno));
+		tlog(TLOG_ERROR, "create socket failed, family = %d, type = %d, proto = %d, %s\n", gai->ai_family,
+			 gai->ai_socktype, gai->ai_protocol, strerror(errno));
 		goto errout;
 	}
 
@@ -3113,7 +3236,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;
 	}

src/dns_server.h

@@ -36,7 +36,8 @@ void dns_server_stop(void);
 void dns_server_exit(void);
 
 /* query result notify function */
-typedef int (*dns_result_callback)(char *domain, dns_rtcode_t rtcode, dns_type_t addr_type, char *ip, unsigned int ping_time, void *user_ptr);
+typedef int (*dns_result_callback)(char *domain, dns_rtcode_t rtcode, dns_type_t addr_type, char *ip,
+								   unsigned int ping_time, void *user_ptr);
 
 /* query domain */
 int dns_server_query(char *domain, int qtype, dns_result_callback callback, void *user_ptr);

src/fast_ping.h

@@ -1,58 +1,60 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#ifndef FAST_PING_H
+#ifndef FAST_PING_H
-#define FAST_PING_H
+#define FAST_PING_H
-
+
-#include <netdb.h>
+#include <netdb.h>
-#include <sys/time.h>
+#include <sys/time.h>
-#ifdef __cpluscplus
+#ifdef __cpluscplus
-extern "C" {
+extern "C" {
-#endif
+#endif
-
+
-typedef enum {
+typedef enum {
-	PING_TYPE_ICMP = 1,
+	PING_TYPE_ICMP = 1,
-	PING_TYPE_TCP = 2,
+	PING_TYPE_TCP = 2,
-	PING_TYPE_DNS = 3,
+	PING_TYPE_DNS = 3,
-} PING_TYPE;
+} PING_TYPE;
-
+
-typedef enum {
+typedef enum {
-	PING_RESULT_RESPONSE = 1,
+	PING_RESULT_RESPONSE = 1,
-	PING_RESULT_TIMEOUT = 2,
+	PING_RESULT_TIMEOUT = 2,
-	PING_RESULT_END = 3,
+	PING_RESULT_END = 3,
-} FAST_PING_RESULT;
+} FAST_PING_RESULT;
-
+
-struct ping_host_struct;
+struct ping_host_struct;
-typedef void (*fast_ping_result)(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result, struct sockaddr *addr, socklen_t addr_len,
+typedef void (*fast_ping_result)(struct ping_host_struct *ping_host, const char *host, FAST_PING_RESULT result,
-								 int seqno, int ttl, struct timeval *tv, void *userptr);
+								 struct sockaddr *addr, socklen_t addr_len, int seqno, int ttl, struct timeval *tv,
-
+								 void *userptr);
-/* start ping */
+
-struct ping_host_struct *fast_ping_start(PING_TYPE type, const char *host, int count, int interval, int timeout, fast_ping_result ping_callback, void *userptr);
+/* start ping */
-
+struct ping_host_struct *fast_ping_start(PING_TYPE type, const char *host, int count, int interval, int timeout,
-/* stop ping */
+										 fast_ping_result ping_callback, void *userptr);
-int fast_ping_stop(struct ping_host_struct *ping_host);
+
-
+/* stop ping */
-int fast_ping_init(void);
+int fast_ping_stop(struct ping_host_struct *ping_host);
-
+
-void fast_ping_exit(void);
+int fast_ping_init(void);
-
+
-#ifdef __cpluscplus
+void fast_ping_exit(void);
-}
+
-#endif
+#ifdef __cpluscplus
-
+}
-#endif // !FAST_PING_H
+#endif
+
+#endif // !FAST_PING_H

src/http_parse.c

@@ -1,463 +1,463 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#include "http_parse.h"
+#include "http_parse.h"
-#include "hash.h"
+#include "hash.h"
-#include "hashtable.h"
+#include "hashtable.h"
-#include "jhash.h"
+#include "jhash.h"
-#include "list.h"
+#include "list.h"
-#include <stdlib.h>
+#include <stdlib.h>
-#include <string.h>
+#include <string.h>
-#include <unistd.h>
+#include <unistd.h>
-
+
-struct http_head_fields {
+struct http_head_fields {
-	struct hlist_node node;
+	struct hlist_node node;
-	struct list_head list;
+	struct list_head list;
-
+
-	char *name;
+	char *name;
-	char *value;
+	char *value;
-};
+};
-
+
-struct http_head {
+struct http_head {
-	HTTP_HEAD_TYPE head_type;
+	HTTP_HEAD_TYPE head_type;
-	HTTP_METHOD method;
+	HTTP_METHOD method;
-	char *url;
+	char *url;
-	char *version;
+	char *version;
-	int code;
+	int code;
-	char *code_msg;
+	char *code_msg;
-	int buff_size;
+	int buff_size;
-	int buff_len;
+	int buff_len;
-	char *buff;
+	char *buff;
-	int head_ok;
+	int head_ok;
-	int head_len;
+	int head_len;
-	char *data;
+	char *data;
-	int data_len;
+	int data_len;
-	int expect_data_len;
+	int expect_data_len;
-	struct http_head_fields field_head;
+	struct http_head_fields field_head;
-	DECLARE_HASHTABLE(field_map, 4);
+	DECLARE_HASHTABLE(field_map, 4);
-};
+};
-
+
-/*
+/*
- * Returns:
+ * Returns:
- *  >=0  - success http data len
+ *  >=0  - success http data len
- *  -1   - Incomplete request
+ *  -1   - Incomplete request
- *  -2   - parse failed
+ *  -2   - parse failed
- */
+ */
-struct http_head *http_head_init(int buffsize)
+struct http_head *http_head_init(int buffsize)
-{
+{
-	struct http_head *http_head = NULL;
+	struct http_head *http_head = NULL;
-	char *buffer = NULL;
+	char *buffer = NULL;
-
+
-	http_head = malloc(sizeof(*http_head));
+	http_head = malloc(sizeof(*http_head));
-	if (http_head == NULL) {
+	if (http_head == NULL) {
-		goto errout;
+		goto errout;
-	}
+	}
-	memset(http_head, 0, sizeof(*http_head));
+	memset(http_head, 0, sizeof(*http_head));
-	INIT_LIST_HEAD(&http_head->field_head.list);
+	INIT_LIST_HEAD(&http_head->field_head.list);
-	hash_init(http_head->field_map);
+	hash_init(http_head->field_map);
-
+
-	buffer = malloc(buffsize);
+	buffer = malloc(buffsize);
-	if (buffer == NULL) {
+	if (buffer == NULL) {
-		goto errout;
+		goto errout;
-	}
+	}
-
+
-	http_head->buff = buffer;
+	http_head->buff = buffer;
-	http_head->buff_size = buffsize;
+	http_head->buff_size = buffsize;
-
+
-	return http_head;
+	return http_head;
-
+
-errout:
+errout:
-	if (buffer) {
+	if (buffer) {
-		free(buffer);
+		free(buffer);
-	}
+	}
-
+
-	if (http_head) {
+	if (http_head) {
-		free(http_head);
+		free(http_head);
-	}
+	}
-
+
-	return NULL;
+	return NULL;
-}
+}
-
+
-struct http_head_fields *http_head_first_fields(struct http_head *http_head)
+struct http_head_fields *http_head_first_fields(struct http_head *http_head)
-{
+{
-	struct http_head_fields *first = NULL;
+	struct http_head_fields *first = NULL;
-	first = list_first_entry(&http_head->field_head.list, struct http_head_fields, list);
+	first = list_first_entry(&http_head->field_head.list, struct http_head_fields, list);
-
+
-	if (first->name == NULL && first->value == NULL) {
+	if (first->name == NULL && first->value == NULL) {
-		return NULL;
+		return NULL;
-	}
+	}
-
+
-	return first;
+	return first;
-}
+}
-
+
-const char *http_head_get_fields_value(struct http_head *http_head, const char *name)
+const char *http_head_get_fields_value(struct http_head *http_head, const char *name)
-{
+{
-	unsigned long key;
+	unsigned long key;
-	struct http_head_fields *filed;
+	struct http_head_fields *filed;
-
+
-	key = hash_string(name);
+	key = hash_string(name);
-	hash_for_each_possible(http_head->field_map, filed, node, key)
+	hash_for_each_possible(http_head->field_map, filed, node, key)
-	{
+	{
-		if (strncmp(filed->name, name, 128) == 0) {
+		if (strncmp(filed->name, name, 128) == 0) {
-			return filed->value;
+			return filed->value;
-		}
+		}
-	}
+	}
-
+
-	return NULL;
+	return NULL;
-}
+}
-
+
-struct http_head_fields *http_head_next_fields(struct http_head_fields *fields)
+struct http_head_fields *http_head_next_fields(struct http_head_fields *fields)
-{
+{
-	struct http_head_fields *next = NULL;
+	struct http_head_fields *next = NULL;
-	next = list_next_entry(fields, list);
+	next = list_next_entry(fields, list);
-
+
-	if (next->name == NULL && next->value == NULL) {
+	if (next->name == NULL && next->value == NULL) {
-		return NULL;
+		return NULL;
-	}
+	}
-
+
-	return next;
+	return next;
-}
+}
-
+
-int http_head_lookup_fields(struct http_head_fields *fields, const char **name, const char **value)
+int http_head_lookup_fields(struct http_head_fields *fields, const char **name, const char **value)
-{
+{
-	if (fields == NULL) {
+	if (fields == NULL) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	if (name) {
+	if (name) {
-		*name = fields->name;
+		*name = fields->name;
-	}
+	}
-
+
-	if (value) {
+	if (value) {
-		*value = fields->value;
+		*value = fields->value;
-	}
+	}
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-HTTP_METHOD http_head_get_method(struct http_head *http_head)
+HTTP_METHOD http_head_get_method(struct http_head *http_head)
-{
+{
-	return http_head->method;
+	return http_head->method;
-}
+}
-
+
-const char *http_head_get_url(struct http_head *http_head)
+const char *http_head_get_url(struct http_head *http_head)
-{
+{
-	return http_head->url;
+	return http_head->url;
-}
+}
-
+
-const char *http_head_get_httpversion(struct http_head *http_head)
+const char *http_head_get_httpversion(struct http_head *http_head)
-{
+{
-	return http_head->version;
+	return http_head->version;
-}
+}
-
+
-int http_head_get_httpcode(struct http_head *http_head)
+int http_head_get_httpcode(struct http_head *http_head)
-{
+{
-	return http_head->code;
+	return http_head->code;
-}
+}
-
+
-char *http_head_get_httpcode_msg(struct http_head *http_head)
+char *http_head_get_httpcode_msg(struct http_head *http_head)
-{
+{
-	return http_head->code_msg;
+	return http_head->code_msg;
-}
+}
-
+
-HTTP_HEAD_TYPE http_head_get_head_type(struct http_head *http_head)
+HTTP_HEAD_TYPE http_head_get_head_type(struct http_head *http_head)
-{
+{
-	return http_head->head_type;
+	return http_head->head_type;
-}
+}
-
+
-char *http_head_get_data(struct http_head *http_head)
+char *http_head_get_data(struct http_head *http_head)
-{
+{
-	return http_head->data;
+	return http_head->data;
-}
+}
-
+
-int http_head_get_data_len(struct http_head *http_head)
+int http_head_get_data_len(struct http_head *http_head)
-{
+{
-	return http_head->data_len;
+	return http_head->data_len;
-}
+}
-
+
-static int _http_head_add_fields(struct http_head *http_head, char *name, char *value)
+static int _http_head_add_fields(struct http_head *http_head, char *name, char *value)
-{
+{
-	unsigned long key = 0;
+	unsigned long key = 0;
-	struct http_head_fields *fields = NULL;
+	struct http_head_fields *fields = NULL;
-	fields = malloc(sizeof(*fields));
+	fields = malloc(sizeof(*fields));
-	if (fields == NULL) {
+	if (fields == NULL) {
-		return -1;
+		return -1;
-	}
+	}
-	memset(fields, 0, sizeof(*fields));
+	memset(fields, 0, sizeof(*fields));
-
+
-	fields->name = name;
+	fields->name = name;
-	fields->value = value;
+	fields->value = value;
-
+
-	list_add_tail(&fields->list, &http_head->field_head.list);
+	list_add_tail(&fields->list, &http_head->field_head.list);
-	key = hash_string(name);
+	key = hash_string(name);
-	hash_add(http_head->field_map, &fields->node, key);
+	hash_add(http_head->field_map, &fields->node, key);
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-static int _http_head_parse_response(struct http_head *http_head, char *key, char *value)
+static int _http_head_parse_response(struct http_head *http_head, char *key, char *value)
-{
+{
-	char *field_start = NULL;
+	char *field_start = NULL;
-	char *tmp_ptr = NULL;
+	char *tmp_ptr = NULL;
-	char *result = NULL;
+	char *result = NULL;
-	char *ret_code = NULL;
+	char *ret_code = NULL;
-
+
-	if (strstr(key, "HTTP/") == NULL) {
+	if (strstr(key, "HTTP/") == NULL) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	for (tmp_ptr = value; *tmp_ptr != 0; tmp_ptr++) {
+	for (tmp_ptr = value; *tmp_ptr != 0; tmp_ptr++) {
-		if (field_start == NULL) {
+		if (field_start == NULL) {
-			field_start = tmp_ptr;
+			field_start = tmp_ptr;
-		}
+		}
-
+
-		if (*tmp_ptr == ' ') {
+		if (*tmp_ptr == ' ') {
-			*tmp_ptr = '\0';
+			*tmp_ptr = '\0';
-			if (ret_code == NULL) {
+			if (ret_code == NULL) {
-				ret_code = field_start;
+				ret_code = field_start;
-			} else if (result == NULL) {
+			} else if (result == NULL) {
-				result = field_start;
+				result = field_start;
-				break;
+				break;
-			}
+			}
-
+
-			field_start = NULL;
+			field_start = NULL;
-		}
+		}
-	}
+	}
-
+
-	if (field_start && result == NULL) {
+	if (field_start && result == NULL) {
-		result = field_start;
+		result = field_start;
-	}
+	}
-
+
-	if (ret_code == NULL || result == NULL) {
+	if (ret_code == NULL || result == NULL) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	http_head->code = atol(ret_code);
+	http_head->code = atol(ret_code);
-	http_head->code_msg = result;
+	http_head->code_msg = result;
-	http_head->version = key;
+	http_head->version = key;
-	http_head->head_type = HTTP_HEAD_RESPONSE;
+	http_head->head_type = HTTP_HEAD_RESPONSE;
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-static int _http_head_parse_request(struct http_head *http_head, char *key, char *value)
+static int _http_head_parse_request(struct http_head *http_head, char *key, char *value)
-{
+{
-	int method = HTTP_METHOD_INVALID;
+	int method = HTTP_METHOD_INVALID;
-	char *url = NULL;
+	char *url = NULL;
-	char *version = NULL;
+	char *version = NULL;
-	char *tmp_ptr = value;
+	char *tmp_ptr = value;
-	char *field_start = NULL;
+	char *field_start = NULL;
-
+
-	if (strncmp(key, "GET", sizeof("GET")) == 0) {
+	if (strncmp(key, "GET", sizeof("GET")) == 0) {
-		method = HTTP_METHOD_GET;
+		method = HTTP_METHOD_GET;
-	} else if (strncmp(key, "POST", sizeof("POST")) == 0) {
+	} else if (strncmp(key, "POST", sizeof("POST")) == 0) {
-		method = HTTP_METHOD_POST;
+		method = HTTP_METHOD_POST;
-	} else if (strncmp(key, "PUT", sizeof("PUT")) == 0) {
+	} else if (strncmp(key, "PUT", sizeof("PUT")) == 0) {
-		method = HTTP_METHOD_PUT;
+		method = HTTP_METHOD_PUT;
-	} else if (strncmp(key, "DELETE", sizeof("DELETE")) == 0) {
+	} else if (strncmp(key, "DELETE", sizeof("DELETE")) == 0) {
-		method = HTTP_METHOD_DELETE;
+		method = HTTP_METHOD_DELETE;
-	} else if (strncmp(key, "TRACE", sizeof("TRACE")) == 0) {
+	} else if (strncmp(key, "TRACE", sizeof("TRACE")) == 0) {
-		method = HTTP_METHOD_TRACE;
+		method = HTTP_METHOD_TRACE;
-	} else if (strncmp(key, "CONNECT", sizeof("CONNECT")) == 0) {
+	} else if (strncmp(key, "CONNECT", sizeof("CONNECT")) == 0) {
-		method = HTTP_METHOD_CONNECT;
+		method = HTTP_METHOD_CONNECT;
-	} else {
+	} else {
-		return _http_head_parse_response(http_head, key, value);
+		return _http_head_parse_response(http_head, key, value);
-	}
+	}
-
+
-	for (tmp_ptr = value; *tmp_ptr != 0; tmp_ptr++) {
+	for (tmp_ptr = value; *tmp_ptr != 0; tmp_ptr++) {
-		if (field_start == NULL) {
+		if (field_start == NULL) {
-			field_start = tmp_ptr;
+			field_start = tmp_ptr;
-		}
+		}
-		if (*tmp_ptr == ' ') {
+		if (*tmp_ptr == ' ') {
-			*tmp_ptr = '\0';
+			*tmp_ptr = '\0';
-			if (url == NULL) {
+			if (url == NULL) {
-				url = field_start;
+				url = field_start;
-			}
+			}
-
+
-			field_start = NULL;
+			field_start = NULL;
-		}
+		}
-	}
+	}
-
+
-	if (field_start && version == NULL) {
+	if (field_start && version == NULL) {
-		version = field_start;
+		version = field_start;
-	}
+	}
-
+
-	http_head->method = method;
+	http_head->method = method;
-	http_head->url = url;
+	http_head->url = url;
-	http_head->version = version;
+	http_head->version = version;
-	http_head->head_type = HTTP_HEAD_REQUEST;
+	http_head->head_type = HTTP_HEAD_REQUEST;
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-static int _http_head_parse(struct http_head *http_head)
+static int _http_head_parse(struct http_head *http_head)
-{
+{
-	int i = 0;
+	int i = 0;
-	char *key = NULL;
+	char *key = NULL;
-	char *value = NULL;
+	char *value = NULL;
-	char *data;
+	char *data;
-	int has_first_line = 0;
+	int has_first_line = 0;
-
+
-	int inkey = 1;
+	int inkey = 1;
-	int invalue = 0;
+	int invalue = 0;
-
+
-	data = http_head->buff;
+	data = http_head->buff;
-	for (i = 0; i < http_head->head_len; i++, data++) {
+	for (i = 0; i < http_head->head_len; i++, data++) {
-		if (inkey) {
+		if (inkey) {
-			if (key == NULL && *data != ' ' && *data != '\r' && *data != '\n') {
+			if (key == NULL && *data != ' ' && *data != '\r' && *data != '\n') {
-				key = data;
+				key = data;
-				continue;
+				continue;
-			}
+			}
-
+
-			if (*data == ':' || *data == ' ') {
+			if (*data == ':' || *data == ' ') {
-				*data = '\0';
+				*data = '\0';
-				inkey = 0;
+				inkey = 0;
-				invalue = 1;
+				invalue = 1;
-				continue;
+				continue;
-			}
+			}
-		}
+		}
-
+
-		if (invalue) {
+		if (invalue) {
-			if (value == NULL && *data != ' ') {
+			if (value == NULL && *data != ' ') {
-				value = data;
+				value = data;
-				continue;
+				continue;
-			}
+			}
-
+
-			if (*data == '\r' || *data == '\n') {
+			if (*data == '\r' || *data == '\n') {
-				*data = '\0';
+				*data = '\0';
-				inkey = 1;
+				inkey = 1;
-				invalue = 0;
+				invalue = 0;
-			}
+			}
-		}
+		}
-
+
-		if (key && value && invalue == 0) {
+		if (key && value && invalue == 0) {
-			if (has_first_line == 0) {
+			if (has_first_line == 0) {
-				if (_http_head_parse_request(http_head, key, value) != 0) {
+				if (_http_head_parse_request(http_head, key, value) != 0) {
-					return -2;
+					return -2;
-				}
+				}
-
+
-				has_first_line = 1;
+				has_first_line = 1;
-			} else {
+			} else {
-				if (_http_head_add_fields(http_head, key, value) != 0) {
+				if (_http_head_add_fields(http_head, key, value) != 0) {
-					return -2;
+					return -2;
-				}
+				}
-			}
+			}
-
+
-			key = NULL;
+			key = NULL;
-			value = NULL;
+			value = NULL;
-			inkey = 1;
+			inkey = 1;
-			invalue = 0;
+			invalue = 0;
-		}
+		}
-	}
+	}
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-int http_head_parse(struct http_head *http_head, const char *data, int data_len)
+int http_head_parse(struct http_head *http_head, const char *data, int data_len)
-{
+{
-	int i = 0;
+	int i = 0;
-	char *buff_end = NULL;
+	char *buff_end = NULL;
-	int left_size = 0;
+	int left_size = 0;
-	int process_data_len = 0;
+	int process_data_len = 0;
-
+
-	left_size = http_head->buff_size - http_head->buff_len;
+	left_size = http_head->buff_size - http_head->buff_len;
-
+
-	if (left_size < data_len) {
+	if (left_size < data_len) {
-		return -3;
+		return -3;
-	}
+	}
-
+
-	buff_end = http_head->buff + http_head->buff_len;
+	buff_end = http_head->buff + http_head->buff_len;
-	if (http_head->head_ok == 0) {
+	if (http_head->head_ok == 0) {
-		for (i = 0; i < data_len; i++, data++) {
+		for (i = 0; i < data_len; i++, data++) {
-			*(buff_end + i) = *data;
+			*(buff_end + i) = *data;
-			if (*data == '\n') {
+			if (*data == '\n') {
-				if (http_head->buff_len + i < 2) {
+				if (http_head->buff_len + i < 2) {
-					continue;
+					continue;
-				}
+				}
-
+
-				if (*(buff_end + i - 2) == '\n') {
+				if (*(buff_end + i - 2) == '\n') {
-					http_head->head_ok = 1;
+					http_head->head_ok = 1;
-					http_head->head_len = http_head->buff_len + i - 2;
+					http_head->head_len = http_head->buff_len + i - 2;
-					i++;
+					i++;
-					buff_end += i;
+					buff_end += i;
-					data_len -= i;
+					data_len -= i;
-					data++;
+					data++;
-					if (_http_head_parse(http_head) != 0) {
+					if (_http_head_parse(http_head) != 0) {
-						return -2;
+						return -2;
-					}
+					}
-
+
-					const char *content_len = NULL;
+					const char *content_len = NULL;
-					content_len = http_head_get_fields_value(http_head, "Content-Length");
+					content_len = http_head_get_fields_value(http_head, "Content-Length");
-					if (content_len) {
+					if (content_len) {
-						http_head->expect_data_len = atol(content_len);
+						http_head->expect_data_len = atol(content_len);
-					} else {
+					} else {
-						http_head->expect_data_len = 0;
+						http_head->expect_data_len = 0;
-					}
+					}
-
+
-					if (http_head->expect_data_len < 0) {
+					if (http_head->expect_data_len < 0) {
-						return -2;
+						return -2;
-					}
+					}
-
+
-					break;
+					break;
-				}
+				}
-			}
+			}
-		}
+		}
-
+
-		process_data_len += i;
+		process_data_len += i;
-		if (http_head->head_ok == 0) {
+		if (http_head->head_ok == 0) {
-			// Read data again */
+			// Read data again */
-			http_head->buff_len += process_data_len;
+			http_head->buff_len += process_data_len;
-			return -1;
+			return -1;
-		}
+		}
-	}
+	}
-
+
-	if (http_head->head_ok == 1) {
+	if (http_head->head_ok == 1) {
-		int get_data_len = (http_head->expect_data_len > data_len) ? data_len : http_head->expect_data_len;
+		int get_data_len = (http_head->expect_data_len > data_len) ? data_len : http_head->expect_data_len;
-		if (http_head->data == NULL) {
+		if (http_head->data == NULL) {
-			http_head->data = buff_end;
+			http_head->data = buff_end;
-		}
+		}
-
+
-		memcpy(buff_end, data, get_data_len);
+		memcpy(buff_end, data, get_data_len);
-		process_data_len += get_data_len;
+		process_data_len += get_data_len;
-		http_head->data_len += get_data_len;
+		http_head->data_len += get_data_len;
-	}
+	}
-
+
-	http_head->buff_len += process_data_len;
+	http_head->buff_len += process_data_len;
-	if (http_head->data_len < http_head->expect_data_len) {
+	if (http_head->data_len < http_head->expect_data_len) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	return process_data_len;
+	return process_data_len;
-}
+}
-
+
-void http_head_destroy(struct http_head *http_head)
+void http_head_destroy(struct http_head *http_head)
-{
+{
-	struct http_head_fields *fields, *tmp;
+	struct http_head_fields *fields, *tmp;
-
+
-	list_for_each_entry_safe(fields, tmp, &http_head->field_head.list, list)
+	list_for_each_entry_safe(fields, tmp, &http_head->field_head.list, list)
-	{
+	{
-		list_del(&fields->list);
+		list_del(&fields->list);
-		free(fields);
+		free(fields);
-	}
+	}
-
+
-	if (http_head->buff) {
+	if (http_head->buff) {
-		free(http_head->buff);
+		free(http_head->buff);
-	}
+	}
-
+
-	free(http_head);
+	free(http_head);
-}
+}

src/http_parse.h

@@ -1,87 +1,87 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#ifndef HTTP_PARSER_H
+#ifndef HTTP_PARSER_H
-#define HTTP_PARSER_H
+#define HTTP_PARSER_H
-
+
-#ifdef __cpluscplus
+#ifdef __cpluscplus
-extern "C" {
+extern "C" {
-#endif
+#endif
-
+
-struct http_head;
+struct http_head;
-struct http_head_fields;
+struct http_head_fields;
-
+
-typedef enum HTTP_METHOD {
+typedef enum HTTP_METHOD {
-	HTTP_METHOD_INVALID = 0,
+	HTTP_METHOD_INVALID = 0,
-	HTTP_METHOD_GET,
+	HTTP_METHOD_GET,
-	HTTP_METHOD_HEAD,
+	HTTP_METHOD_HEAD,
-	HTTP_METHOD_POST,
+	HTTP_METHOD_POST,
-	HTTP_METHOD_PUT,
+	HTTP_METHOD_PUT,
-	HTTP_METHOD_DELETE,
+	HTTP_METHOD_DELETE,
-	HTTP_METHOD_TRACE,
+	HTTP_METHOD_TRACE,
-	HTTP_METHOD_CONNECT,
+	HTTP_METHOD_CONNECT,
-} HTTP_METHOD;
+} HTTP_METHOD;
-
+
-typedef enum HTTP_HEAD_TYPE {
+typedef enum HTTP_HEAD_TYPE {
-	HTTP_HEAD_INVALID = 0,
+	HTTP_HEAD_INVALID = 0,
-	HTTP_HEAD_REQUEST = 1,
+	HTTP_HEAD_REQUEST = 1,
-	HTTP_HEAD_RESPONSE = 2,
+	HTTP_HEAD_RESPONSE = 2,
-} HTTP_HEAD_TYPE;
+} HTTP_HEAD_TYPE;
-
+
-struct http_head *http_head_init(int buffsize);
+struct http_head *http_head_init(int buffsize);
-
+
-HTTP_HEAD_TYPE http_head_get_head_type(struct http_head *http_head);
+HTTP_HEAD_TYPE http_head_get_head_type(struct http_head *http_head);
-
+
-HTTP_METHOD http_head_get_method(struct http_head *http_head);
+HTTP_METHOD http_head_get_method(struct http_head *http_head);
-
+
-const char *http_head_get_url(struct http_head *http_head);
+const char *http_head_get_url(struct http_head *http_head);
-
+
-const char *http_head_get_httpversion(struct http_head *http_head);
+const char *http_head_get_httpversion(struct http_head *http_head);
-
+
-int http_head_get_httpcode(struct http_head *http_head);
+int http_head_get_httpcode(struct http_head *http_head);
-
+
-char *http_head_get_httpcode_msg(struct http_head *http_head);
+char *http_head_get_httpcode_msg(struct http_head *http_head);
-
+
-char *http_head_get_data(struct http_head *http_head);
+char *http_head_get_data(struct http_head *http_head);
-
+
-int http_head_get_data_len(struct http_head *http_head);
+int http_head_get_data_len(struct http_head *http_head);
-
+
-struct http_head_fields *http_head_first_fields(struct http_head *http_head);
+struct http_head_fields *http_head_first_fields(struct http_head *http_head);
-
+
-struct http_head_fields *http_head_next_fields(struct http_head_fields *fields);
+struct http_head_fields *http_head_next_fields(struct http_head_fields *fields);
-
+
-const char *http_head_get_fields_value(struct http_head *http_head, const char *name);
+const char *http_head_get_fields_value(struct http_head *http_head, const char *name);
-
+
-int http_head_lookup_fields(struct http_head_fields *fields, const char **name, const char **value);
+int http_head_lookup_fields(struct http_head_fields *fields, const char **name, const char **value);
-
+
-/*
+/*
- * Returns:
+ * Returns:
- *  >=0  - success http data len
+ *  >=0  - success http data len
- *  -1   - Incomplete request
+ *  -1   - Incomplete request
- *  -2   - parse failed
+ *  -2   - parse failed
- *  -3   - buffer is small
+ *  -3   - buffer is small
- */
+ */
-int http_head_parse(struct http_head *http_head, const char *data, int data_len);
+int http_head_parse(struct http_head *http_head, const char *data, int data_len);
-
+
-void http_head_destroy(struct http_head *http_head);
+void http_head_destroy(struct http_head *http_head);
-
+
-#ifdef __cpluscplus
+#ifdef __cpluscplus
-}
+}
-#endif
+#endif
-
+
-#endif // !HTTP_PARSER_H
+#endif // !HTTP_PARSER_H

src/include/art.h

@@ -1,251 +1,251 @@
-/*
+/*
-Copyright (c) 2012, Armon Dadgar
+Copyright (c) 2012, Armon Dadgar
-All rights reserved.
+All rights reserved.
-
+
-Redistribution and use in source and binary forms, with or without
+Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
+modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
+    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
+      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
+    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
+      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+      documentation and/or other materials provided with the distribution.
-    * Neither the name of the organization nor the
+    * Neither the name of the organization nor the
-      names of its contributors may be used to endorse or promote products
+      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
+      derived from this software without specific prior written permission.
-
+
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL ARMON DADGAR BE LIABLE FOR ANY
+DISCLAIMED. IN NO EVENT SHALL ARMON DADGAR BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+*/
-#include <stdint.h>
+#include <stdint.h>
-#ifndef ART_H
+#ifndef ART_H
-#define ART_H
+#define ART_H
-
+
-#ifdef __cplusplus
+#ifdef __cplusplus
-extern "C" {
+extern "C" {
-#endif
+#endif
-
+
-#define NODE4   1
+#define NODE4   1
-#define NODE16  2
+#define NODE16  2
-#define NODE48  3
+#define NODE48  3
-#define NODE256 4
+#define NODE256 4
-
+
-#define MAX_PREFIX_LEN 10
+#define MAX_PREFIX_LEN 10
-
+
-#if defined(__GNUC__) && !defined(__clang__)
+#if defined(__GNUC__) && !defined(__clang__)
-# if __STDC_VERSION__ >= 199901L && 402 == (__GNUC__ * 100 + __GNUC_MINOR__)
+# if __STDC_VERSION__ >= 199901L && 402 == (__GNUC__ * 100 + __GNUC_MINOR__)
-/*
+/*
- * GCC 4.2.2's C99 inline keyword support is pretty broken; avoid. Introduced in
+ * GCC 4.2.2's C99 inline keyword support is pretty broken; avoid. Introduced in
- * GCC 4.2.something, fixed in 4.3.0. So checking for specific major.minor of
+ * GCC 4.2.something, fixed in 4.3.0. So checking for specific major.minor of
- * 4.2 is fine.
+ * 4.2 is fine.
- */
+ */
-#  define BROKEN_GCC_C99_INLINE
+#  define BROKEN_GCC_C99_INLINE
-# endif
+# endif
-#endif
+#endif
-
+
-typedef int(*art_callback)(void *data, const unsigned char *key, uint32_t key_len, void *value);
+typedef int(*art_callback)(void *data, const unsigned char *key, uint32_t key_len, void *value);
-
+
-/**
+/**
- * This struct is included as part
+ * This struct is included as part
- * of all the various node sizes
+ * of all the various node sizes
- */
+ */
-typedef struct {
+typedef struct {
-    uint8_t type;
+    uint8_t type;
-    uint8_t num_children;
+    uint8_t num_children;
-    uint32_t partial_len;
+    uint32_t partial_len;
-    unsigned char partial[MAX_PREFIX_LEN];
+    unsigned char partial[MAX_PREFIX_LEN];
-} art_node;
+} art_node;
-
+
-/**
+/**
- * Small node with only 4 children
+ * Small node with only 4 children
- */
+ */
-typedef struct {
+typedef struct {
-    art_node n;
+    art_node n;
-    unsigned char keys[4];
+    unsigned char keys[4];
-    art_node *children[4];
+    art_node *children[4];
-} art_node4;
+} art_node4;
-
+
-/**
+/**
- * Node with 16 children
+ * Node with 16 children
- */
+ */
-typedef struct {
+typedef struct {
-    art_node n;
+    art_node n;
-    unsigned char keys[16];
+    unsigned char keys[16];
-    art_node *children[16];
+    art_node *children[16];
-} art_node16;
+} art_node16;
-
+
-/**
+/**
- * Node with 48 children, but
+ * Node with 48 children, but
- * a full 256 byte field.
+ * a full 256 byte field.
- */
+ */
-typedef struct {
+typedef struct {
-    art_node n;
+    art_node n;
-    unsigned char keys[256];
+    unsigned char keys[256];
-    art_node *children[48];
+    art_node *children[48];
-} art_node48;
+} art_node48;
-
+
-/**
+/**
- * Full node with 256 children
+ * Full node with 256 children
- */
+ */
-typedef struct {
+typedef struct {
-    art_node n;
+    art_node n;
-    art_node *children[256];
+    art_node *children[256];
-} art_node256;
+} art_node256;
-
+
-/**
+/**
- * Represents a leaf. These are
+ * Represents a leaf. These are
- * of arbitrary size, as they include the key.
+ * of arbitrary size, as they include the key.
- */
+ */
-typedef struct {
+typedef struct {
-    void *value;
+    void *value;
-    uint32_t key_len;
+    uint32_t key_len;
-    unsigned char key[0];
+    unsigned char key[0];
-} art_leaf;
+} art_leaf;
-
+
-/**
+/**
- * Main struct, points to root.
+ * Main struct, points to root.
- */
+ */
-typedef struct {
+typedef struct {
-    art_node *root;
+    art_node *root;
-    uint64_t size;
+    uint64_t size;
-} art_tree;
+} art_tree;
-
+
-/**
+/**
- * Initializes an ART tree
+ * Initializes an ART tree
- * @return 0 on success.
+ * @return 0 on success.
- */
+ */
-int art_tree_init(art_tree *t);
+int art_tree_init(art_tree *t);
-
+
-/**
+/**
- * DEPRECATED
+ * DEPRECATED
- * Initializes an ART tree
+ * Initializes an ART tree
- * @return 0 on success.
+ * @return 0 on success.
- */
+ */
-#define init_art_tree(...) art_tree_init(__VA_ARGS__)
+#define init_art_tree(...) art_tree_init(__VA_ARGS__)
-
+
-/**
+/**
- * Destroys an ART tree
+ * Destroys an ART tree
- * @return 0 on success.
+ * @return 0 on success.
- */
+ */
-int art_tree_destroy(art_tree *t);
+int art_tree_destroy(art_tree *t);
-
+
-/**
+/**
- * DEPRECATED
+ * DEPRECATED
- * Initializes an ART tree
+ * Initializes an ART tree
- * @return 0 on success.
+ * @return 0 on success.
- */
+ */
-#define destroy_art_tree(...) art_tree_destroy(__VA_ARGS__)
+#define destroy_art_tree(...) art_tree_destroy(__VA_ARGS__)
-
+
-/**
+/**
- * Returns the size of the ART tree.
+ * Returns the size of the ART tree.
- */
+ */
-#ifdef BROKEN_GCC_C99_INLINE
+#ifdef BROKEN_GCC_C99_INLINE
-# define art_size(t) ((t)->size)
+# define art_size(t) ((t)->size)
-#else
+#else
-static inline uint64_t art_size(art_tree *t) {
+static inline uint64_t art_size(art_tree *t) {
-    return t->size;
+    return t->size;
-}
+}
-#endif
+#endif
-
+
-/**
+/**
- * Inserts a new value into the ART tree
+ * Inserts a new value into the ART tree
- * @arg t The tree
+ * @arg t The tree
- * @arg key The key
+ * @arg key The key
- * @arg key_len The length of the key
+ * @arg key_len The length of the key
- * @arg value Opaque value.
+ * @arg value Opaque value.
- * @return NULL if the item was newly inserted, otherwise
+ * @return NULL if the item was newly inserted, otherwise
- * the old value pointer is returned.
+ * the old value pointer is returned.
- */
+ */
-void* art_insert(art_tree *t, const unsigned char *key, int key_len, void *value);
+void* art_insert(art_tree *t, const unsigned char *key, int key_len, void *value);
-
+
-/**
+/**
- * Deletes a value from the ART tree
+ * Deletes a value from the ART tree
- * @arg t The tree
+ * @arg t The tree
- * @arg key The key
+ * @arg key The key
- * @arg key_len The length of the key
+ * @arg key_len The length of the key
- * @return NULL if the item was not found, otherwise
+ * @return NULL if the item was not found, otherwise
- * the value pointer is returned.
+ * the value pointer is returned.
- */
+ */
-void* art_delete(art_tree *t, const unsigned char *key, int key_len);
+void* art_delete(art_tree *t, const unsigned char *key, int key_len);
-
+
-/**
+/**
- * Searches for a value in the ART tree
+ * Searches for a value in the ART tree
- * @arg t The tree
+ * @arg t The tree
- * @arg key The key
+ * @arg key The key
- * @arg key_len The length of the key
+ * @arg key_len The length of the key
- * @return NULL if the item was not found, otherwise
+ * @return NULL if the item was not found, otherwise
- * the value pointer is returned.
+ * the value pointer is returned.
- */
+ */
-void* art_search(const art_tree *t, const unsigned char *key, int key_len);
+void* art_search(const art_tree *t, const unsigned char *key, int key_len);
-
+
-/**
+/**
- * Searches substring for a value in the ART tree
+ * Searches substring for a value in the ART tree
- * @arg t The tree
+ * @arg t The tree
- * @arg str The key
+ * @arg str The key
- * @arg str_len The length of the key
+ * @arg str_len The length of the key
- * @return NULL if the item was not found, otherwise
+ * @return NULL if the item was not found, otherwise
- * the value pointer is returned.
+ * the value pointer is returned.
- */
+ */
-void *art_substring(const art_tree *t, const unsigned char *str, int str_len, unsigned char *key, int *key_len);
+void *art_substring(const art_tree *t, const unsigned char *str, int str_len, unsigned char *key, int *key_len);
-
+
-/**
+/**
- * Wakk substring for a value in the ART tree
+ * Wakk substring for a value in the ART tree
- * @arg t The tree
+ * @arg t The tree
- * @arg str The key
+ * @arg str The key
- * @arg str_len The length of the key
+ * @arg str_len The length of the key
- * @return NULL if the item was not found, otherwise
+ * @return NULL if the item was not found, otherwise
- * the value pointer is returned.
+ * the value pointer is returned.
- */
+ */
-typedef int (*walk_func)(unsigned char *key, uint32_t key_len, void *value, void *arg);
+typedef int (*walk_func)(unsigned char *key, uint32_t key_len, void *value, void *arg);
-void art_substring_walk(const art_tree *t, const unsigned char *str, int str_len, walk_func func, void *arg);
+void art_substring_walk(const art_tree *t, const unsigned char *str, int str_len, walk_func func, void *arg);
-
+
-/**
+/**
- * Returns the minimum valued leaf
+ * Returns the minimum valued leaf
- * @return The minimum leaf or NULL
+ * @return The minimum leaf or NULL
- */
+ */
-art_leaf* art_minimum(art_tree *t);
+art_leaf* art_minimum(art_tree *t);
-
+
-/**
+/**
- * Returns the maximum valued leaf
+ * Returns the maximum valued leaf
- * @return The maximum leaf or NULL
+ * @return The maximum leaf or NULL
- */
+ */
-art_leaf* art_maximum(art_tree *t);
+art_leaf* art_maximum(art_tree *t);
-
+
-/**
+/**
- * Iterates through the entries pairs in the map,
+ * Iterates through the entries pairs in the map,
- * invoking a callback for each. The call back gets a
+ * invoking a callback for each. The call back gets a
- * key, value for each and returns an integer stop value.
+ * key, value for each and returns an integer stop value.
- * If the callback returns non-zero, then the iteration stops.
+ * If the callback returns non-zero, then the iteration stops.
- * @arg t The tree to iterate over
+ * @arg t The tree to iterate over
- * @arg cb The callback function to invoke
+ * @arg cb The callback function to invoke
- * @arg data Opaque handle passed to the callback
+ * @arg data Opaque handle passed to the callback
- * @return 0 on success, or the return of the callback.
+ * @return 0 on success, or the return of the callback.
- */
+ */
-int art_iter(art_tree *t, art_callback cb, void *data);
+int art_iter(art_tree *t, art_callback cb, void *data);
-
+
-/**
+/**
- * Iterates through the entries pairs in the map,
+ * Iterates through the entries pairs in the map,
- * invoking a callback for each that matches a given prefix.
+ * invoking a callback for each that matches a given prefix.
- * The call back gets a key, value for each and returns an integer stop value.
+ * The call back gets a key, value for each and returns an integer stop value.
- * If the callback returns non-zero, then the iteration stops.
+ * If the callback returns non-zero, then the iteration stops.
- * @arg t The tree to iterate over
+ * @arg t The tree to iterate over
- * @arg prefix The prefix of keys to read
+ * @arg prefix The prefix of keys to read
- * @arg prefix_len The length of the prefix
+ * @arg prefix_len The length of the prefix
- * @arg cb The callback function to invoke
+ * @arg cb The callback function to invoke
- * @arg data Opaque handle passed to the callback
+ * @arg data Opaque handle passed to the callback
- * @return 0 on success, or the return of the callback.
+ * @return 0 on success, or the return of the callback.
- */
+ */
-int art_iter_prefix(art_tree *t, const unsigned char *prefix, int prefix_len, art_callback cb, void *data);
+int art_iter_prefix(art_tree *t, const unsigned char *prefix, int prefix_len, art_callback cb, void *data);
-
+
-#ifdef __cplusplus
+#ifdef __cplusplus
-}
+}
-#endif
+#endif
-
+
-#endif
+#endif

src/include/conf.h

@@ -1,142 +1,141 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-
+#ifndef _GENERIC_CONF_H
-#ifndef _GENERIC_CONF_H
+#define _GENERIC_CONF_H
-#define _GENERIC_CONF_H
+
-
+#include <unistd.h>
-#include <unistd.h>
+
-
+#define MAX_LINE_LEN 1024
-#define MAX_LINE_LEN 1024
+#define MAX_KEY_LEN 64
-#define MAX_KEY_LEN 64
+#define CONF_INT_MAX (~(1 << 31))
-#define CONF_INT_MAX (~(1 << 31))
+#define CONF_INT_MIN (1 << 31)
-#define CONF_INT_MIN (1 << 31)
+
-
+#define CONF_RET_OK 0
-#define CONF_RET_OK     0
+#define CONF_RET_ERR -1
-#define CONF_RET_ERR   -1
+#define CONF_RET_WARN -2
-#define CONF_RET_WARN  -2
+#define CONF_RET_NOENT -3
-#define CONF_RET_NOENT -3
+
-
+struct config_item {
-struct config_item {
+	const char *item;
-	const char *item;
+	int (*item_func)(const char *item, void *data, int argc, char *argv[]);
-	int (*item_func)(const char *item, void *data, int argc, char *argv[]);
+	void *data;
-	void *data;
+};
-};
+
-
+struct config_item_custom {
-struct config_item_custom {
+	void *custom_data;
-	void *custom_data;
+	int (*custom_func)(void *data, int argc, char *argv[]);
-	int (*custom_func)(void *data, int argc, char *argv[]);
+};
-};
+
-
+struct config_item_int {
-struct config_item_int {
+	int *data;
-	int *data;
+	int min;
-	int min;
+	int max;
-	int max;
+};
-};
+
-
+struct config_item_string {
-struct config_item_string {
+	char *data;
-	char *data;
+	size_t size;
-	size_t size;
+};
-};
+
-
+struct config_item_yesno {
-struct config_item_yesno {
+	int *data;
-	int *data;
+};
-};
+
-
+struct config_item_size {
-struct config_item_size {
+	size_t *data;
-	size_t *data;
+	size_t min;
-	size_t min;
+	size_t max;
-	size_t max;
+};
-};
+
-
+#define CONF_INT(key, value, min_value, max_value)                                                                     \
-#define CONF_INT(key, value, min_value, max_value)                                                                                                             \
+	{                                                                                                                  \
-	{                                                                                                                                                          \
+		key, conf_int, &(struct config_item_int)                                                                       \
-		key, conf_int, &(struct config_item_int)                                                                                                               \
+		{                                                                                                              \
-		{                                                                                                                                                      \
+			.data = value, .min = min_value, .max = max_value                                                          \
-			.data = value, .min = min_value, .max = max_value                                                                                                  \
+		}                                                                                                              \
-		}                                                                                                                                                      \
+	}
-	}
+#define CONF_STRING(key, value, len_value)                                                                             \
-#define CONF_STRING(key, value, len_value)                                                                                                                     \
+	{                                                                                                                  \
-	{                                                                                                                                                          \
+		key, conf_string, &(struct config_item_string)                                                                 \
-		key, conf_string, &(struct config_item_string)                                                                                                         \
+		{                                                                                                              \
-		{                                                                                                                                                      \
+			.data = value, .size = len_value                                                                           \
-			.data = value, .size = len_value                                                                                                                   \
+		}                                                                                                              \
-		}                                                                                                                                                      \
+	}
-	}
+#define CONF_YESNO(key, value)                                                                                         \
-#define CONF_YESNO(key, value)                                                                                                                                 \
+	{                                                                                                                  \
-	{                                                                                                                                                          \
+		key, conf_yesno, &(struct config_item_yesno)                                                                   \
-		key, conf_yesno, &(struct config_item_yesno)                                                                                                           \
+		{                                                                                                              \
-		{                                                                                                                                                      \
+			.data = value                                                                                              \
-			.data = value                                                                                                                                      \
+		}                                                                                                              \
-		}                                                                                                                                                      \
+	}
-	}
+#define CONF_SIZE(key, value, min_value, max_value)                                                                    \
-#define CONF_SIZE(key, value, min_value, max_value)                                                                                                            \
+	{                                                                                                                  \
-	{                                                                                                                                                          \
+		key, conf_size, &(struct config_item_size)                                                                     \
-		key, conf_size, &(struct config_item_size)                                                                                                             \
+		{                                                                                                              \
-		{                                                                                                                                                      \
+			.data = value, .min = min_value, .max = max_value                                                          \
-			.data = value, .min = min_value, .max = max_value                                                                                                  \
+		}                                                                                                              \
-		}                                                                                                                                                      \
+	}
-	}
+/*
-/*
+ * func: int (*func)(void *data, int argc, char *argv[]);
- * func: int (*func)(void *data, int argc, char *argv[]);
+ */
- */
+#define CONF_CUSTOM(key, func, data)                                                                                   \
-#define CONF_CUSTOM(key, func, data)                                                                                                                           \
+	{                                                                                                                  \
-	{                                                                                                                                                          \
+		key, conf_custom, &(struct config_item_custom)                                                                 \
-		key, conf_custom, &(struct config_item_custom)                                                                                                         \
+		{                                                                                                              \
-		{                                                                                                                                                      \
+			.custom_data = data, .custom_func = func                                                                   \
-			.custom_data = data, .custom_func = func                                                                                                           \
+		}                                                                                                              \
-		}                                                                                                                                                      \
+	}
-	}
+
-
+#define CONF_END()                                                                                                     \
-#define CONF_END()                                                                                                                                             \
+	{                                                                                                                  \
-	{                                                                                                                                                          \
+		NULL, NULL, NULL                                                                                               \
-		NULL, NULL, NULL                                                                                                                                                \
+	}
-	}
+
-
+extern int conf_custom(const char *item, void *data, int argc, char *argv[]);
-extern int conf_custom(const char *item, void *data, int argc, char *argv[]);
+
-
+extern int conf_int(const char *item, void *data, int argc, char *argv[]);
-extern int conf_int(const char *item, void *data, int argc, char *argv[]);
+
-
+extern int conf_string(const char *item, void *data, int argc, char *argv[]);
-extern int conf_string(const char *item, void *data, int argc, char *argv[]);
+
-
+extern int conf_yesno(const char *item, void *data, int argc, char *argv[]);
-extern int conf_yesno(const char *item, void *data, int argc, char *argv[]);
+
-
+extern int conf_size(const char *item, void *data, int argc, char *argv[]);
-extern int conf_size(const char *item, void *data, int argc, char *argv[]);
+
-
+/*
-/*
+ * Example:
- * Example:
+ *  int num = 0;
- *  int num = 0;
+ *
- *
+ *  struct config_item itmes [] = {
- *  struct config_item itmes [] = {
+ *       CONF_INT("CONF_NUM", &num, -1, 10),
- *       CONF_INT("CONF_NUM", &num, -1, 10),
+ *       CONF_END();
- *       CONF_END();
+ *  }
- *  }
+ *
- *
+ *  load_conf(file, items);
- *  load_conf(file, items);
+ *
- *
+ */
- */
+
-
+typedef int(conf_error_handler)(const char *file, int lineno, int ret);
-typedef int(conf_error_handler)(const char *file, int lineno, int ret);
+
-
+int load_conf(const char *file, struct config_item items[], conf_error_handler handler);
-int load_conf(const char *file, struct config_item items[], conf_error_handler handler);
+
-
+void load_exit(void);
-void load_exit(void);
+
-
+const char *conf_get_conf_file(void);
-const char *conf_get_conf_file(void);
+
-
+#endif // !_GENERIC_CONF_H
-#endif // !_GENERIC_CONF_H

src/include/radix.h

@@ -1,162 +1,162 @@
-/*
+/*
- * Copyright (c) 1999-2000
+ * Copyright (c) 1999-2000
- * 
+ * 
- * The Regents of the University of Michigan ("The Regents") and
+ * The Regents of the University of Michigan ("The Regents") and
- * Merit Network, Inc. All rights reserved.  Redistribution and use
+ * Merit Network, Inc. All rights reserved.  Redistribution and use
- * in source and binary forms, with or without modification, are
+ * in source and binary forms, with or without modification, are
- * permitted provided that the following conditions are met:
+ * permitted provided that the following conditions are met:
- * 
+ * 
- * 1. Redistributions of source code must retain the above 
+ * 1. Redistributions of source code must retain the above 
- * copyright notice, this list of conditions and the 
+ * copyright notice, this list of conditions and the 
- * following disclaimer.
+ * following disclaimer.
- * 
+ * 
- * 2. Redistributions in binary form must reproduce the above 
+ * 2. Redistributions in binary form must reproduce the above 
- * copyright notice, this list of conditions and the 
+ * copyright notice, this list of conditions and the 
- * following disclaimer in the documentation and/or other 
+ * following disclaimer in the documentation and/or other 
- * materials provided with the distribution.
+ * materials provided with the distribution.
- * 
+ * 
- * 3. All advertising materials mentioning features or use of 
+ * 3. All advertising materials mentioning features or use of 
- * this software must display the following acknowledgement:
+ * this software must display the following acknowledgement:
- * 
+ * 
- *   This product includes software developed by the University of
+ *   This product includes software developed by the University of
- *   Michigan, Merit Network, Inc., and their contributors.
+ *   Michigan, Merit Network, Inc., and their contributors.
- * 
+ * 
- * 4. Neither the name of the University, Merit Network, nor the
+ * 4. Neither the name of the University, Merit Network, nor the
- * names of their contributors may be used to endorse or 
+ * names of their contributors may be used to endorse or 
- * promote products derived from this software without 
+ * promote products derived from this software without 
- * specific prior written permission.
+ * specific prior written permission.
- * 
+ * 
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS"
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TH E REGENTS
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TH E REGENTS
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HO WEVER CAUSED
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HO WEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
+ * POSSIBILITY OF SUCH DAMAGE.
- */
+ */
-/*
+/*
- * Portions Copyright (c) 2004,2005 Damien Miller <djm@mindrot.org>
+ * Portions Copyright (c) 2004,2005 Damien Miller <djm@mindrot.org>
- *
+ *
- * Permission to use, copy, modify, and distribute this software for any
+ * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
+ * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
+ * copyright notice and this permission notice appear in all copies.
- *
+ *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
+ */
-
+
-/* $Id: radix.h,v 1.9 2007/10/24 06:03:08 djm Exp $ */
+/* $Id: radix.h,v 1.9 2007/10/24 06:03:08 djm Exp $ */
-
+
-#ifndef _RADIX_H
+#ifndef _RADIX_H
-#define _RADIX_H
+#define _RADIX_H
-
+
-#if defined(_MSC_VER)
+#if defined(_MSC_VER)
-#include <winsock2.h>
+#include <winsock2.h>
-#include <ws2tcpip.h>
+#include <ws2tcpip.h>
-#else
+#else
-# include <sys/types.h>
+# include <sys/types.h>
-# include <sys/socket.h>
+# include <sys/socket.h>
-# include <netinet/in.h>
+# include <netinet/in.h>
-# include <arpa/inet.h>
+# include <arpa/inet.h>
-# include <netdb.h>
+# include <netdb.h>
-#endif
+#endif
-
+
-#if defined(_MSC_VER)
+#if defined(_MSC_VER)
-# define snprintf _snprintf
+# define snprintf _snprintf
-typedef unsigned __int8		u_int8_t;
+typedef unsigned __int8		u_int8_t;
-typedef unsigned __int16	u_int16_t;
+typedef unsigned __int16	u_int16_t;
-typedef unsigned __int32	u_int32_t;
+typedef unsigned __int32	u_int32_t;
-const char *inet_ntop(int af, const void *src, char *dst, size_t size);
+const char *inet_ntop(int af, const void *src, char *dst, size_t size);
-size_t strlcpy(char *dst, const char *src, size_t size);
+size_t strlcpy(char *dst, const char *src, size_t size);
-#endif
+#endif
-
+
-/*
+/*
- * Originally from MRT include/mrt.h
+ * Originally from MRT include/mrt.h
- * $MRTId: mrt.h,v 1.1.1.1 2000/08/14 18:46:10 labovit Exp $
+ * $MRTId: mrt.h,v 1.1.1.1 2000/08/14 18:46:10 labovit Exp $
- */
+ */
-typedef struct _prefix_t {
+typedef struct _prefix_t {
-	u_int family;			/* AF_INET | AF_INET6 */
+	u_int family;			/* AF_INET | AF_INET6 */
-	u_int bitlen;			/* same as mask? */
+	u_int bitlen;			/* same as mask? */
-	int ref_count;			/* reference count */
+	int ref_count;			/* reference count */
-	union {
+	union {
-		struct in_addr sin;
+		struct in_addr sin;
-		struct in6_addr sin6;
+		struct in6_addr sin6;
-	} add;
+	} add;
-} prefix_t;
+} prefix_t;
-
+
-void Deref_Prefix(prefix_t *prefix);
+void Deref_Prefix(prefix_t *prefix);
-
+
-/*
+/*
- * Originally from MRT include/radix.h
+ * Originally from MRT include/radix.h
- * $MRTId: radix.h,v 1.1.1.1 2000/08/14 18:46:10 labovit Exp $
+ * $MRTId: radix.h,v 1.1.1.1 2000/08/14 18:46:10 labovit Exp $
- */
+ */
-typedef struct _radix_node_t {
+typedef struct _radix_node_t {
-	u_int bit;			/* flag if this node used */
+	u_int bit;			/* flag if this node used */
-	prefix_t *prefix;		/* who we are in radix tree */
+	prefix_t *prefix;		/* who we are in radix tree */
-	struct _radix_node_t *l, *r;	/* left and right children */
+	struct _radix_node_t *l, *r;	/* left and right children */
-	struct _radix_node_t *parent;	/* may be used */
+	struct _radix_node_t *parent;	/* may be used */
-	void *data;			/* pointer to data */
+	void *data;			/* pointer to data */
-} radix_node_t;
+} radix_node_t;
-
+
-typedef struct _radix_tree_t {
+typedef struct _radix_tree_t {
-	radix_node_t *head;
+	radix_node_t *head;
-	u_int maxbits;			/* for IP, 32 bit addresses */
+	u_int maxbits;			/* for IP, 32 bit addresses */
-	int num_active_node;		/* for debug purpose */
+	int num_active_node;		/* for debug purpose */
-} radix_tree_t;
+} radix_tree_t;
-
+
-/* Type of callback function */
+/* Type of callback function */
-typedef void (*rdx_cb_t)(radix_node_t *, void *);
+typedef void (*rdx_cb_t)(radix_node_t *, void *);
-
+
-radix_tree_t *New_Radix(void);
+radix_tree_t *New_Radix(void);
-void Destroy_Radix(radix_tree_t *radix, rdx_cb_t func, void *cbctx);
+void Destroy_Radix(radix_tree_t *radix, rdx_cb_t func, void *cbctx);
-radix_node_t *radix_lookup(radix_tree_t *radix, prefix_t *prefix);
+radix_node_t *radix_lookup(radix_tree_t *radix, prefix_t *prefix);
-void radix_remove(radix_tree_t *radix, radix_node_t *node);
+void radix_remove(radix_tree_t *radix, radix_node_t *node);
-radix_node_t *radix_search_exact(radix_tree_t *radix, prefix_t *prefix);
+radix_node_t *radix_search_exact(radix_tree_t *radix, prefix_t *prefix);
-radix_node_t *radix_search_best(radix_tree_t *radix, prefix_t *prefix);
+radix_node_t *radix_search_best(radix_tree_t *radix, prefix_t *prefix);
-void radix_process(radix_tree_t *radix, rdx_cb_t func, void *cbctx);
+void radix_process(radix_tree_t *radix, rdx_cb_t func, void *cbctx);
-
+
-#define RADIX_MAXBITS 128
+#define RADIX_MAXBITS 128
-
+
-#define RADIX_WALK(Xhead, Xnode) \
+#define RADIX_WALK(Xhead, Xnode) \
-	do { \
+	do { \
-		radix_node_t *Xstack[RADIX_MAXBITS+1]; \
+		radix_node_t *Xstack[RADIX_MAXBITS+1]; \
-		radix_node_t **Xsp = Xstack; \
+		radix_node_t **Xsp = Xstack; \
-		radix_node_t *Xrn = (Xhead); \
+		radix_node_t *Xrn = (Xhead); \
-		while ((Xnode = Xrn)) { \
+		while ((Xnode = Xrn)) { \
-			if (Xnode->prefix)
+			if (Xnode->prefix)
-
+
-#define RADIX_WALK_END \
+#define RADIX_WALK_END \
-			if (Xrn->l) { \
+			if (Xrn->l) { \
-				if (Xrn->r) { \
+				if (Xrn->r) { \
-					*Xsp++ = Xrn->r; \
+					*Xsp++ = Xrn->r; \
-				} \
+				} \
-				Xrn = Xrn->l; \
+				Xrn = Xrn->l; \
-			} else if (Xrn->r) { \
+			} else if (Xrn->r) { \
-				Xrn = Xrn->r; \
+				Xrn = Xrn->r; \
-			} else if (Xsp != Xstack) { \
+			} else if (Xsp != Xstack) { \
-				Xrn = *(--Xsp); \
+				Xrn = *(--Xsp); \
-			} else { \
+			} else { \
-				Xrn = (radix_node_t *) 0; \
+				Xrn = (radix_node_t *) 0; \
-			} \
+			} \
-		} \
+		} \
-	} while (0)
+	} while (0)
-
+
-/* Local additions */
+/* Local additions */
-
+
-prefix_t *prefix_pton(const char *string, long len, prefix_t *prefix, const char **errmsg);
+prefix_t *prefix_pton(const char *string, long len, prefix_t *prefix, const char **errmsg);
-prefix_t *prefix_from_blob(unsigned char *blob, int len, int prefixlen, prefix_t *prefix);
+prefix_t *prefix_from_blob(unsigned char *blob, int len, int prefixlen, prefix_t *prefix);
-const char *prefix_addr_ntop(prefix_t *prefix, char *buf, size_t len);
+const char *prefix_addr_ntop(prefix_t *prefix, char *buf, size_t len);
-const char *prefix_ntop(prefix_t *prefix, char *buf, size_t len);
+const char *prefix_ntop(prefix_t *prefix, char *buf, size_t len);
-
+
-#endif /* _RADIX_H */
+#endif /* _RADIX_H */
-
+

src/include/rbtree.h

@@ -1,305 +1,305 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#ifndef _GENERIC_RBTREE_H
+#ifndef _GENERIC_RBTREE_H
-#define _GENERIC_RBTREE_H
+#define _GENERIC_RBTREE_H
-
+
-#include <stddef.h>
+#include <stddef.h>
-
+
-struct rb_node {
+struct rb_node {
-	unsigned long __rb_parent_color;
+	unsigned long __rb_parent_color;
-	struct rb_node *rb_right;
+	struct rb_node *rb_right;
-	struct rb_node *rb_left;
+	struct rb_node *rb_left;
-} __attribute__((aligned(sizeof(long))));
+} __attribute__((aligned(sizeof(long))));
-/* The alignment might seem pointless, but allegedly CRIS needs it */
+/* The alignment might seem pointless, but allegedly CRIS needs it */
-
+
-struct rb_root {
+struct rb_root {
-	struct rb_node *rb_node;
+	struct rb_node *rb_node;
-};
+};
-
+
-#define rb_parent(r) ((struct rb_node *)((r)->__rb_parent_color & ~3))
+#define rb_parent(r) ((struct rb_node *)((r)->__rb_parent_color & ~3))
-
+
-#define RB_ROOT                                                                                                                                                \
+#define RB_ROOT                                                                                                                                                \
-	(struct rb_root)                                                                                                                                           \
+	(struct rb_root)                                                                                                                                           \
-	{                                                                                                                                                          \
+	{                                                                                                                                                          \
-		NULL,                                                                                                                                                  \
+		NULL,                                                                                                                                                  \
-	}
+	}
-#define rb_entry(ptr, type, member) container_of(ptr, type, member)
+#define rb_entry(ptr, type, member) container_of(ptr, type, member)
-
+
-#define RB_EMPTY_ROOT(root) ((root)->rb_node == NULL)
+#define RB_EMPTY_ROOT(root) ((root)->rb_node == NULL)
-
+
-/* 'empty' nodes are nodes that are known not to be inserted in an rbtree */
+/* 'empty' nodes are nodes that are known not to be inserted in an rbtree */
-#define RB_EMPTY_NODE(node) ((node)->__rb_parent_color == (unsigned long)(node))
+#define RB_EMPTY_NODE(node) ((node)->__rb_parent_color == (unsigned long)(node))
-#define RB_CLEAR_NODE(node) ((node)->__rb_parent_color = (unsigned long)(node))
+#define RB_CLEAR_NODE(node) ((node)->__rb_parent_color = (unsigned long)(node))
-
+
-extern void rb_insert_color(struct rb_node *, struct rb_root *);
+extern void rb_insert_color(struct rb_node *, struct rb_root *);
-extern void rb_erase(struct rb_node *, struct rb_root *);
+extern void rb_erase(struct rb_node *, struct rb_root *);
-
+
-/* Find logical next and previous nodes in a tree */
+/* Find logical next and previous nodes in a tree */
-extern struct rb_node *rb_next(const struct rb_node *);
+extern struct rb_node *rb_next(const struct rb_node *);
-extern struct rb_node *rb_prev(const struct rb_node *);
+extern struct rb_node *rb_prev(const struct rb_node *);
-extern struct rb_node *rb_first(const struct rb_root *);
+extern struct rb_node *rb_first(const struct rb_root *);
-extern struct rb_node *rb_last(const struct rb_root *);
+extern struct rb_node *rb_last(const struct rb_root *);
-
+
-/* Postorder iteration - always visit the parent after its children */
+/* Postorder iteration - always visit the parent after its children */
-extern struct rb_node *rb_first_postorder(const struct rb_root *);
+extern struct rb_node *rb_first_postorder(const struct rb_root *);
-extern struct rb_node *rb_next_postorder(const struct rb_node *);
+extern struct rb_node *rb_next_postorder(const struct rb_node *);
-
+
-/* Fast replacement of a single node without remove/rebalance/add/rebalance */
+/* Fast replacement of a single node without remove/rebalance/add/rebalance */
-extern void rb_replace_node(struct rb_node *victim, struct rb_node *new_node, struct rb_root *root);
+extern void rb_replace_node(struct rb_node *victim, struct rb_node *new_node, struct rb_root *root);
-
+
-static inline void rb_link_node(struct rb_node *node, struct rb_node *parent, struct rb_node **rb_link)
+static inline void rb_link_node(struct rb_node *node, struct rb_node *parent, struct rb_node **rb_link)
-{
+{
-	node->__rb_parent_color = (unsigned long)parent;
+	node->__rb_parent_color = (unsigned long)parent;
-	node->rb_left = node->rb_right = NULL;
+	node->rb_left = node->rb_right = NULL;
-
+
-	*rb_link = node;
+	*rb_link = node;
-}
+}
-
+
-#define rb_entry_safe(ptr, type, member)                                                                                                                       \
+#define rb_entry_safe(ptr, type, member)                                                                                                                       \
-	({                                                                                                                                                         \
+	({                                                                                                                                                         \
-		typeof(ptr) ____ptr = (ptr);                                                                                                                           \
+		typeof(ptr) ____ptr = (ptr);                                                                                                                           \
-		____ptr ? rb_entry(____ptr, type, member) : NULL;                                                                                                      \
+		____ptr ? rb_entry(____ptr, type, member) : NULL;                                                                                                      \
-	})
+	})
-
+
-/*
+/*
- * Handy for checking that we are not deleting an entry that is
+ * Handy for checking that we are not deleting an entry that is
- * already in a list, found in block/{blk-throttle,cfq-iosched}.c,
+ * already in a list, found in block/{blk-throttle,cfq-iosched}.c,
- * probably should be moved to lib/rbtree.c...
+ * probably should be moved to lib/rbtree.c...
- */
+ */
-static inline void rb_erase_init(struct rb_node *n, struct rb_root *root)
+static inline void rb_erase_init(struct rb_node *n, struct rb_root *root)
-{
+{
-	rb_erase(n, root);
+	rb_erase(n, root);
-	RB_CLEAR_NODE(n);
+	RB_CLEAR_NODE(n);
-}
+}
-
+
-
+
-/*
+/*
- * Please note - only struct rb_augment_callbacks and the prototypes for
+ * Please note - only struct rb_augment_callbacks and the prototypes for
- * rb_insert_augmented() and rb_erase_augmented() are intended to be public.
+ * rb_insert_augmented() and rb_erase_augmented() are intended to be public.
- * The rest are implementation details you are not expected to depend on.
+ * The rest are implementation details you are not expected to depend on.
- *
+ *
- * See Documentation/rbtree.txt for documentation and samples.
+ * See Documentation/rbtree.txt for documentation and samples.
- */
+ */
-
+
-struct rb_augment_callbacks {
+struct rb_augment_callbacks {
-	void (*propagate)(struct rb_node *node, struct rb_node *stop);
+	void (*propagate)(struct rb_node *node, struct rb_node *stop);
-	void (*copy)(struct rb_node *old_node, struct rb_node *new_node);
+	void (*copy)(struct rb_node *old_node, struct rb_node *new_node);
-	void (*rotate)(struct rb_node *old_node, struct rb_node *new_node);
+	void (*rotate)(struct rb_node *old_node, struct rb_node *new_node);
-};
+};
-
+
-extern void __rb_insert_augmented(struct rb_node *node, struct rb_root *root,
+extern void __rb_insert_augmented(struct rb_node *node, struct rb_root *root,
-	void (*augment_rotate)(struct rb_node *old_node, struct rb_node *new_node));
+	void (*augment_rotate)(struct rb_node *old_node, struct rb_node *new_node));
-/*
+/*
- * Fixup the rbtree and update the augmented information when rebalancing.
+ * Fixup the rbtree and update the augmented information when rebalancing.
- *
+ *
- * On insertion, the user must update the augmented information on the path
+ * On insertion, the user must update the augmented information on the path
- * leading to the inserted node, then call rb_link_node() as usual and
+ * leading to the inserted node, then call rb_link_node() as usual and
- * rb_augment_inserted() instead of the usual rb_insert_color() call.
+ * rb_augment_inserted() instead of the usual rb_insert_color() call.
- * If rb_augment_inserted() rebalances the rbtree, it will callback into
+ * If rb_augment_inserted() rebalances the rbtree, it will callback into
- * a user provided function to update the augmented information on the
+ * a user provided function to update the augmented information on the
- * affected subtrees.
+ * affected subtrees.
- */
+ */
-static inline void
+static inline void
-rb_insert_augmented(struct rb_node *node, struct rb_root *root,
+rb_insert_augmented(struct rb_node *node, struct rb_root *root,
-		    const struct rb_augment_callbacks *augment)
+		    const struct rb_augment_callbacks *augment)
-{
+{
-	__rb_insert_augmented(node, root, augment->rotate);
+	__rb_insert_augmented(node, root, augment->rotate);
-}
+}
-
+
-#define RB_DECLARE_CALLBACKS(rbstatic, rbname, rbstruct, rbfield,	\
+#define RB_DECLARE_CALLBACKS(rbstatic, rbname, rbstruct, rbfield,	\
-			     rbtype, rbaugmented, rbcompute)		\
+			     rbtype, rbaugmented, rbcompute)		\
-static inline void							\
+static inline void							\
-rbname ## _propagate(struct rb_node *rb, struct rb_node *stop)		\
+rbname ## _propagate(struct rb_node *rb, struct rb_node *stop)		\
-{									\
+{									\
-	while (rb != stop) {						\
+	while (rb != stop) {						\
-		rbstruct *node = rb_entry(rb, rbstruct, rbfield);	\
+		rbstruct *node = rb_entry(rb, rbstruct, rbfield);	\
-		rbtype augmented = rbcompute(node);			\
+		rbtype augmented = rbcompute(node);			\
-		if (node->rbaugmented == augmented)			\
+		if (node->rbaugmented == augmented)			\
-			break;						\
+			break;						\
-		node->rbaugmented = augmented;				\
+		node->rbaugmented = augmented;				\
-		rb = rb_parent(&node->rbfield);				\
+		rb = rb_parent(&node->rbfield);				\
-	}								\
+	}								\
-}									\
+}									\
-static inline void							\
+static inline void							\
-rbname ## _copy(struct rb_node *rb_old, struct rb_node *rb_new)		\
+rbname ## _copy(struct rb_node *rb_old, struct rb_node *rb_new)		\
-{									\
+{									\
-	rbstruct *old_node = rb_entry(rb_old, rbstruct, rbfield);		\
+	rbstruct *old_node = rb_entry(rb_old, rbstruct, rbfield);		\
-	rbstruct *new_node = rb_entry(rb_new, rbstruct, rbfield);		\
+	rbstruct *new_node = rb_entry(rb_new, rbstruct, rbfield);		\
-	new_node->rbaugmented = old_node->rbaugmented;				\
+	new_node->rbaugmented = old_node->rbaugmented;				\
-}									\
+}									\
-static void								\
+static void								\
-rbname ## _rotate(struct rb_node *rb_old, struct rb_node *rb_new)	\
+rbname ## _rotate(struct rb_node *rb_old, struct rb_node *rb_new)	\
-{									\
+{									\
-	rbstruct *old_node = rb_entry(rb_old, rbstruct, rbfield);		\
+	rbstruct *old_node = rb_entry(rb_old, rbstruct, rbfield);		\
-	rbstruct *new_node = rb_entry(rb_new, rbstruct, rbfield);		\
+	rbstruct *new_node = rb_entry(rb_new, rbstruct, rbfield);		\
-	new_node->rbaugmented = old_node->rbaugmented;				\
+	new_node->rbaugmented = old_node->rbaugmented;				\
-	old_node->rbaugmented = rbcompute(old_node);				\
+	old_node->rbaugmented = rbcompute(old_node);				\
-}									\
+}									\
-rbstatic const struct rb_augment_callbacks rbname = {			\
+rbstatic const struct rb_augment_callbacks rbname = {			\
-	rbname ## _propagate, rbname ## _copy, rbname ## _rotate	\
+	rbname ## _propagate, rbname ## _copy, rbname ## _rotate	\
-};
+};
-
+
-
+
-#define	RB_RED		0
+#define	RB_RED		0
-#define	RB_BLACK	1
+#define	RB_BLACK	1
-
+
-#define __rb_parent(pc)    ((struct rb_node *)(pc & ~3))
+#define __rb_parent(pc)    ((struct rb_node *)(pc & ~3))
-
+
-#define __rb_color(pc)     ((pc) & 1)
+#define __rb_color(pc)     ((pc) & 1)
-#define __rb_is_black(pc)  __rb_color(pc)
+#define __rb_is_black(pc)  __rb_color(pc)
-#define __rb_is_red(pc)    (!__rb_color(pc))
+#define __rb_is_red(pc)    (!__rb_color(pc))
-#define rb_color(rb)       __rb_color((rb)->__rb_parent_color)
+#define rb_color(rb)       __rb_color((rb)->__rb_parent_color)
-#define rb_is_red(rb)      __rb_is_red((rb)->__rb_parent_color)
+#define rb_is_red(rb)      __rb_is_red((rb)->__rb_parent_color)
-#define rb_is_black(rb)    __rb_is_black((rb)->__rb_parent_color)
+#define rb_is_black(rb)    __rb_is_black((rb)->__rb_parent_color)
-
+
-static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
+static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
-{
+{
-	rb->__rb_parent_color = rb_color(rb) | (unsigned long)p;
+	rb->__rb_parent_color = rb_color(rb) | (unsigned long)p;
-}
+}
-
+
-static inline void rb_set_parent_color(struct rb_node *rb,
+static inline void rb_set_parent_color(struct rb_node *rb,
-				       struct rb_node *p, int color)
+				       struct rb_node *p, int color)
-{
+{
-	rb->__rb_parent_color = (unsigned long)p | color;
+	rb->__rb_parent_color = (unsigned long)p | color;
-}
+}
-
+
-static inline void
+static inline void
-__rb_change_child(struct rb_node *old_node, struct rb_node *new_node,
+__rb_change_child(struct rb_node *old_node, struct rb_node *new_node,
-		  struct rb_node *parent, struct rb_root *root)
+		  struct rb_node *parent, struct rb_root *root)
-{
+{
-	if (parent) {
+	if (parent) {
-		if (parent->rb_left == old_node)
+		if (parent->rb_left == old_node)
-			parent->rb_left = new_node;
+			parent->rb_left = new_node;
-		else
+		else
-			parent->rb_right = new_node;
+			parent->rb_right = new_node;
-	} else
+	} else
-		root->rb_node = new_node;
+		root->rb_node = new_node;
-}
+}
-
+
-extern void __rb_erase_color(struct rb_node *parent, struct rb_root *root,
+extern void __rb_erase_color(struct rb_node *parent, struct rb_root *root,
-	void (*augment_rotate)(struct rb_node *old_node, struct rb_node *new_node));
+	void (*augment_rotate)(struct rb_node *old_node, struct rb_node *new_node));
-
+
-static inline struct rb_node *
+static inline struct rb_node *
-__rb_erase_augmented(struct rb_node *node, struct rb_root *root,
+__rb_erase_augmented(struct rb_node *node, struct rb_root *root,
-		     const struct rb_augment_callbacks *augment)
+		     const struct rb_augment_callbacks *augment)
-{
+{
-	struct rb_node *child = node->rb_right, *tmp = node->rb_left;
+	struct rb_node *child = node->rb_right, *tmp = node->rb_left;
-	struct rb_node *parent, *rebalance;
+	struct rb_node *parent, *rebalance;
-	unsigned long pc;
+	unsigned long pc;
-
+
-	if (!tmp) {
+	if (!tmp) {
-		/*
+		/*
-		 * Case 1: node to erase has no more than 1 child (easy!)
+		 * Case 1: node to erase has no more than 1 child (easy!)
-		 *
+		 *
-		 * Note that if there is one child it must be red due to 5)
+		 * Note that if there is one child it must be red due to 5)
-		 * and node must be black due to 4). We adjust colors locally
+		 * and node must be black due to 4). We adjust colors locally
-		 * so as to bypass __rb_erase_color() later on.
+		 * so as to bypass __rb_erase_color() later on.
-		 */
+		 */
-		pc = node->__rb_parent_color;
+		pc = node->__rb_parent_color;
-		parent = __rb_parent(pc);
+		parent = __rb_parent(pc);
-		__rb_change_child(node, child, parent, root);
+		__rb_change_child(node, child, parent, root);
-		if (child) {
+		if (child) {
-			child->__rb_parent_color = pc;
+			child->__rb_parent_color = pc;
-			rebalance = NULL;
+			rebalance = NULL;
-		} else
+		} else
-			rebalance = __rb_is_black(pc) ? parent : NULL;
+			rebalance = __rb_is_black(pc) ? parent : NULL;
-		tmp = parent;
+		tmp = parent;
-	} else if (!child) {
+	} else if (!child) {
-		/* Still case 1, but this time the child is node->rb_left */
+		/* Still case 1, but this time the child is node->rb_left */
-		tmp->__rb_parent_color = pc = node->__rb_parent_color;
+		tmp->__rb_parent_color = pc = node->__rb_parent_color;
-		parent = __rb_parent(pc);
+		parent = __rb_parent(pc);
-		__rb_change_child(node, tmp, parent, root);
+		__rb_change_child(node, tmp, parent, root);
-		rebalance = NULL;
+		rebalance = NULL;
-		tmp = parent;
+		tmp = parent;
-	} else {
+	} else {
-		struct rb_node *successor = child, *child2;
+		struct rb_node *successor = child, *child2;
-		tmp = child->rb_left;
+		tmp = child->rb_left;
-		if (!tmp) {
+		if (!tmp) {
-			/*
+			/*
-			 * Case 2: node's successor is its right child
+			 * Case 2: node's successor is its right child
-			 *
+			 *
-			 *    (n)          (s)
+			 *    (n)          (s)
-			 *    / \          / \
+			 *    / \          / \
-			 *  (x) (s)  ->  (x) (c)
+			 *  (x) (s)  ->  (x) (c)
-			 *        \
+			 *        \
-			 *        (c)
+			 *        (c)
-			 */
+			 */
-			parent = successor;
+			parent = successor;
-			child2 = successor->rb_right;
+			child2 = successor->rb_right;
-			augment->copy(node, successor);
+			augment->copy(node, successor);
-		} else {
+		} else {
-			/*
+			/*
-			 * Case 3: node's successor is leftmost under
+			 * Case 3: node's successor is leftmost under
-			 * node's right child subtree
+			 * node's right child subtree
-			 *
+			 *
-			 *    (n)          (s)
+			 *    (n)          (s)
-			 *    / \          / \
+			 *    / \          / \
-			 *  (x) (y)  ->  (x) (y)
+			 *  (x) (y)  ->  (x) (y)
-			 *      /            /
+			 *      /            /
-			 *    (p)          (p)
+			 *    (p)          (p)
-			 *    /            /
+			 *    /            /
-			 *  (s)          (c)
+			 *  (s)          (c)
-			 *    \
+			 *    \
-			 *    (c)
+			 *    (c)
-			 */
+			 */
-			do {
+			do {
-				parent = successor;
+				parent = successor;
-				successor = tmp;
+				successor = tmp;
-				tmp = tmp->rb_left;
+				tmp = tmp->rb_left;
-			} while (tmp);
+			} while (tmp);
-			parent->rb_left = child2 = successor->rb_right;
+			parent->rb_left = child2 = successor->rb_right;
-			successor->rb_right = child;
+			successor->rb_right = child;
-			rb_set_parent(child, successor);
+			rb_set_parent(child, successor);
-			augment->copy(node, successor);
+			augment->copy(node, successor);
-			augment->propagate(parent, successor);
+			augment->propagate(parent, successor);
-		}
+		}
-
+
-		successor->rb_left = tmp = node->rb_left;
+		successor->rb_left = tmp = node->rb_left;
-		rb_set_parent(tmp, successor);
+		rb_set_parent(tmp, successor);
-
+
-		pc = node->__rb_parent_color;
+		pc = node->__rb_parent_color;
-		tmp = __rb_parent(pc);
+		tmp = __rb_parent(pc);
-		__rb_change_child(node, successor, tmp, root);
+		__rb_change_child(node, successor, tmp, root);
-		if (child2) {
+		if (child2) {
-			successor->__rb_parent_color = pc;
+			successor->__rb_parent_color = pc;
-			rb_set_parent_color(child2, parent, RB_BLACK);
+			rb_set_parent_color(child2, parent, RB_BLACK);
-			rebalance = NULL;
+			rebalance = NULL;
-		} else {
+		} else {
-			unsigned long pc2 = successor->__rb_parent_color;
+			unsigned long pc2 = successor->__rb_parent_color;
-			successor->__rb_parent_color = pc;
+			successor->__rb_parent_color = pc;
-			rebalance = __rb_is_black(pc2) ? parent : NULL;
+			rebalance = __rb_is_black(pc2) ? parent : NULL;
-		}
+		}
-		tmp = successor;
+		tmp = successor;
-	}
+	}
-
+
-	augment->propagate(tmp, NULL);
+	augment->propagate(tmp, NULL);
-	return rebalance;
+	return rebalance;
-}
+}
-
+
-static inline void
+static inline void
-rb_erase_augmented(struct rb_node *node, struct rb_root *root,
+rb_erase_augmented(struct rb_node *node, struct rb_root *root,
-		   const struct rb_augment_callbacks *augment)
+		   const struct rb_augment_callbacks *augment)
-{
+{
-	struct rb_node *rebalance = __rb_erase_augmented(node, root, augment);
+	struct rb_node *rebalance = __rb_erase_augmented(node, root, augment);
-	if (rebalance)
+	if (rebalance)
-		__rb_erase_color(rebalance, root, augment->rotate);
+		__rb_erase_color(rebalance, root, augment->rotate);
-}
+}
-
+
-#endif /* _GENERIC_RBTREE_H */
+#endif /* _GENERIC_RBTREE_H */
-
+

src/include/stringutil.h

@@ -1,42 +1,42 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#ifndef _GENERIC_STRING_UITL_H
+#ifndef _GENERIC_STRING_UITL_H
-#define _GENERIC_STRING_UITL_H
+#define _GENERIC_STRING_UITL_H
-
+
-#include <stddef.h>
+#include <stddef.h>
-#include <string.h>
+#include <string.h>
-
+
-static inline char *safe_strncpy(char *dest, const char *src, size_t n) 
+static inline char *safe_strncpy(char *dest, const char *src, size_t n) 
-{
+{
-#if __GNUC__  > 7
+#if __GNUC__  > 7
-#pragma GCC diagnostic push
+#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-truncation"
+#pragma GCC diagnostic ignored "-Wstringop-truncation"
-#endif
+#endif
-	char *ret = strncpy(dest, src, n - 1);
+	char *ret = strncpy(dest, src, n - 1);
-    if (n > 0) {
+    if (n > 0) {
-	    dest[n - 1] = '\0';
+	    dest[n - 1] = '\0';
-    }
+    }
-#if __GNUC__  > 7
+#if __GNUC__  > 7
-#pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
-#endif
+#endif
-	return ret;
+	return ret;
-}
+}
-
+
-
+
-#endif
+#endif

src/lib/conf.c

@@ -1,311 +1,311 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#include "conf.h"
+#include "conf.h"
-#include <getopt.h>
+#include <getopt.h>
-#include <stdio.h>
+#include <stdio.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <string.h>
+#include <string.h>
-#include <unistd.h>
+#include <unistd.h>
-
+
-static const char *currrent_conf_file = NULL;
+static const char *currrent_conf_file = NULL;
-
+
-const char *conf_get_conf_file(void)
+const char *conf_get_conf_file(void)
-{
+{
-	return currrent_conf_file;
+	return currrent_conf_file;
-}
+}
-
+
-int conf_custom(const char *item, void *data, int argc, char *argv[])
+int conf_custom(const char *item, void *data, int argc, char *argv[])
-{
+{
-	struct config_item_custom *item_custom = data;
+	struct config_item_custom *item_custom = data;
-	return item_custom->custom_func(item_custom->custom_data, argc, argv);
+	return item_custom->custom_func(item_custom->custom_data, argc, argv);
-}
+}
-
+
-int conf_int(const char *item, void *data, int argc, char *argv[])
+int conf_int(const char *item, void *data, int argc, char *argv[])
-{
+{
-	struct config_item_int *item_int = data;
+	struct config_item_int *item_int = data;
-	int value = 0;
+	int value = 0;
-	if (argc < 2) {
+	if (argc < 2) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	value = atoi(argv[1]);
+	value = atoi(argv[1]);
-
+
-	if (value < item_int->min) {
+	if (value < item_int->min) {
-		value = item_int->min;
+		value = item_int->min;
-	} else if (value > item_int->max) {
+	} else if (value > item_int->max) {
-		value = item_int->max;
+		value = item_int->max;
-	}
+	}
-
+
-	*(item_int->data) = value;
+	*(item_int->data) = value;
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-int conf_string(const char *item, void *data, int argc, char *argv[])
+int conf_string(const char *item, void *data, int argc, char *argv[])
-{
+{
-	struct config_item_string *item_string = data;
+	struct config_item_string *item_string = data;
-
+
-	if (argc < 2) {
+	if (argc < 2) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	strncpy(item_string->data, argv[1], item_string->size);
+	strncpy(item_string->data, argv[1], item_string->size);
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-int conf_yesno(const char *item, void *data, int argc, char *argv[])
+int conf_yesno(const char *item, void *data, int argc, char *argv[])
-{
+{
-	struct config_item_yesno *item_yesno = data;
+	struct config_item_yesno *item_yesno = data;
-	int yes = 0;
+	int yes = 0;
-
+
-	if (argc < 2) {
+	if (argc < 2) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	char *value = argv[1];
+	char *value = argv[1];
-	if (strncmp("auto", value, sizeof("auto")) == 0 || strncmp("AUTO", value, sizeof("AUTO")) == 0) {
+	if (strncmp("auto", value, sizeof("auto")) == 0 || strncmp("AUTO", value, sizeof("AUTO")) == 0) {
-		return 0;
+		return 0;
-	}
+	}
-
+
-	if (strncmp("yes", value, sizeof("yes")) == 0 || strncmp("YES", value, sizeof("YES")) == 0) {
+	if (strncmp("yes", value, sizeof("yes")) == 0 || strncmp("YES", value, sizeof("YES")) == 0) {
-		yes = 1;
+		yes = 1;
-	} else if (strncmp("no", value, sizeof("no")) == 0 || strncmp("NO", value, sizeof("NO")) == 0) {
+	} else if (strncmp("no", value, sizeof("no")) == 0 || strncmp("NO", value, sizeof("NO")) == 0) {
-		yes = 0;
+		yes = 0;
-	}
+	}
-
+
-	*(item_yesno->data) = yes;
+	*(item_yesno->data) = yes;
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-int conf_size(const char *item, void *data, int argc, char *argv[])
+int conf_size(const char *item, void *data, int argc, char *argv[])
-{
+{
-	/* read dns cache size */
+	/* read dns cache size */
-	int base = 1;
+	int base = 1;
-	size_t size = 0;
+	size_t size = 0;
-	int num = 0;
+	int num = 0;
-	struct config_item_size *item_size = data;
+	struct config_item_size *item_size = data;
-	char *value = argv[1];
+	char *value = argv[1];
-
+
-	if (strstr(value, "k") || strstr(value, "K")) {
+	if (strstr(value, "k") || strstr(value, "K")) {
-		base = 1024;
+		base = 1024;
-	} else if (strstr(value, "m") || strstr(value, "M")) {
+	} else if (strstr(value, "m") || strstr(value, "M")) {
-		base = 1024 * 1024;
+		base = 1024 * 1024;
-	} else if (strstr(value, "g") || strstr(value, "G")) {
+	} else if (strstr(value, "g") || strstr(value, "G")) {
-		base = 1024 * 1024 * 1024;
+		base = 1024 * 1024 * 1024;
-	}
+	}
-
+
-	num = atoi(value);
+	num = atoi(value);
-	if (num < 0) {
+	if (num < 0) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	size = num * base;
+	size = num * base;
-	if (size > item_size->max) {
+	if (size > item_size->max) {
-		size = item_size->max;
+		size = item_size->max;
-	} else if (size < item_size->min) {
+	} else if (size < item_size->min) {
-		size = item_size->min;
+		size = item_size->min;
-	}
+	}
-
+
-	*(item_size->data) = size;
+	*(item_size->data) = size;
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-void conf_getopt_reset(void)
+void conf_getopt_reset(void)
-{
+{
-	static struct option long_options[] = {{"-", 0, 0, 0}, {0, 0, 0, 0}};
+	static struct option long_options[] = {{"-", 0, 0, 0}, {0, 0, 0, 0}};
-	int argc = 2;
+	int argc = 2;
-	char *argv[3] = {"reset", "", 0};
+	char *argv[3] = {"reset", "", 0};
-
+
-	optind = 0;
+	optind = 0;
-	opterr = 0;
+	opterr = 0;
-	optopt = 0;
+	optopt = 0;
-	getopt_long(argc, argv, "", long_options, NULL);
+	getopt_long(argc, argv, "", long_options, NULL);
-	optind = 0;
+	optind = 0;
-	opterr = 0;
+	opterr = 0;
-	optopt = 0;
+	optopt = 0;
-}
+}
-
+
-int conf_parse_args(char *key, char *value, int *argc, char **argv)
+int conf_parse_args(char *key, char *value, int *argc, char **argv)
-{
+{
-	char *start = NULL;
+	char *start = NULL;
-	char *ptr = value;
+	char *ptr = value;
-	int count = 0;
+	int count = 0;
-	int sep_flag = ' ';
+	int sep_flag = ' ';
-
+
-	argv[0] = key;
+	argv[0] = key;
-	count++;
+	count++;
-
+
-	while (*ptr != '\0') {
+	while (*ptr != '\0') {
-		if (*ptr == '\\') {
+		if (*ptr == '\\') {
-			char *tmp = ptr + 1;
+			char *tmp = ptr + 1;
-			while (*tmp != '\0') {
+			while (*tmp != '\0') {
-				*(tmp - 1) = *tmp;
+				*(tmp - 1) = *tmp;
-				tmp++;
+				tmp++;
-			}
+			}
-			ptr++;
+			ptr++;
-			continue;
+			continue;
-		}
+		}
-
+
-		if (*ptr == '"' && start == NULL) {
+		if (*ptr == '"' && start == NULL) {
-			sep_flag = '"';
+			sep_flag = '"';
-			start = NULL;
+			start = NULL;
-		}
+		}
-
+
-		if (*ptr != sep_flag && start == NULL) {
+		if (*ptr != sep_flag && start == NULL) {
-			start = ptr;
+			start = ptr;
-			ptr++;
+			ptr++;
-			continue;
+			continue;
-		}
+		}
-
+
-		if (*ptr == sep_flag && start == NULL) {
+		if (*ptr == sep_flag && start == NULL) {
-			ptr++;
+			ptr++;
-			continue;
+			continue;
-		}
+		}
-
+
-		if (*ptr == sep_flag && start) {
+		if (*ptr == sep_flag && start) {
-			argv[count] = start;
+			argv[count] = start;
-			*ptr = '\0';
+			*ptr = '\0';
-			ptr++;
+			ptr++;
-			count++;
+			count++;
-			sep_flag = ' ';
+			sep_flag = ' ';
-			start = NULL;
+			start = NULL;
-			continue;
+			continue;
-		}
+		}
-
+
-		ptr++;
+		ptr++;
-	}
+	}
-
+
-	if (start != ptr && start) {
+	if (start != ptr && start) {
-		argv[count] = start;
+		argv[count] = start;
-		count++;
+		count++;
-	}
+	}
-
+
-	*argc = count;
+	*argc = count;
-	argv[count] = 0;
+	argv[count] = 0;
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-void load_exit(void)
+void load_exit(void)
-{
+{
-	return;
+	return;
-}
+}
-
+
-int load_conf_printf(const char *file, int lineno, int ret)
+int load_conf_printf(const char *file, int lineno, int ret)
-{
+{
-	if (ret != CONF_RET_OK) {
+	if (ret != CONF_RET_OK) {
-		printf("process config file '%s' failed at line %d.", file, lineno);
+		printf("process config file '%s' failed at line %d.", file, lineno);
-		if (ret == CONF_RET_ERR || ret == CONF_RET_NOENT) {
+		if (ret == CONF_RET_ERR || ret == CONF_RET_NOENT) {
-			return -1;
+			return -1;
-		}
+		}
-
+
-		return 0;
+		return 0;
-	}
+	}
-
+
-	return 0;
+	return 0;
-}
+}
-
+
-int load_conf_file(const char *file, struct config_item *items, conf_error_handler handler)
+int load_conf_file(const char *file, struct config_item *items, conf_error_handler handler)
-{
+{
-	FILE *fp = NULL;
+	FILE *fp = NULL;
-	char line[MAX_LINE_LEN];
+	char line[MAX_LINE_LEN];
-	char key[MAX_KEY_LEN];
+	char key[MAX_KEY_LEN];
-	char value[MAX_LINE_LEN];
+	char value[MAX_LINE_LEN];
-	int filed_num = 0;
+	int filed_num = 0;
-	int i;
+	int i;
-	int argc;
+	int argc;
-	char *argv[1024];
+	char *argv[1024];
-	int ret = 0;
+	int ret = 0;
-	int call_ret = 0;
+	int call_ret = 0;
-	int line_no = 0;
+	int line_no = 0;
-
+
-	if (handler == NULL) {
+	if (handler == NULL) {
-		handler = load_conf_printf;
+		handler = load_conf_printf;
-	}
+	}
-
+
-	fp = fopen(file, "r");
+	fp = fopen(file, "r");
-	if (fp == NULL) {
+	if (fp == NULL) {
-		return -1;
+		return -1;
-	}
+	}
-
+
-	line_no = 0;
+	line_no = 0;
-	while (fgets(line, MAX_LINE_LEN, fp)) {
+	while (fgets(line, MAX_LINE_LEN, fp)) {
-		line_no++;
+		line_no++;
-		filed_num = sscanf(line, "%63s %1023[^\r\n]s", key, value);
+		filed_num = sscanf(line, "%63s %1023[^\r\n]s", key, value);
-		if (filed_num <= 0) {
+		if (filed_num <= 0) {
-			continue;
+			continue;
-		}
+		}
-
+
-		/* comment, skip */
+		/* comment, skip */
-		if (key[0] == '#') {
+		if (key[0] == '#') {
-			continue;
+			continue;
-		}
+		}
-
+
-		/* if field format is not key = value, error */
+		/* if field format is not key = value, error */
-		if (filed_num != 2) {
+		if (filed_num != 2) {
-			goto errout;
+			goto errout;
-		}
+		}
-
+
-		for (i = 0;; i++) {
+		for (i = 0;; i++) {
-			if (items[i].item == NULL) {
+			if (items[i].item == NULL) {
-				handler(file, line_no, CONF_RET_NOENT);
+				handler(file, line_no, CONF_RET_NOENT);
-				break;
+				break;
-			}
+			}
-
+
-			if (strncmp(items[i].item, key, MAX_KEY_LEN) != 0) {
+			if (strncmp(items[i].item, key, MAX_KEY_LEN) != 0) {
-				continue;
+				continue;
-			}
+			}
-
+
-			if (conf_parse_args(key, value, &argc, argv) != 0) {
+			if (conf_parse_args(key, value, &argc, argv) != 0) {
-				continue;
+				continue;
-			}
+			}
-
+
-			conf_getopt_reset();
+			conf_getopt_reset();
-			/* call item function */
+			/* call item function */
-			currrent_conf_file = file;
+			currrent_conf_file = file;
-			call_ret = items[i].item_func(items[i].item, items[i].data, argc, argv);
+			call_ret = items[i].item_func(items[i].item, items[i].data, argc, argv);
-			ret = handler(file, line_no, call_ret);
+			ret = handler(file, line_no, call_ret);
-			if (ret != 0) {
+			if (ret != 0) {
-				conf_getopt_reset();
+				conf_getopt_reset();
-				goto errout;
+				goto errout;
-			}
+			}
-
+
-			conf_getopt_reset();
+			conf_getopt_reset();
-
+
-			break;
+			break;
-		}
+		}
-	}
+	}
-
+
-	fclose(fp);
+	fclose(fp);
-
+
-	return 0;
+	return 0;
-errout:
+errout:
-	if (fp) {
+	if (fp) {
-		fclose(fp);
+		fclose(fp);
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-
+
-int load_conf(const char *file, struct config_item items[], conf_error_handler handler)
+int load_conf(const char *file, struct config_item items[], conf_error_handler handler)
-{
+{
-	return load_conf_file(file, items, handler);
+	return load_conf_file(file, items, handler);
-}
+}

src/lib/stringutil.c

@@ -1,17 +1,17 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
  */

src/smartdns.c

@@ -1,443 +1,456 @@
-/*************************************************************************
+/*************************************************************************
- *
+ *
- * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
+ * Copyright (C) 2018-2020 Ruilin Peng (Nick) <pymumu@gmail.com>.
- *
+ *
- * smartdns is free software: you can redistribute it and/or modify
+ * smartdns is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+ * it under the terms of the GNU General Public License as published 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.
+ * (at your option) any later version.
- *
+ *
- * smartdns is distributed in the hope that it will be useful,
+ * smartdns is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU General Public License for more details.
- *
+ *
- * You should have received a copy of the GNU 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 <http://www.gnu.org/licenses/>.
- */
+ */
-
+
-#define _GNU_SOURCE
+#define _GNU_SOURCE
-#include "art.h"
+#include "art.h"
-#include "atomic.h"
+#include "atomic.h"
-#include "dns_client.h"
+#include "dns_client.h"
-#include "dns_conf.h"
+#include "dns_conf.h"
-#include "dns_server.h"
+#include "dns_server.h"
-#include "fast_ping.h"
+#include "fast_ping.h"
-#include "hashtable.h"
+#include "hashtable.h"
-#include "list.h"
+#include "list.h"
-#include "rbtree.h"
+#include "rbtree.h"
-#include "tlog.h"
+#include "tlog.h"
-#include "util.h"
+#include "util.h"
-#include <errno.h>
+#include <errno.h>
-#include <fcntl.h>
+#include <fcntl.h>
-#include <libgen.h>
+#include <libgen.h>
-#include <openssl/err.h>
+#include <openssl/err.h>
-#include <openssl/ssl.h>
+#include <openssl/ssl.h>
-#include <signal.h>
+#include <signal.h>
-#include <stdio.h>
+#include <stdio.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <string.h>
+#include <string.h>
-#include <sys/stat.h>
+#include <sys/stat.h>
-#include <sys/types.h>
+#include <sys/types.h>
-#include <ucontext.h>
+#include <ucontext.h>
-
+
-#define RESOLVE_FILE "/etc/resolv.conf"
+#define RESOLVE_FILE "/etc/resolv.conf"
-#define MAX_LINE_LEN 1024
+#define MAX_LINE_LEN 1024
-#define MAX_KEY_LEN 64
+#define MAX_KEY_LEN 64
-#define SMARTDNS_PID_FILE "/var/run/smartdns.pid"
+#define SMARTDNS_PID_FILE "/var/run/smartdns.pid"
-#define TMP_BUFF_LEN_32 32
+#define TMP_BUFF_LEN_32 32
-
+
-static int verbose_screen;
+static int verbose_screen;
-
+
-static void _help(void)
+static void _help(void)
-{
+{
-	/* clang-format off */
+	/* clang-format off */
-	char *help = ""
+	char *help = ""
-		"Usage: smartdns [OPTION]...\n"
+		"Usage: smartdns [OPTION]...\n"
-		"Start smartdns server.\n"
+		"Start smartdns server.\n"
-		"  -f            run forground.\n"
+		"  -f            run forground.\n"
-		"  -c [conf]     config file.\n"
+		"  -c [conf]     config file.\n"
-		"  -p [pid]      pid file path\n"
+		"  -p [pid]      pid file path\n"
-		"  -S            ignore segment fault signal.\n"
+		"  -S            ignore segment fault signal.\n"
-		"  -x            verbose screen.\n"
+		"  -x            verbose screen.\n"
-		"  -v            dispaly version.\n"
+		"  -v            dispaly version.\n"
-		"  -h            show this help message.\n"
+		"  -h            show this help message.\n"
-
+
-		"Online help: http://pymumu.github.io/smartdns\n"
+		"Online help: http://pymumu.github.io/smartdns\n"
-		"Copyright (C) Nick Peng <pymumu@gmail.com>\n"
+		"Copyright (C) Nick Peng <pymumu@gmail.com>\n"
-		;
+		;
-	/* clang-format on */
+	/* clang-format on */
-	printf("%s", help);
+	printf("%s", help);
-}
+}
-
+
-static void _show_version(void)
+static void _show_version(void)
-{
+{
-	char str_ver[256] = {0};
+	char str_ver[256] = {0};
-#ifdef SMARTDNS_VERION
+#ifdef SMARTDNS_VERION
-	const char *ver = SMARTDNS_VERION;
+	const char *ver = SMARTDNS_VERION;
-	snprintf(str_ver, sizeof(str_ver), "%s", ver);
+	snprintf(str_ver, sizeof(str_ver), "%s", ver);
-#else
+#else
-	struct tm tm;
+	struct tm tm;
-	get_compiled_time(&tm);
+	get_compiled_time(&tm);
-	snprintf(str_ver, sizeof(str_ver), "1.%.4d%.2d%.2d-%.2d%.2d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);
+	snprintf(str_ver, sizeof(str_ver), "1.%.4d%.2d%.2d-%.2d%.2d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
-#endif
+			 tm.tm_hour, tm.tm_min);
-	printf("smartdns %s\n", str_ver);
+#endif
-}
+	printf("smartdns %s\n", str_ver);
-
+}
-static int _smartdns_load_from_resolv(void)
+
-{
+static int _smartdns_load_from_resolv(void)
-	FILE *fp = NULL;
+{
-	char line[MAX_LINE_LEN];
+	FILE *fp = NULL;
-	char key[MAX_KEY_LEN];
+	char line[MAX_LINE_LEN];
-	char value[MAX_LINE_LEN];
+	char key[MAX_KEY_LEN];
-	char ns_ip[DNS_MAX_IPLEN];
+	char value[MAX_LINE_LEN];
-	int port = PORT_NOT_DEFINED;
+	char ns_ip[DNS_MAX_IPLEN];
-	int ret = -1;
+	int port = PORT_NOT_DEFINED;
-
+	int ret = -1;
-	int filed_num = 0;
+
-	int line_num = 0;
+	int filed_num = 0;
-
+	int line_num = 0;
-	fp = fopen(RESOLVE_FILE, "r");
+
-	if (fp == NULL) {
+	fp = fopen(RESOLVE_FILE, "r");
-		tlog(TLOG_ERROR, "open %s failed, %s", RESOLVE_FILE, strerror(errno));
+	if (fp == NULL) {
-		return -1;
+		tlog(TLOG_ERROR, "open %s failed, %s", RESOLVE_FILE, strerror(errno));
-	}
+		return -1;
-
+	}
-	while (fgets(line, MAX_LINE_LEN, fp)) {
+
-		line_num++;
+	while (fgets(line, MAX_LINE_LEN, fp)) {
-		filed_num = sscanf(line, "%63s %1023[^\r\n]s", key, value);
+		line_num++;
-
+		filed_num = sscanf(line, "%63s %1023[^\r\n]s", key, value);
-		if (filed_num != 2) {
+
-			continue;
+		if (filed_num != 2) {
-		}
+			continue;
-
+		}
-		if (strncmp(key, "nameserver", MAX_KEY_LEN) != 0) {
+
-			continue;
+		if (strncmp(key, "nameserver", MAX_KEY_LEN) != 0) {
-		}
+			continue;
-
+		}
-		if (parse_ip(value, ns_ip, &port) != 0) {
+
-			continue;
+		if (parse_ip(value, ns_ip, &port) != 0) {
-		}
+			continue;
-
+		}
-		if (port == PORT_NOT_DEFINED) {
+
-			port = DEFAULT_DNS_PORT;
+		if (port == PORT_NOT_DEFINED) {
-		}
+			port = DEFAULT_DNS_PORT;
-
+		}
-		safe_strncpy(dns_conf_servers[dns_conf_server_num].server, ns_ip, DNS_MAX_IPLEN);
+
-		dns_conf_servers[dns_conf_server_num].port = port;
+		safe_strncpy(dns_conf_servers[dns_conf_server_num].server, ns_ip, DNS_MAX_IPLEN);
-		dns_conf_servers[dns_conf_server_num].type = DNS_SERVER_UDP;
+		dns_conf_servers[dns_conf_server_num].port = port;
-		dns_conf_server_num++;
+		dns_conf_servers[dns_conf_server_num].type = DNS_SERVER_UDP;
-		ret = 0;
+		dns_conf_server_num++;
-	}
+		ret = 0;
-
+	}
-	fclose(fp);
+
-
+	fclose(fp);
-	return ret;
+
-}
+	return ret;
-
+}
-static int _smartdns_add_servers(void)
+
-{
+static int _smartdns_add_servers(void)
-	int i = 0;
+{
-	int j = 0;
+	int i = 0;
-	int ret = 0;
+	int j = 0;
-	struct dns_server_groups *group = NULL;
+	int ret = 0;
-	struct dns_servers *server = NULL;
+	struct dns_server_groups *group = NULL;
-	struct client_dns_server_flags flags;
+	struct dns_servers *server = NULL;
-
+	struct client_dns_server_flags flags;
-	for (i = 0; i < dns_conf_server_num; i++) {
+
-		memset(&flags, 0, sizeof(flags));
+	for (i = 0; i < dns_conf_server_num; i++) {
-		switch (dns_conf_servers[i].type) {
+		memset(&flags, 0, sizeof(flags));
-		case DNS_SERVER_UDP: {
+		switch (dns_conf_servers[i].type) {
-			struct client_dns_server_flag_udp *flag_udp = &flags.udp;
+		case DNS_SERVER_UDP: {
-			flag_udp->ttl = dns_conf_servers[i].ttl;
+			struct client_dns_server_flag_udp *flag_udp = &flags.udp;
-		} break;
+			flag_udp->ttl = dns_conf_servers[i].ttl;
-		case DNS_SERVER_HTTPS: {
+		} break;
-			struct client_dns_server_flag_https *flag_http = &flags.https;
+		case DNS_SERVER_HTTPS: {
-			flag_http->spi_len = dns_client_spki_decode(dns_conf_servers[i].spki, (unsigned char *)flag_http->spki);
+			struct client_dns_server_flag_https *flag_http = &flags.https;
-			safe_strncpy(flag_http->hostname, dns_conf_servers[i].hostname, sizeof(flag_http->hostname));
+			flag_http->spi_len = dns_client_spki_decode(dns_conf_servers[i].spki, (unsigned char *)flag_http->spki);
-			safe_strncpy(flag_http->path, dns_conf_servers[i].path, sizeof(flag_http->path));
+			safe_strncpy(flag_http->hostname, dns_conf_servers[i].hostname, sizeof(flag_http->hostname));
-			safe_strncpy(flag_http->httphost, dns_conf_servers[i].httphost, sizeof(flag_http->httphost));
+			safe_strncpy(flag_http->path, dns_conf_servers[i].path, sizeof(flag_http->path));
-			safe_strncpy(flag_http->tls_host_verify, dns_conf_servers[i].tls_host_verify, sizeof(flag_http->tls_host_verify));
+			safe_strncpy(flag_http->httphost, dns_conf_servers[i].httphost, sizeof(flag_http->httphost));
-		} break;
+			safe_strncpy(flag_http->tls_host_verify, dns_conf_servers[i].tls_host_verify,
-		case DNS_SERVER_TLS: {
+						 sizeof(flag_http->tls_host_verify));
-			struct client_dns_server_flag_tls *flag_tls = &flags.tls;
+			flag_http->skip_check_cert = dns_conf_servers[i].skip_check_cert;
-			flag_tls->spi_len = dns_client_spki_decode(dns_conf_servers[i].spki, (unsigned char *)flag_tls->spki);
+		} break;
-			safe_strncpy(flag_tls->hostname, dns_conf_servers[i].hostname, sizeof(flag_tls->hostname));
+		case DNS_SERVER_TLS: {
-			safe_strncpy(flag_tls->tls_host_verify, dns_conf_servers[i].tls_host_verify, sizeof(flag_tls->tls_host_verify));
+			struct client_dns_server_flag_tls *flag_tls = &flags.tls;
-		} break;
+			flag_tls->spi_len = dns_client_spki_decode(dns_conf_servers[i].spki, (unsigned char *)flag_tls->spki);
-		case DNS_SERVER_TCP:
+			safe_strncpy(flag_tls->hostname, dns_conf_servers[i].hostname, sizeof(flag_tls->hostname));
-			break;
+			safe_strncpy(flag_tls->tls_host_verify, dns_conf_servers[i].tls_host_verify,
-		default:
+						 sizeof(flag_tls->tls_host_verify));
-			return -1;
+			flag_tls->skip_check_cert = dns_conf_servers[i].skip_check_cert;
-			break;
+
-		}
+		} break;
-
+		case DNS_SERVER_TCP:
-		flags.type = dns_conf_servers[i].type;
+			break;
-		flags.server_flag = dns_conf_servers[i].server_flag;
+		default:
-		flags.result_flag = dns_conf_servers[i].result_flag;
+			return -1;
-		ret = dns_client_add_server(dns_conf_servers[i].server, dns_conf_servers[i].port, dns_conf_servers[i].type, &flags);
+			break;
-		if (ret != 0) {
+		}
-			tlog(TLOG_ERROR, "add server failed, %s:%d", dns_conf_servers[i].server, dns_conf_servers[i].port);
+
-			return -1;
+		flags.type = dns_conf_servers[i].type;
-		}
+		flags.server_flag = dns_conf_servers[i].server_flag;
-	}
+		flags.result_flag = dns_conf_servers[i].result_flag;
-
+		ret = dns_client_add_server(dns_conf_servers[i].server, dns_conf_servers[i].port, dns_conf_servers[i].type,
-	hash_for_each(dns_group_table.group, i, group, node)
+									&flags);
-	{
+		if (ret != 0) {
-		ret = dns_client_add_group(group->group_name);
+			tlog(TLOG_ERROR, "add server failed, %s:%d", dns_conf_servers[i].server, dns_conf_servers[i].port);
-		if (ret != 0) {
+			return -1;
-			tlog(TLOG_ERROR, "add group failed, %s", group->group_name);
+		}
-			return -1;
+	}
-		}
+
-
+	hash_for_each(dns_group_table.group, i, group, node)
-		for (j = 0; j < group->server_num; j++) {
+	{
-			server = group->servers[j];
+		ret = dns_client_add_group(group->group_name);
-			if (server == NULL) {
+		if (ret != 0) {
-				continue;
+			tlog(TLOG_ERROR, "add group failed, %s", group->group_name);
-			}
+			return -1;
-			ret = dns_client_add_to_group(group->group_name, server->server, server->port, server->type);
+		}
-			if (ret != 0) {
+
-				tlog(TLOG_ERROR, "add server %s to group %s failed", server->server, group->group_name);
+		for (j = 0; j < group->server_num; j++) {
-				return -1;
+			server = group->servers[j];
-			}
+			if (server == NULL) {
-		}
+				continue;
-	}
+			}
-
+			ret = dns_client_add_to_group(group->group_name, server->server, server->port, server->type);
-	return 0;
+			if (ret != 0) {
-}
+				tlog(TLOG_ERROR, "add server %s to group %s failed", server->server, group->group_name);
-
+				return -1;
-static int _smartdns_set_ecs_ip(void)
+			}
-{
+		}
-	int ret = 0;
+	}
-	if (dns_conf_ipv4_ecs.enable) {
+
-		ret |= dns_client_set_ecs(dns_conf_ipv4_ecs.ip, dns_conf_ipv4_ecs.subnet);
+	return 0;
-	}
+}
-
+
-	if (dns_conf_ipv6_ecs.enable) {
+static int _smartdns_set_ecs_ip(void)
-		ret |= dns_client_set_ecs(dns_conf_ipv6_ecs.ip, dns_conf_ipv6_ecs.subnet);
+{
-	}
+	int ret = 0;
-
+	if (dns_conf_ipv4_ecs.enable) {
-	return ret;
+		ret |= dns_client_set_ecs(dns_conf_ipv4_ecs.ip, dns_conf_ipv4_ecs.subnet);
-}
+	}
-
+
-static int _smartdns_init_ssl(void)
+	if (dns_conf_ipv6_ecs.enable) {
-{
+		ret |= dns_client_set_ecs(dns_conf_ipv6_ecs.ip, dns_conf_ipv6_ecs.subnet);
-	SSL_load_error_strings();
+	}
-	SSL_library_init();
+
-	OpenSSL_add_all_algorithms();
+	return ret;
-	SSL_CRYPTO_thread_setup();
+}
-
+
-	return 0;
+static int _smartdns_init_ssl(void)
-}
+{
-
+#if OPENSSL_API_COMPAT < 0x10100000L
-static int _smartdns_destroy_ssl(void)
+	SSL_load_error_strings();
-{
+	SSL_library_init();
-	SSL_CRYPTO_thread_cleanup();
+	OpenSSL_add_all_algorithms();
-	ERR_free_strings();
+	SSL_CRYPTO_thread_setup();
-	EVP_cleanup();
+#endif
-
+	return 0;
-	return 0;
+}
-}
+
-
+static int _smartdns_destroy_ssl(void)
-static int _smartdns_init(void)
+{
-{
+#if OPENSSL_API_COMPAT < 0x10100000L
-	int ret;
+	SSL_CRYPTO_thread_cleanup();
-	char *logfile = SMARTDNS_LOG_FILE;
+	ERR_free_strings();
-
+	EVP_cleanup();
-	if (dns_conf_log_file[0] != 0) {
+#endif
-		logfile = dns_conf_log_file;
+	return 0;
-	}
+}
-
+
-	ret = tlog_init(logfile, dns_conf_log_size, dns_conf_log_num, 0, 0);
+static int _smartdns_init(void)
-	if (ret != 0) {
+{
-		tlog(TLOG_ERROR, "start tlog failed.\n");
+	int ret;
-		goto errout;
+	char *logfile = SMARTDNS_LOG_FILE;
-	}
+
-
+	if (dns_conf_log_file[0] != 0) {
-	tlog_setlogscreen(verbose_screen);
+		logfile = dns_conf_log_file;
-	tlog_setlevel(dns_conf_log_level);
+	}
-
+
-	tlog(TLOG_NOTICE, "smartdns starting...(Copyright (C) Nick Peng <pymumu@gmail.com>, build:%s %s)", __DATE__, __TIME__);
+	ret = tlog_init(logfile, dns_conf_log_size, dns_conf_log_num, 0, 0);
-
+	if (ret != 0) {
-	if (_smartdns_init_ssl() != 0) {
+		tlog(TLOG_ERROR, "start tlog failed.\n");
-		tlog(TLOG_ERROR, "init ssl failed.");
+		goto errout;
-		goto errout;
+	}
-	}
+
-
+	tlog_setlogscreen(verbose_screen);
-	if (dns_conf_server_num <= 0) {
+	tlog_setlevel(dns_conf_log_level);
-		if (_smartdns_load_from_resolv() != 0) {
+
-			tlog(TLOG_ERROR, "load dns from resolv failed.");
+	tlog(TLOG_NOTICE, "smartdns starting...(Copyright (C) Nick Peng <pymumu@gmail.com>, build:%s %s)", __DATE__,
-			goto errout;
+		 __TIME__);
-		}
+
-	}
+	if (_smartdns_init_ssl() != 0) {
-
+		tlog(TLOG_ERROR, "init ssl failed.");
-	ret = fast_ping_init();
+		goto errout;
-	if (ret != 0) {
+	}
-		tlog(TLOG_ERROR, "start ping failed.\n");
+
-		goto errout;
+	if (dns_conf_server_num <= 0) {
-	}
+		if (_smartdns_load_from_resolv() != 0) {
-
+			tlog(TLOG_ERROR, "load dns from resolv failed.");
-	ret = dns_server_init();
+			goto errout;
-	if (ret != 0) {
+		}
-		tlog(TLOG_ERROR, "start dns server failed.\n");
+	}
-		goto errout;
+
-	}
+	ret = fast_ping_init();
-
+	if (ret != 0) {
-	ret = dns_client_init();
+		tlog(TLOG_ERROR, "start ping failed.\n");
-	if (ret != 0) {
+		goto errout;
-		tlog(TLOG_ERROR, "start dns client failed.\n");
+	}
-		goto errout;
+
-	}
+	ret = dns_server_init();
-	ret = _smartdns_add_servers();
+	if (ret != 0) {
-	if (ret != 0) {
+		tlog(TLOG_ERROR, "start dns server failed.\n");
-		tlog(TLOG_ERROR, "add servers failed.");
+		goto errout;
-		goto errout;
+	}
-	}
+
-
+	ret = dns_client_init();
-	ret = _smartdns_set_ecs_ip();
+	if (ret != 0) {
-	if (ret != 0) {
+		tlog(TLOG_ERROR, "start dns client failed.\n");
-		tlog(TLOG_WARN, "set ecs ip address failed.");
+		goto errout;
-	}
+	}
-
+	ret = _smartdns_add_servers();
-	return 0;
+	if (ret != 0) {
-errout:
+		tlog(TLOG_ERROR, "add servers failed.");
-
+		goto errout;
-	return -1;
+	}
-}
+
-
+	ret = _smartdns_set_ecs_ip();
-static int _smartdns_run(void)
+	if (ret != 0) {
-{
+		tlog(TLOG_WARN, "set ecs ip address failed.");
-	return dns_server_run();
+	}
-}
+
-
+	return 0;
-static void _smartdns_exit(void)
+errout:
-{
+
-	dns_server_exit();
+	return -1;
-	dns_client_exit();
+}
-	fast_ping_exit();
+
-	_smartdns_destroy_ssl();
+static int _smartdns_run(void)
-	tlog_exit();
+{
-	dns_server_load_exit();
+	return dns_server_run();
-}
+}
-
+
-static void _sig_exit(int signo)
+static void _smartdns_exit(void)
-{
+{
-	dns_server_stop();
+	dns_server_exit();
-}
+	dns_client_exit();
-
+	fast_ping_exit();
-static void _sig_error_exit(int signo, siginfo_t *siginfo, void *ct)
+	_smartdns_destroy_ssl();
-{
+	tlog_exit();
-	unsigned long PC = 0;
+	dns_server_load_exit();
-	ucontext_t *context = ct;
+}
-#if defined(__i386__)
+
-	int *pgregs = (int *)(&(context->uc_mcontext.gregs));
+static void _sig_exit(int signo)
-	PC = pgregs[REG_EIP];
+{
-#elif defined(__x86_64__)
+	dns_server_stop();
-	int *pgregs = (int *)(&(context->uc_mcontext.gregs));
+}
-	PC = pgregs[REG_RIP];
+
-#elif defined(__arm__)
+static void _sig_error_exit(int signo, siginfo_t *siginfo, void *ct)
-	PC = context->uc_mcontext.arm_pc;
+{
-#elif defined(__aarch64__)
+	unsigned long PC = 0;
-	PC = context->uc_mcontext.pc;
+	ucontext_t *context = ct;
-#elif defined(__mips__)
+#if defined(__i386__)
-	PC = context->uc_mcontext.pc;
+	int *pgregs = (int *)(&(context->uc_mcontext.gregs));
-#endif
+	PC = pgregs[REG_EIP];
-	tlog(TLOG_FATAL, "process exit with signal %d, code = %d, errno = %d, pid = %d, self = %d, pc = %#lx, addr = %#lx, build(%s %s)\n", signo, siginfo->si_code,
+#elif defined(__x86_64__)
-		 siginfo->si_errno, siginfo->si_pid, getpid(), PC, (unsigned long)siginfo->si_addr, __DATE__, __TIME__);
+	int *pgregs = (int *)(&(context->uc_mcontext.gregs));
-
+	PC = pgregs[REG_RIP];
-	sleep(1);
+#elif defined(__arm__)
-	_exit(0);
+	PC = context->uc_mcontext.arm_pc;
-}
+#elif defined(__aarch64__)
-
+	PC = context->uc_mcontext.pc;
-static int sig_list[] = {SIGSEGV, SIGABRT, SIGBUS, SIGILL, SIGFPE};
+#elif defined(__mips__)
-
+	PC = context->uc_mcontext.pc;
-static int sig_num = sizeof(sig_list) / sizeof(int);
+#endif
-
+	tlog(TLOG_FATAL,
-static void _reg_signal(void)
+		 "process exit with signal %d, code = %d, errno = %d, pid = %d, self = %d, pc = %#lx, addr = %#lx, build(%s "
-{
+		 "%s)\n",
-	struct sigaction act, old;
+		 signo, siginfo->si_code, siginfo->si_errno, siginfo->si_pid, getpid(), PC, (unsigned long)siginfo->si_addr,
-	int i = 0;
+		 __DATE__, __TIME__);
-	act.sa_sigaction = _sig_error_exit;
+
-	sigemptyset(&act.sa_mask);
+	sleep(1);
-	act.sa_flags = SA_RESTART | SA_SIGINFO;
+	_exit(0);
-
+}
-	for (i = 0; i < sig_num; i++) {
+
-		sigaction(sig_list[i], &act, &old);
+static int sig_list[] = {SIGSEGV, SIGABRT, SIGBUS, SIGILL, SIGFPE};
-	}
+
-}
+static int sig_num = sizeof(sig_list) / sizeof(int);
-
+
-int main(int argc, char *argv[])
+static void _reg_signal(void)
-{
+{
-	int ret;
+	struct sigaction act, old;
-	int is_forground = 0;
+	int i = 0;
-	int opt;
+	act.sa_sigaction = _sig_error_exit;
-	char config_file[MAX_LINE_LEN];
+	sigemptyset(&act.sa_mask);
-	char pid_file[MAX_LINE_LEN];
+	act.sa_flags = SA_RESTART | SA_SIGINFO;
-	int signal_ignore = 0;
+
-
+	for (i = 0; i < sig_num; i++) {
-	safe_strncpy(config_file, SMARTDNS_CONF_FILE, MAX_LINE_LEN);
+		sigaction(sig_list[i], &act, &old);
-	safe_strncpy(pid_file, SMARTDNS_PID_FILE, MAX_LINE_LEN);
+	}
-
+}
-	while ((opt = getopt(argc, argv, "fhc:p:Svx")) != -1) {
+
-		switch (opt) {
+int main(int argc, char *argv[])
-		case 'f':
+{
-			is_forground = 1;
+	int ret;
-			break;
+	int is_forground = 0;
-		case 'c':
+	int opt;
-			snprintf(config_file, sizeof(config_file), "%s", optarg);
+	char config_file[MAX_LINE_LEN];
-			break;
+	char pid_file[MAX_LINE_LEN];
-		case 'p':
+	int signal_ignore = 0;
-			snprintf(pid_file, sizeof(pid_file), "%s", optarg);
+
-			break;
+	safe_strncpy(config_file, SMARTDNS_CONF_FILE, MAX_LINE_LEN);
-		case 'S':
+	safe_strncpy(pid_file, SMARTDNS_PID_FILE, MAX_LINE_LEN);
-			signal_ignore = 1;
+
-			break;
+	while ((opt = getopt(argc, argv, "fhc:p:Svx")) != -1) {
-		case 'x':
+		switch (opt) {
-			verbose_screen = 1;
+		case 'f':
-			break;
+			is_forground = 1;
-		case 'v':
+			break;
-			_show_version();
+		case 'c':
-			return 0;
+			snprintf(config_file, sizeof(config_file), "%s", optarg);
-			break;
+			break;
-		case 'h':
+		case 'p':
-			_help();
+			snprintf(pid_file, sizeof(pid_file), "%s", optarg);
-			return 1;
+			break;
-		}
+		case 'S':
-	}
+			signal_ignore = 1;
-
+			break;
-	if (is_forground == 0) {
+		case 'x':
-		if (daemon(0, 0) < 0) {
+			verbose_screen = 1;
-			fprintf(stderr, "run daemon process failed, %s\n", strerror(errno));
+			break;
-			return 1;
+		case 'v':
-		}
+			_show_version();
-	}
+			return 0;
-
+			break;
-	if (signal_ignore == 0) {
+		case 'h':
-		_reg_signal();
+			_help();
-	}
+			return 1;
-
+		}
-	if (create_pid_file(pid_file) != 0) {
+	}
-		goto errout;
+
-	}
+	if (is_forground == 0) {
-
+		if (daemon(0, 0) < 0) {
-	if (dns_server_load_conf(config_file) != 0) {
+			fprintf(stderr, "run daemon process failed, %s\n", strerror(errno));
-		fprintf(stderr, "load config failed.\n");
+			return 1;
-		goto errout;
+		}
-	}
+	}
-
+
-	ret = _smartdns_init();
+	if (signal_ignore == 0) {
-	if (ret != 0) {
+		_reg_signal();
-		usleep(100000);
+	}
-		goto errout;
+
-	}
+	if (create_pid_file(pid_file) != 0) {
-
+		goto errout;
-	signal(SIGINT, _sig_exit);
+	}
-	signal(SIGPIPE, SIG_IGN);
+
-	atexit(_smartdns_exit);
+	if (dns_server_load_conf(config_file) != 0) {
-
+		fprintf(stderr, "load config failed.\n");
-	return _smartdns_run();
+		goto errout;
-
+	}
-errout:
+
-
+	ret = _smartdns_init();
-	return 1;
+	if (ret != 0) {
-}
+		usleep(100000);
+		goto errout;
+	}
+
+	signal(SIGINT, _sig_exit);
+	signal(SIGPIPE, SIG_IGN);
+	atexit(_smartdns_exit);
+
+	return _smartdns_run();
+
+errout:
+
+	return 1;
+}

src/util.c

@@ -24,20 +24,20 @@
 #include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <linux/netlink.h>
+#include <inttypes.h>
 #include <linux/capability.h>
+#include <linux/netlink.h>
+#include <netinet/tcp.h>
 #include <openssl/crypto.h>
 #include <openssl/ssl.h>
 #include <pthread.h>
-#include <netinet/tcp.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/prctl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
-#include <inttypes.h>
-#include <sys/prctl.h>
 
 #define TMP_BUFF_LEN_32 32
 
@@ -285,14 +285,14 @@ int parse_ip(const char *value, char *ip, int *port)
 	return 0;
 }
 
-static int _check_is_ipv4(const char *ip) 
+static int _check_is_ipv4(const char *ip)
 {
 	const char *ptr = ip;
 	char c = 0;
 	int dot_num = 0;
 	int dig_num = 0;
 
-	while ( (c = *ptr++) != '\0') {
+	while ((c = *ptr++) != '\0') {
 		if (c == '.') {
 			dot_num++;
 			dig_num = 0;
@@ -326,7 +326,7 @@ static int _check_is_ipv6(const char *ip)
 	int colon_num = 0;
 	int dig_num = 0;
 
-	while ( (c = *ptr++) != '\0') {
+	while ((c = *ptr++) != '\0') {
 		if (c == '[' || c == ']') {
 			continue;
 		}
@@ -420,7 +420,7 @@ int parse_uri(char *value, char *scheme, char *host, int *port, char *path)
 
 	if (path) {
 		strncpy(path, process_ptr, PATH_MAX);
-	} 
+	}
 	return 0;
 }
 
@@ -456,8 +456,8 @@ char *reverse_string(char *output, const char *input, int len, int to_lower_case
 		if (to_lower_case) {
 			if (*output >= 'A' && *output <= 'Z') {
 				/* To lower case */
-         		*output = *output + 32;
+				*output = *output + 32;
-      		}
+			}
 		}
 		output++;
 		len--;
@@ -502,7 +502,8 @@ static int _ipset_support_timeout(const char *ipsetname)
 	return -1;
 }
 
-static int _ipset_operate(const char *ipsetname, const unsigned char addr[], int addr_len, unsigned long timeout, int operate)
+static int _ipset_operate(const char *ipsetname, const unsigned char addr[], int addr_len, unsigned long timeout,
+						  int operate)
 {
 	struct nlmsghdr *netlink_head;
 	struct ipset_netlink_msg *netlink_msg;
@@ -560,7 +561,9 @@ static int _ipset_operate(const char *ipsetname, const unsigned char addr[], int
 	netlink_head->nlmsg_len += NETLINK_ALIGN(sizeof(struct ipset_netlink_attr));
 	nested[1]->type = NLA_F_NESTED | IPSET_ATTR_IP;
 
-	_ipset_add_attr(netlink_head, (af == AF_INET ? IPSET_ATTR_IPADDR_IPV4 : IPSET_ATTR_IPADDR_IPV6) | NLA_F_NET_BYTEORDER, addr_len, addr);
+	_ipset_add_attr(netlink_head,
+					(af == AF_INET ? IPSET_ATTR_IPADDR_IPV4 : IPSET_ATTR_IPADDR_IPV6) | NLA_F_NET_BYTEORDER, addr_len,
+					addr);
 	nested[1]->len = (void *)buffer + NETLINK_ALIGN(netlink_head->nlmsg_len) - (void *)nested[1];
 
 	if (timeout > 0 && _ipset_support_timeout(ipsetname) == 0) {
@@ -687,6 +690,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 +747,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
@@ -923,20 +928,20 @@ static int parse_server_name_extension(const char *data, size_t data_len, char *
 	return -2;
 }
 
-void get_compiled_time(struct tm *tm) 
+void get_compiled_time(struct tm *tm)
-{ 
+{
-    char s_month[5];
+	char s_month[5];
-    int month, day, year;
+	int month, day, year;
 	int hour, min, sec;
-    static const char *month_names = "JanFebMarAprMayJunJulAugSepOctNovDec";
+	static const char *month_names = "JanFebMarAprMayJunJulAugSepOctNovDec";
 
-    sscanf(__DATE__, "%5s %d %d", s_month, &day, &year);
+	sscanf(__DATE__, "%5s %d %d", s_month, &day, &year);
-    month = (strstr(month_names, s_month) - month_names) / 3;
+	month = (strstr(month_names, s_month) - month_names) / 3;
 	sscanf(__TIME__, "%d:%d:%d", &hour, &min, &sec);
-    tm->tm_year = year - 1900;
+	tm->tm_year = year - 1900;
-    tm->tm_mon = month;
+	tm->tm_mon = month;
-    tm->tm_mday = day;
+	tm->tm_mday = day;
-    tm->tm_isdst = -1;
+	tm->tm_isdst = -1;
 	tm->tm_hour = hour;
 	tm->tm_min = min;
 	tm->tm_sec = sec;
@@ -956,7 +961,7 @@ int has_network_raw_cap(void)
 int set_sock_keepalive(int fd, int keepidle, int keepinterval, int keepcnt)
 {
 	const int yes = 1;
-	if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes))!= 0) {
+	if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) != 0) {
 		return -1;
 	}
 
@@ -964,5 +969,19 @@ int set_sock_keepalive(int fd, int keepidle, int keepinterval, int keepcnt)
 	setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepinterval, sizeof(keepinterval));
 	setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepcnt, sizeof(keepcnt));
 
+	return 0;
+}
+
+int set_sock_lingertime(int fd, int time)
+{
+	struct linger l;
+
+	l.l_onoff = 1;
+	l.l_linger = 0;
+
+	if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (const char *)&l, sizeof(l)) != 0) {
+		return -1;
+	}
+
 	return 0;
 }

src/util.h

@@ -19,23 +19,27 @@
 #ifndef SMART_DNS_UTIL_H
 #define SMART_DNS_UTIL_H
 
+#include "stringutil.h"
 #include <netdb.h>
 #include <time.h>
-#include "stringutil.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /*__cplusplus */
 
+#ifndef TCP_FASTOPEN
+#define TCP_FASTOPEN 23
+#endif
+
 #ifndef TCP_FASTOPEN_CONNECT
 #define TCP_FASTOPEN_CONNECT 30
 #endif
 #ifndef TCP_THIN_LINEAR_TIMEOUTS
-#define TCP_THIN_LINEAR_TIMEOUTS 16 
+#define TCP_THIN_LINEAR_TIMEOUTS 16
 #endif
 
 #ifndef TCP_THIN_DUPACK
-#define TCP_THIN_DUPACK		 17 
+#define TCP_THIN_DUPACK 17
 #endif
 
 #define PORT_NOT_DEFINED -1
@@ -98,6 +102,8 @@ int has_network_raw_cap(void);
 
 int set_sock_keepalive(int fd, int keepidle, int keepinterval, int keepcnt);
 
+int set_sock_lingertime(int fd, int time);
+
 #ifdef __cplusplus
 }
 #endif /*__cplusplus */

systemd/smartdns.service.in

@@ -1,17 +1,17 @@
 [Unit]
 Description=smart dns server
 After=network.target 
+StartLimitBurst=0
+StartLimitIntervalSec=60
 
 [Service]
 Type=forking
-PIDFile=/var/run/smartdns.pid
+PIDFile=@RUNSTATEDIR@/smartdns.pid
-EnvironmentFile=/etc/default/smartdns
+EnvironmentFile=@SYSCONFDIR@/default/smartdns
-ExecStart=/usr/sbin/smartdns $SMART_DNS_OPTS
+ExecStart=@SBINDIR@/smartdns -p @RUNSTATEDIR@/smartdns.pid $SMART_DNS_OPTS 
 KillMode=process
 Restart=always
 RestartSec=2
-StartLimitBurst=0
-StartLimitIntervalSec=60
 
 [Install]
 WantedBy=multi-user.target