net/adblock/files/adblock.sh

   1 #!/bin/sh
   2 # dns based ad/abuse domain blocking
   3 # Copyright (c) 2015-2020 Dirk Brenken (dev@brenken.org)
   4 # This is free software, licensed under the GNU General Public License v3.
   5
   6 # set (s)hellcheck exceptions
   7 # shellcheck disable=1091,2016,2039,2059,2086,2143,2181,2188
   8
   9 # set initial defaults
  10 #
  11 export LC_ALL=C
  12 export PATH="/usr/sbin:/usr/bin:/sbin:/bin"
  13 set -o pipefail
  14 adb_ver="4.0.6"
  15 adb_enabled=0
  16 adb_debug=0
  17 adb_forcedns=0
  18 adb_maxqueue=4
  19 adb_dnsfilereset=0
  20 adb_dnsflush=0
  21 adb_dnstimeout=20
  22 adb_safesearch=0
  23 adb_safesearchlist=""
  24 adb_safesearchmod=0
  25 adb_report=0
  26 adb_trigger=""
  27 adb_triggerdelay=0
  28 adb_backup=1
  29 adb_mail=0
  30 adb_mailcnt=0
  31 adb_jail=0
  32 adb_dns=""
  33 adb_dnsprefix="adb_list"
  34 adb_locallist="blacklist whitelist"
  35 adb_tmpbase="/tmp"
  36 adb_backupdir="/tmp"
  37 adb_reportdir="/tmp"
  38 adb_jaildir="/tmp"
  39 adb_pidfile="/var/run/adblock.pid"
  40 adb_blacklist="/etc/adblock/adblock.blacklist"
  41 adb_whitelist="/etc/adblock/adblock.whitelist"
  42 adb_ubusservice="/etc/adblock/adblock.monitor"
  43 adb_mailservice="/etc/adblock/adblock.mail"
  44 adb_dnsfile="${adb_dnsprefix}.overall"
  45 adb_dnsjail="${adb_dnsprefix}.jail"
  46 adb_srcarc="/etc/adblock/adblock.sources.gz"
  47 adb_srcfile="${adb_tmpbase}/adb_sources.json"
  48 adb_rtfile="${adb_tmpbase}/adb_runtime.json"
  49 adb_loggercmd="$(command -v logger)"
  50 adb_dumpcmd="$(command -v tcpdump)"
  51 adb_lookupcmd="$(command -v nslookup)"
  52 adb_fetchutil=""
  53 adb_portlist="53 853 5353"
  54 adb_repiface=""
  55 adb_replisten="53"
  56 adb_repchunkcnt="5"
  57 adb_repchunksize="1"
  58 adb_lookupdomain="example.com"
  59 adb_action="${1:-"start"}"
  60 adb_packages=""
  61 adb_sources=""
  62 adb_cnt=""
  63
  64 # load & check adblock environment
  65 #
  66 f_load()
  67 {
  68         adb_sysver="$(ubus -S call system board 2>/dev/null | jsonfilter -e '@.model' -e '@.release.description' | \
  69                 "${adb_awk}" 'BEGIN{ORS=", "}{print $0}' | "${adb_awk}" '{print substr($0,1,length($0)-2)}')"
  70         f_conf
  71         if [ "${adb_action}" != "report" ]
  72         then
  73                 f_dns
  74                 f_fetch
  75         fi
  76
  77         if [ "${adb_enabled}" -eq 0 ]
  78         then
  79                 f_extconf
  80                 f_temp
  81                 f_rmdns
  82                 f_bgserv "stop"
  83                 f_jsnup "disabled"
  84                 f_log "info" "adblock is currently disabled, please set the config option 'adb_enabled' to '1' to use this service"
  85                 exit 0
  86         fi
  87 }
  88
  89 # check & set environment
  90 #
  91 f_env()
  92 {
  93         adb_starttime="$(date "+%s")"
  94         f_log "info" "adblock instance started ::: action: ${adb_action}, priority: ${adb_nice:-"0"}, pid: ${$}"
  95         f_jsnup "running"
  96         f_extconf
  97         f_temp
  98
  99         if [ "${adb_dnsflush}" -eq 1 ]
 100         then
 101                 printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
 102                 f_dnsup
 103         fi
 104
 105         if [ ! -r "${adb_srcfile}" ]
 106         then
 107                 if [ -r "${adb_srcarc}" ]
 108                 then
 109                         zcat "${adb_srcarc}" > "${adb_srcfile}"
 110                 else
 111                         f_log "err" "adblock source archive not found"
 112                 fi
 113         fi
 114         if [ -r "${adb_srcfile}" ]
 115         then
 116                 json_load_file "${adb_srcfile}"
 117         else
 118                 f_log "err" "adblock source file not found"
 119         fi
 120 }
 121
 122 # load adblock config
 123 #
 124 f_conf()
 125 {
 126         local cnt=0 cnt_max=10
 127
 128         if [ ! -r "/etc/config/adblock" ] || [ -n "$(uci -q show adblock.@source[0])" ]
 129         then
 130                 if { [ -r "/etc/config/adblock-opkg" ] && [ -z "$(uci -q show adblock-opkg.@source[0])" ]; } || \
 131                         { [ -r "/rom/etc/config/adblock" ] && [ -z "$(uci -q show /rom/etc/config/adblock.@source[0])" ]; }
 132                 then
 133                         if [ -r "/etc/config/adblock" ]
 134                         then
 135                                 cp -pf "/etc/config/adblock" "/etc/config/adblock-backup"
 136                         fi
 137                         if [ -r "/etc/config/adblock-opkg" ]
 138                         then
 139                                 cp -pf "/etc/config/adblock-opkg" "/etc/config/adblock"
 140                         elif [ -r "/rom/etc/config/adblock" ]
 141                         then
 142                                 cp -pf "/rom/etc/config/adblock" "/etc/config/adblock"
 143                         fi
 144                         f_log "info" "missing or old adblock config replaced with new valid default config"
 145                 else
 146                         f_log "err" "unrecoverable adblock config error, please re-install the package via opkg with the '--force-reinstall --force-maintainer' options"
 147                 fi
 148         fi
 149
 150         config_cb()
 151         {
 152                 option_cb()
 153                 {
 154                         local option="${1}"
 155                         local value="${2}"
 156                         eval "${option}=\"${value}\""
 157                 }
 158                 list_cb()
 159                 {
 160                         local option="${1}"
 161                         local value="${2}"
 162                         if [ "${option}" = "adb_sources" ]
 163                         then
 164                                 eval "${option}=\"$(printf "%s" "${adb_sources}") ${value}\""
 165                         elif [ "${option}" = "adb_safesearchlist" ]
 166                         then
 167                                 eval "${option}=\"$(printf "%s" "${adb_safesearchlist}") ${value}\""
 168                         fi
 169                 }
 170         }
 171         config_load adblock
 172
 173         if [ -z "${adb_fetchutil}" ] || [ -z "${adb_dns}" ]
 174         then
 175                 while [ -z "${adb_packages}" ] && [ "${cnt}" -le "${cnt_max}" ]
 176                 do
 177                         adb_packages="$(opkg list-installed 2>/dev/null)"
 178                         cnt=$((cnt+1))
 179                         sleep 1
 180                 done
 181                 if [ -z "${adb_packages}" ]
 182                 then
 183                         f_log "err" "local opkg package repository is not available, please set 'adb_fetchutil' and 'adb_dns' manually"
 184                 fi
 185         fi
 186 }
 187
 188 # load dns backend config
 189 #
 190 f_dns()
 191 {
 192         local util utils dns_up cnt=0
 193
 194         if [ -z "${adb_dns}" ]
 195         then
 196                 utils="knot-resolver named unbound dnsmasq raw"
 197                 for util in ${utils}
 198                 do
 199                         if [ "${util}" = "raw" ] || [ -n "$(printf "%s" "${adb_packages}" | grep "^${util}")" ]
 200                         then
 201                                 if [ "${util}" = "knot-resolver" ]
 202                                 then
 203                                         util="kresd"
 204                                 fi
 205                                 if [ "${util}" = "raw" ] || [ -x "$(command -v "${util}")" ]
 206                                 then
 207                                         adb_dns="${util}"
 208                                         uci_set adblock global adb_dns "${util}"
 209                                         f_uci "adblock"
 210                                         break
 211                                 fi
 212                         fi
 213                 done
 214         elif [ "${adb_dns}" != "raw" ] && [ ! -x "$(command -v "${adb_dns}")" ]
 215         then
 216                 unset adb_dns
 217         fi
 218
 219         if [ -n "${adb_dns}" ]
 220         then
 221                 case "${adb_dns}" in
 222                         "dnsmasq")
 223                                 adb_dnsinotify="${adb_dnsinotify:-"0"}"
 224                                 adb_dnsinstance="${adb_dnsinstance:-"0"}"
 225                                 adb_dnsuser="${adb_dnsuser:-"dnsmasq"}"
 226                                 adb_dnsdir="${adb_dnsdir:-"/tmp/dnsmasq.d"}"
 227                                 adb_dnsheader="${adb_dnsheader}"
 228                                 adb_dnsdeny="${adb_dnsdeny:-"${adb_awk} '{print \"address=/\"\$0\"/\"}'"}"
 229                                 adb_dnsallow="${adb_dnsallow:-"${adb_awk} '{print \"local=/\"\$0\"/#\"}'"}"
 230                                 adb_dnssafesearch="${adb_dnssafesearch:-"${adb_awk} -v item=\"\$item\" '{print \"address=/\"\$0\"/\"item\"\"}'"}"
 231                                 adb_dnsstop="${adb_dnsstop:-"address=/#/"}"
 232                         ;;
 233                         "unbound")
 234                                 adb_dnsinotify="${adb_dnsinotify:-"0"}"
 235                                 adb_dnsinstance="${adb_dnsinstance:-"0"}"
 236                                 adb_dnsuser="${adb_dnsuser:-"unbound"}"
 237                                 adb_dnsdir="${adb_dnsdir:-"/var/lib/unbound"}"
 238                                 adb_dnsheader="${adb_dnsheader}"
 239                                 adb_dnsdeny="${adb_dnsdeny:-"${adb_awk} '{print \"local-zone: \\042\"\$0\"\\042 static\"}'"}"
 240                                 adb_dnsallow="${adb_dnsallow:-"${adb_awk} '{print \"local-zone: \\042\"\$0\"\\042 transparent\"}'"}"
 241                                 adb_dnssafesearch="${adb_dnssafesearch:-"${adb_awk} -v item=\"\$item\" '{type=\"AAAA\";if(match(item,/^([0-9]{1,3}\.){3}[0-9]{1,3}$/)){type=\"A\"}}{print \"local-data: \\042\"\$0\" \"type\" \"item\"\\042\"}'"}"
 242                                 adb_dnsstop="${adb_dnsstop:-"local-zone: \".\" static"}"
 243                         ;;
 244                         "named")
 245                                 adb_dnsinotify="${adb_dnsinotify:-"0"}"
 246                                 adb_dnsinstance="${adb_dnsinstance:-"0"}"
 247                                 adb_dnsuser="${adb_dnsuser:-"bind"}"
 248                                 adb_dnsdir="${adb_dnsdir:-"/var/lib/bind"}"
 249                                 adb_dnsheader="${adb_dnsheader:-"\$TTL 2h\n@ IN SOA localhost. root.localhost. (1 6h 1h 1w 2h)\n  IN NS  localhost.\n"}"
 250                                 adb_dnsdeny="${adb_dnsdeny:-"${adb_awk} '{print \"\"\$0\" CNAME .\\n*.\"\$0\" CNAME .\"}'"}"
 251                                 adb_dnsallow="${adb_dnsallow:-"${adb_awk} '{print \"\"\$0\" CNAME rpz-passthru.\\n*.\"\$0\" CNAME rpz-passthru.\"}'"}"
 252                                 adb_dnssafesearch="${adb_dnssafesearch:-"${adb_awk} -v item=\"\$item\" '{print \"\"\$0\" CNAME \"item\".\\n*.\"\$0\" CNAME \"item\".\"}'"}"
 253                                 adb_dnsstop="${adb_dnsstop:-"* CNAME ."}"
 254                         ;;
 255                         "kresd")
 256                                 adb_dnsinotify="${adb_dnsinotify:-"0"}"
 257                                 adb_dnsinstance="${adb_dnsinstance:-"0"}"
 258                                 adb_dnsuser="${adb_dnsuser:-"root"}"
 259                                 adb_dnsdir="${adb_dnsdir:-"/etc/kresd"}"
 260                                 adb_dnsheader="${adb_dnsheader:-"\$TTL 2h\n@ IN SOA localhost. root.localhost. (1 6h 1h 1w 2h)\n"}"
 261                                 adb_dnsdeny="${adb_dnsdeny:-"${adb_awk} '{print \"\"\$0\" CNAME .\\n*.\"\$0\" CNAME .\"}'"}"
 262                                 adb_dnsallow="${adb_dnsallow:-"${adb_awk} '{print \"\"\$0\" CNAME rpz-passthru.\\n*.\"\$0\" CNAME rpz-passthru.\"}'"}"
 263                                 adb_dnssafesearch="${adb_dnssafesearch:-"${adb_awk} -v item=\"\$item\" '{type=\"AAAA\";if(match(item,/^([0-9]{1,3}\.){3}[0-9]{1,3}$/)){type=\"A\"}}{print \"\"\$0\" \"type\" \"item\"\"}'"}"
 264                                 adb_dnsstop="${adb_dnsstop:-"* CNAME ."}"
 265                         ;;
 266                         "raw")
 267                                 adb_dnsinotify="${adb_dnsinotify:-"0"}"
 268                                 adb_dnsinstance="${adb_dnsinstance:-"0"}"
 269                                 adb_dnsuser="${adb_dnsuser:-"root"}"
 270                                 adb_dnsdir="${adb_dnsdir:-"/tmp"}"
 271                                 adb_dnsheader="${adb_dnsheader}"
 272                                 adb_dnsdeny="${adb_dnsdeny:-"0"}"
 273                                 adb_dnsallow="${adb_dnsallow:-"1"}"
 274                                 adb_dnssafesearch="${adb_dnssafesearch:-"0"}"
 275                                 adb_dnsstop="${adb_dnsstop:-"0"}"
 276                         ;;
 277                 esac
 278         fi
 279
 280         if [ "${adb_dns}" != "raw" ] && { [ -z "${adb_dns}" ] || [ ! -x "$(command -v "${adb_dns}")" ]; }
 281         then
 282                 f_log "err" "dns backend not found, please set 'adb_dns' manually"
 283         fi
 284
 285         if [ "${adb_dns}" != "raw" ] && { [ "${adb_dnsdir}" = "${adb_tmpbase}" ] || [ "${adb_dnsdir}" = "${adb_backupdir}" ] || \
 286                 [ "${adb_dnsdir}" = "${adb_reportdir}" ] || [ "${adb_dnsdir}" = "${adb_jaildir}" ]; }
 287         then
 288                 f_log "err" "dns directory '${adb_dnsdir}' has been misconfigured, it must not point to the 'adb_tmpbase', 'adb_backupdir', 'adb_reportdir' or 'adb_jaildir'"
 289         fi
 290
 291         if [ "${adb_action}" = "start" ] && [ -z "${adb_trigger}" ]
 292         then
 293                 sleep ${adb_triggerdelay}
 294         fi
 295
 296         if [ "${adb_dns}" != "raw" ] && [ "${adb_action}" != "stop" ]
 297         then
 298                 while [ "${cnt}" -le 30 ]
 299                 do
 300                         dns_up="$(ubus -S call service list "{\"name\":\"${adb_dns}\"}" 2>/dev/null | jsonfilter -l1 -e "@[\"${adb_dns}\"].instances.*.running" 2>/dev/null)"
 301                         if [ "${dns_up}" = "true" ]
 302                         then
 303                                 break
 304                         fi
 305                         sleep 1
 306                         cnt=$((cnt+1))
 307                 done
 308
 309                 if [ -n "${adb_dnsdir}" ] && [ ! -d "${adb_dnsdir}" ]
 310                 then
 311                         mkdir -p "${adb_dnsdir}"
 312                         if [ "${?}" -eq 0 ]
 313                         then
 314                                 f_log "info" "dns backend directory '${adb_dnsdir}' created"
 315                         else
 316                                 f_log "err" "dns backend directory '${adb_dnsdir}' could not be created"
 317                         fi
 318                 fi
 319
 320                 if [ ! -f "${adb_dnsdir}/${adb_dnsfile}" ]
 321                 then
 322                         printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
 323                 fi
 324
 325                 if [ "${dns_up}" != "true" ]
 326                 then
 327                         f_dnsup 4
 328                         if [ "${?}" -ne 0 ]
 329                         then
 330                                 f_log "err" "dns backend '${adb_dns}' not running or executable"
 331                         fi
 332                 fi
 333
 334                 if [ "${adb_backup}" -eq 1 ] && [ -n "${adb_backupdir}" ] && [ ! -d "${adb_backupdir}" ]
 335                 then
 336                         mkdir -p "${adb_backupdir}"
 337                         if [ "${?}" -eq 0 ]
 338                         then
 339                                 f_log "info" "backup directory '${adb_backupdir}' created"
 340                         else
 341                                 f_log "err" "backup backend directory '${adb_backupdir}' could not be created"
 342                         fi
 343                 fi
 344
 345                 if [ -n "${adb_jaildir}" ] && [ ! -d "${adb_jaildir}" ]
 346                 then
 347                         mkdir -p "${adb_jaildir}"
 348                         if [ "${?}" -eq 0 ]
 349                         then
 350                                 f_log "info" "jail directory '${adb_jaildir}' created"
 351                         else
 352                                 f_log "err" "jail directory '${adb_jaildir}' could not be created"
 353                         fi
 354                 fi
 355         fi
 356         f_log "debug" "f_dns    ::: dns: ${adb_dns}, dns_dir: ${adb_dnsdir}, dns_file: ${adb_dnsfile}, dns_user: ${adb_dnsuser}, dns_inotify: ${adb_dnsinotify}, dns_instance: ${adb_dnsinstance}, backup: ${adb_backup}, backup_dir: ${adb_backupdir}, jail_dir: ${adb_jaildir}"
 357 }
 358
 359 # load fetch utility
 360 #
 361 f_fetch()
 362 {
 363         local util utils cnt=0
 364
 365         if [ -z "${adb_fetchutil}" ]
 366         then
 367                 utils="aria2c curl wget uclient-fetch"
 368                 for util in ${utils}
 369                 do
 370                         if { [ "${util}" = "uclient-fetch" ] && [ -n "$(printf "%s" "${adb_packages}" | grep "^libustream-")" ]; } || \
 371                                 { [ "${util}" = "wget" ] && [ -n "$(printf "%s" "${adb_packages}" | grep "^wget -")" ]; } || \
 372                                 [ "${util}" = "curl" ] || [ "${util}" = "aria2c" ]
 373                         then
 374                                 if [ -x "$(command -v "${util}")" ]
 375                                 then
 376                                         adb_fetchutil="${util}"
 377                                         uci_set adblock global adb_fetchutil "${util}"
 378                                         f_uci "adblock"
 379                                         break
 380                                 fi
 381                         fi
 382                 done
 383         elif [ ! -x "$(command -v "${adb_fetchutil}")" ]
 384         then
 385                 unset adb_fetchutil
 386         fi
 387         case "${adb_fetchutil}" in
 388                 "aria2c")
 389                         adb_fetchparm="${adb_fetchparm:-"--timeout=20 --allow-overwrite=true --auto-file-renaming=false --check-certificate=true --dir= -o"}"
 390                 ;;
 391                 "curl")
 392                         adb_fetchparm="${adb_fetchparm:-"--connect-timeout 20 --silent --show-error --location -o"}"
 393                 ;;
 394                 "uclient-fetch")
 395                         adb_fetchparm="${adb_fetchparm:-"--timeout=20 -O"}"
 396                 ;;
 397                 "wget")
 398                         adb_fetchparm="${adb_fetchparm:-"--no-cache --no-cookies --max-redirect=0 --timeout=20 -O"}"
 399                 ;;
 400         esac
 401         if [ -n "${adb_fetchutil}" ] && [ -n "${adb_fetchparm}" ]
 402         then
 403                 adb_fetchutil="$(command -v "${adb_fetchutil}")"
 404         else
 405                 f_log "err" "download utility with SSL support not found, please install 'uclient-fetch' with a 'libustream-*' variant or another download utility like 'wget', 'curl' or 'aria2'"
 406         fi
 407         f_log "debug" "f_fetch  ::: fetch_util: ${adb_fetchutil:-"-"}, fetch_parm: ${adb_fetchparm:-"-"}"
 408 }
 409
 410 # create temporary files, directories and set dependent options
 411 #
 412 f_temp()
 413 {
 414         local cpu core cores
 415
 416         cpu="$(grep -c '^processor' /proc/cpuinfo 2>/dev/null)"
 417         core="$(grep -cm1 '^core id' /proc/cpuinfo 2>/dev/null)"
 418         if [ "${cpu}" -eq 0 ]
 419         then
 420                 cpu=1
 421         fi
 422         if [ "${core}" -eq 0 ]
 423         then
 424                 core=1
 425         fi
 426         cores=$((cpu*core))
 427
 428         if [ -d "${adb_tmpbase}" ]
 429         then
 430                 adb_tmpdir="$(mktemp -p "${adb_tmpbase}" -d)"
 431                 adb_tmpload="$(mktemp -p "${adb_tmpdir}" -tu)"
 432                 adb_tmpfile="$(mktemp -p "${adb_tmpdir}" -tu)"
 433                 adb_srtopts="--temporary-directory=${adb_tmpdir} --compress-program=gzip --batch-size=32 --parallel=${cores}"
 434         else
 435                 f_log "err" "the temp base directory '${adb_tmpbase}' does not exist/is not mounted yet, please create the directory or raise the 'adb_triggerdelay' to defer the adblock start"
 436         fi
 437         if [ ! -s "${adb_pidfile}" ]
 438         then
 439                 printf "%s" "${$}" > "${adb_pidfile}"
 440         fi
 441         f_log "debug" "f_temp   ::: tmp_base: ${adb_tmpbase:-"-"}, tmp_dir: ${adb_tmpdir:-"-"}, cores: ${cores:-"-"}, sort_options: ${adb_srtopts}, pid_file: ${adb_pidfile:-"-"}"
 442 }
 443
 444 # remove temporary files and directories
 445 #
 446 f_rmtemp()
 447 {
 448         if [ -d "${adb_tmpdir}" ]
 449         then
 450                 rm -rf "${adb_tmpdir}"
 451         fi
 452         rm -f "${adb_srcfile}"
 453         > "${adb_pidfile}"
 454         f_log "debug" "f_rmtemp ::: tmp_dir: ${adb_tmpdir:-"-"}, src_file: ${adb_srcfile:-"-"}, pid_file: ${adb_pidfile:-"-"}"
 455 }
 456
 457 # remove dns related files
 458 #
 459 f_rmdns()
 460 {
 461         local status
 462
 463         status="$(ubus -S call service list '{"name":"adblock"}' 2>/dev/null | jsonfilter -l1 -e '@["adblock"].instances.*.running' 2>/dev/null)"
 464         if [ "${adb_dns}" = "raw" ] || { [ -n "${adb_dns}" ] && [ -n "${status}" ]; }
 465         then
 466                 > "${adb_rtfile}"
 467                 if [ "${adb_backup}" -eq 1 ]
 468                 then
 469                         rm -f "${adb_backupdir}/${adb_dnsprefix}".*.gz
 470                 fi
 471                 printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
 472                 f_dnsup 4
 473         fi
 474         f_rmtemp
 475         f_log "debug" "f_rmdns  ::: dns: ${adb_dns}, status: ${status:-"-"}, dns_dir: ${adb_dnsdir}, dns_file: ${adb_dnsfile}, rt_file: ${adb_rtfile}, backup_dir: ${adb_backupdir:-"-"}"
 476 }
 477
 478 # commit uci changes
 479 #
 480 f_uci()
 481 {
 482         local change config="${1}"
 483
 484         if [ -n "${config}" ]
 485         then
 486                 change="$(uci -q changes "${config}" | "${adb_awk}" '{ORS=" "; print $0}')"
 487                 if [ -n "${change}" ]
 488                 then
 489                         uci_commit "${config}"
 490                         case "${config}" in
 491                                 "firewall")
 492                                         "/etc/init.d/firewall" reload >/dev/null 2>&1
 493                                 ;;
 494                                 "resolver")
 495                                         printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
 496                                         f_count
 497                                         f_jsnup "running"
 498                                         "/etc/init.d/${adb_dns}" reload >/dev/null 2>&1
 499                                 ;;
 500                         esac
 501                 fi
 502                 f_log "debug" "f_uci    ::: config: ${config}, change: ${change}"
 503         fi
 504 }
 505
 506 # get list counter
 507 #
 508 f_count()
 509 {
 510         local file mode="${1}" name="${2}"
 511
 512         adb_cnt=0
 513         case "${mode}" in
 514                 "blacklist")
 515                         if [ -s "${adb_tmpfile}.${name}" ]
 516                         then
 517                                 adb_cnt="$(wc -l 2>/dev/null < "${adb_tmpfile}.${name}")"
 518                         fi
 519                 ;;
 520                 "whitelist")
 521                         if [ -s "${adb_tmpdir}/tmp.raw.${name}" ]
 522                         then
 523                                 adb_cnt="$(wc -l 2>/dev/null < "${adb_tmpdir}/tmp.raw.${name}")"
 524                                 rm -f "${adb_tmpdir}/tmp.raw.${name}"
 525                         fi
 526                 ;;
 527                 "safesearch")
 528                         if [ -s "${adb_tmpdir}/tmp.safesearch.${name}" ]
 529                         then
 530                                 adb_cnt="$(wc -l 2>/dev/null < "${adb_tmpdir}/tmp.safesearch.${name}")"
 531                         fi
 532                 ;;
 533                 "merge")
 534                         if [ -s "${adb_tmpdir}/${adb_dnsfile}" ]
 535                         then
 536                                 adb_cnt="$(wc -l 2>/dev/null < "${adb_tmpdir}/${adb_dnsfile}")"
 537                         fi
 538                 ;;
 539                 "download"|"backup"|"restore")
 540                         if [ -s "${src_tmpfile}" ]
 541                         then
 542                                 adb_cnt="$(wc -l 2>/dev/null < "${src_tmpfile}")"
 543                         fi
 544                 ;;
 545                 "final")
 546                         if [ -s "${adb_dnsdir}/${adb_dnsfile}" ]
 547                         then
 548                                 adb_cnt="$(wc -l 2>/dev/null < "${adb_dnsdir}/${adb_dnsfile}")"
 549                                 if [ -s "${adb_tmpdir}/tmp.add.whitelist" ]
 550                                 then
 551                                         adb_cnt=$((adb_cnt-$(wc -l 2>/dev/null < "${adb_tmpdir}/tmp.add.whitelist")))
 552                                 fi
 553                                 for file in "${adb_tmpdir}/tmp.safesearch".*
 554                                 do
 555                                         if [ -r "${file}" ]
 556                                         then
 557                                                 adb_cnt=$((adb_cnt-$(wc -l 2>/dev/null < "${file}")))
 558                                         fi
 559                                 done
 560                                 if [ -n "${adb_dnsheader}" ]
 561                                 then
 562                                         adb_cnt=$(((adb_cnt-$(printf "${adb_dnsheader}" | grep -c "^"))/2))
 563                                 fi
 564                         fi
 565                 ;;
 566         esac
 567 }
 568
 569 # set external config options
 570 #
 571 f_extconf()
 572 {
 573         local config config_dir config_file port fwcfg
 574
 575         case "${adb_dns}" in
 576                 "dnsmasq")
 577                         config="dhcp"
 578                         config_dir="$(uci_get dhcp "@dnsmasq[${adb_dnsinstance}]" confdir | grep -Fo "${adb_dnsdir}")"
 579                         if [ "${adb_enabled}" -eq 1 ] && [ -z "${config_dir}" ]
 580                         then
 581                                 uci_set dhcp "@dnsmasq[${adb_dnsinstance}]" confdir "${adb_dnsdir}" 2>/dev/null
 582                         fi
 583                 ;;
 584                 "kresd")
 585                         config="resolver"
 586                         config_file="$(uci_get resolver kresd rpz_file | grep -Fo "${adb_dnsdir}/${adb_dnsfile}")"
 587                         if [ "${adb_enabled}" -eq 1 ] && [ -z "${config_file}" ]
 588                         then
 589                                 uci -q add_list resolver.kresd.rpz_file="${adb_dnsdir}/${adb_dnsfile}"
 590                         elif [ "${adb_enabled}" -eq 0 ] && [ -n "${config_file}" ]
 591                         then
 592                                 uci -q del_list resolver.kresd.rpz_file="${adb_dnsdir}/${adb_dnsfile}"
 593                         fi
 594                 ;;
 595         esac
 596         f_uci "${config}"
 597
 598         config="firewall"
 599         fwcfg="$(uci -qNX show "${config}")"
 600         if [ "${adb_enabled}" -eq 1 ] && [ "${adb_forcedns}" -eq 1 ] && \
 601                 [ "$(/etc/init.d/firewall enabled; printf "%u" ${?})" -eq 0 ]
 602         then
 603                 for port in ${adb_portlist}
 604                 do
 605                         if [ -z "$(printf "%s" "${fwcfg}" | grep -Fo -m1 "adblock_dns_${port}")" ]
 606                         then
 607                                 uci -q batch <<-EOC
 608                                         set firewall."adblock_dns_${port}"="redirect"
 609                                         set firewall."adblock_dns_${port}".name="Adblock DNS, port ${port}"
 610                                         set firewall."adblock_dns_${port}".src="lan"
 611                                         set firewall."adblock_dns_${port}".proto="tcp udp"
 612                                         set firewall."adblock_dns_${port}".src_dport="${port}"
 613                                         set firewall."adblock_dns_${port}".dest_port="${port}"
 614                                         set firewall."adblock_dns_${port}".target="DNAT"
 615                                 EOC
 616                         fi
 617                 done
 618         elif [ "${adb_enabled}" -eq 0 ] || [ "${adb_forcedns}" -eq 0 ]
 619         then
 620                 for port in ${adb_portlist}
 621                 do
 622                         if [ -n "$(printf "%s" "${fwcfg}" | grep -Fo -m1 "adblock_dns_${port}")" ]
 623                         then
 624                                 uci_remove firewall "adblock_dns_${port}"
 625                         fi
 626                 done
 627         fi
 628         f_uci "${config}"
 629 }
 630
 631 # restart dns backend
 632 #
 633 f_dnsup()
 634 {
 635         local dns_service dns_up dns_pid dns_procfile restart_rc cnt=0 out_rc=4 in_rc="${1:-0}"
 636
 637         if [ "${adb_dns}" = "raw" ] || { [ "${in_rc}" -eq 0 ] && [ "${adb_dnsinotify}" -eq 1 ]; }
 638         then
 639                 out_rc=0
 640         else
 641                 "/etc/init.d/${adb_dns}" restart >/dev/null 2>&1
 642                 restart_rc="${?}"
 643         fi
 644         if [ "${restart_rc}" = "0" ]
 645         then
 646                 while [ "${cnt}" -le "${adb_dnstimeout}" ]
 647                 do
 648                         dns_service="$(ubus -S call service list "{\"name\":\"${adb_dns}\"}")"
 649                         dns_up="$(printf "%s" "${dns_service}" | jsonfilter -l1 -e "@[\"${adb_dns}\"].instances.*.running")"
 650                         dns_pid="$(printf "%s" "${dns_service}" | jsonfilter -l1 -e "@[\"${adb_dns}\"].instances.*.pid")"
 651                         dns_procfile="$(ls -l "/proc/${dns_pid}/fd" 2>/dev/null | grep -Fo "${adb_dnsdir}/${adb_dnsfile}")"
 652                         if [ "${dns_up}" = "true" ] && [ -n "${dns_pid}" ] && [ -z "${dns_procfile}" ]
 653                         then
 654                                 if [ -x "${adb_lookupcmd}" ] && [ "${adb_lookupdomain}" != "false" ]
 655                                 then
 656                                         "${adb_lookupcmd}" "${adb_lookupdomain}" >/dev/null 2>&1
 657                                         if [ "${?}" -eq 0 ]
 658                                         then
 659                                                 out_rc=0
 660                                                 break
 661                                         fi
 662                                 else
 663                                         sleep ${adb_dnstimeout}
 664                                         cnt=${adb_dnstimeout}
 665                                         out_rc=0
 666                                         break
 667                                 fi
 668                         fi
 669                         cnt=$((cnt+1))
 670                         sleep 1
 671                 done
 672         fi
 673         f_log "debug" "f_dnsup  ::: lookup_util: ${adb_lookupcmd:-"-"}, lookup_domain: ${adb_lookupdomain:-"-"}, restart_rc: ${restart_rc:-"-"}, dns_timeout: ${adb_dnstimeout}, dns_cnt: ${cnt}, in_rc: ${in_rc}, out_rc: ${out_rc}"
 674         return "${out_rc}"
 675 }
 676
 677 # backup/restore/remove blocklists
 678 #
 679 f_list()
 680 {
 681         local hold file rset item array safe_url safe_ips safe_cname safe_domains out_rc mode="${1}" src_name="${2:-"${src_name}"}" in_rc="${src_rc:-0}" cnt=1 ffiles="-maxdepth 1 -name ${adb_dnsprefix}.*.gz"
 682
 683         case "${mode}" in
 684                 "blacklist"|"whitelist")
 685                         src_name="${mode}"
 686                         if [ "${src_name}" = "blacklist" ] && [ -s "${adb_blacklist}" ]
 687                         then
 688                                 rset="/^([[:alnum:]_-]{1,63}\\.)+[[:alpha:]]+([[:space:]]|$)/{print tolower(\$1)}"
 689                                 "${adb_awk}" "${rset}" "${adb_blacklist}" | \
 690                                 "${adb_awk}" 'BEGIN{FS="."}{for(f=NF;f>1;f--)printf "%s.",$f;print $1}' > "${adb_tmpdir}/tmp.raw.${src_name}"
 691                                 sort ${adb_srtopts} -u "${adb_tmpdir}/tmp.raw.${src_name}" 2>/dev/null > "${adb_tmpfile}.${src_name}"
 692                                 out_rc="${?}"
 693                                 rm -f "${adb_tmpdir}/tmp.raw.${src_name}"
 694                         elif [ "${src_name}" = "whitelist" ] && [ -s "${adb_whitelist}" ]
 695                         then
 696                                 rset="/^([[:alnum:]_-]{1,63}\\.)+[[:alpha:]]+([[:space:]]|$)/{print tolower(\$1)}"
 697                                 "${adb_awk}" "${rset}" "${adb_whitelist}" > "${adb_tmpdir}/tmp.raw.${src_name}"
 698                                 out_rc="${?}"
 699                                 if [ "${out_rc}" -eq 0 ]
 700                                 then
 701                                         rset="/^([[:alnum:]_-]{1,63}\\.)+[[:alpha:]]+([[:space:]]|$)/{gsub(\"\\\\.\",\"\\\\.\",\$1);print tolower(\"^(|.*\\\\.)\"\$1\"$\")}"
 702                                         "${adb_awk}" "${rset}" "${adb_tmpdir}/tmp.raw.${src_name}" > "${adb_tmpdir}/tmp.rem.${src_name}"
 703                                         out_rc="${?}"
 704                                         if [ "${out_rc}" -eq 0 ] && [ "${adb_dnsallow}" != "1" ]
 705                                         then
 706                                                 eval "${adb_dnsallow}" "${adb_tmpdir}/tmp.raw.${src_name}" > "${adb_tmpdir}/tmp.add.${src_name}"
 707                                                 out_rc="${?}"
 708                                                 if [ "${out_rc}" -eq 0 ] && [ "${adb_jail}" = "1" ] && [ "${adb_dnsstop}" != "0" ]
 709                                                 then
 710                                                         > "${adb_jaildir}/${adb_dnsjail}"
 711                                                         if [ -n "${adb_dnsheader}" ]
 712                                                         then
 713                                                                 printf "${adb_dnsheader}" >> "${adb_jaildir}/${adb_dnsjail}"
 714                                                         fi
 715                                                         cat "${adb_tmpdir}/tmp.add.${src_name}" >> "${adb_jaildir}/${adb_dnsjail}"
 716                                                         printf "%s\n" "${adb_dnsstop}" >> "${adb_jaildir}/${adb_dnsjail}"
 717                                                 fi
 718                                         fi
 719                                 fi
 720                         fi
 721                 ;;
 722                 "safesearch")
 723                         case "${src_name}" in
 724                                 "google")
 725                                         rset="/^(\\.[[:alnum:]_-]{1,63}\\.)+[[:alpha:]]+([[:space:]]|$)/{printf \"%s\n%s\n\",tolower(\"www\"\$1),tolower(substr(\$1,2,length(\$1)))}"
 726                                         safe_url="https://www.google.com/supported_domains"
 727                                         safe_ips="216.239.38.120 2001:4860:4802:32::78"
 728                                         safe_cname="forcesafesearch.google.com"
 729                                         safe_domains="${adb_tmpdir}/tmp.load.safesearch.${src_name}"
 730                                         if [ "${adb_backup}" -eq 1 ] && [ -s "${adb_backupdir}/safesearch.${src_name}.gz" ]
 731                                         then
 732                                                 zcat "${adb_backupdir}/safesearch.${src_name}.gz" > "${safe_domains}"
 733                                                 out_rc="${?}"
 734                                         else
 735                                                 "${adb_fetchutil}" ${adb_fetchparm} "${safe_domains}" "${safe_url}" 2>/dev/null
 736                                                 out_rc="${?}"
 737                                                 if [ "${adb_backup}" -eq 1 ] && [ "${out_rc}" -eq 0 ]
 738                                                 then
 739                                                         gzip -cf "${safe_domains}" > "${adb_backupdir}/safesearch.${src_name}.gz"
 740                                                 fi
 741                                         fi
 742                                         if [ "${out_rc}" -eq 0 ]
 743                                         then
 744                                                 "${adb_awk}" "${rset}" "${safe_domains}" > "${adb_tmpdir}/tmp.raw.safesearch.${src_name}"
 745                                                 out_rc="${?}"
 746                                         fi
 747                                 ;;
 748                                 "bing")
 749                                         safe_ips="204.79.197.220 ::FFFF:CC4F:C5DC"
 750                                         safe_cname="strict.bing.com"
 751                                         safe_domains="www.bing.com"
 752                                         printf "%s\n" ${safe_domains} > "${adb_tmpdir}/tmp.raw.safesearch.${src_name}"
 753                                         out_rc="${?}"
 754                                 ;;
 755                                 "duckduckgo")
 756                                         safe_ips="50.16.250.179 54.208.102.2 52.204.96.252"
 757                                         safe_cname="safe.duckduckgo.com"
 758                                         safe_domains="duckduckgo.com"
 759                                         printf "%s\n" ${safe_domains} > "${adb_tmpdir}/tmp.raw.safesearch.${src_name}"
 760                                         out_rc="${?}"
 761                                 ;;
 762                                 "pixabay")
 763                                         safe_ips="104.18.82.97 2606:4700::6812:8d57 2606:4700::6812:5261"
 764                                         safe_cname="safesearch.pixabay.com"
 765                                         safe_domains="pixabay.com"
 766                                         printf "%s\n" ${safe_domains} > "${adb_tmpdir}/tmp.raw.safesearch.${src_name}"
 767                                         out_rc="${?}"
 768                                 ;;
 769                                 "yandex")
 770                                         safe_ips="213.180.193.56"
 771                                         safe_cname="familysearch.yandex.ru"
 772                                         safe_domains="ya.ru yandex.ru yandex.com yandex.com.tr yandex.ua yandex.by yandex.ee yandex.lt yandex.lv yandex.md yandex.uz yandex.tm yandex.tj yandex.az"
 773                                         printf "%s\n" ${safe_domains} > "${adb_tmpdir}/tmp.raw.safesearch.${src_name}"
 774                                         out_rc="${?}"
 775                                 ;;
 776                                 "youtube")
 777                                         if [ "${adb_safesearchmod}" -eq 0 ]
 778                                         then
 779                                                 safe_ips="216.239.38.120 2001:4860:4802:32::78"
 780                                                 safe_cname="restrict.youtube.com"
 781                                         else
 782                                                 safe_ips="216.239.38.119 2001:4860:4802:32::77"
 783                                                 safe_cname="restrictmoderate.youtube.com"
 784                                         fi
 785                                         safe_domains="www.youtube.com m.youtube.com youtubei.googleapis.com youtube.googleapis.com www.youtube-nocookie.com"
 786                                         printf "%s\n" ${safe_domains} > "${adb_tmpdir}/tmp.raw.safesearch.${src_name}"
 787                                         out_rc="${?}"
 788                                 ;;
 789                         esac
 790                         if [ "${out_rc}" -eq 0 ]
 791                         then
 792                                 > "${adb_tmpdir}/tmp.safesearch.${src_name}"
 793                                 if [ "${adb_dns}" = "named" ]
 794                                 then
 795                                         array="${safe_cname}"
 796                                 else
 797                                         array="${safe_ips}"
 798                                 fi
 799                                 for item in ${array}
 800                                 do
 801                                         eval "${adb_dnssafesearch}" "${adb_tmpdir}/tmp.raw.safesearch.${src_name}" >> "${adb_tmpdir}/tmp.safesearch.${src_name}"
 802                                         if [ "${?}" -ne 0 ]
 803                                         then
 804                                                 rm -f "${adb_tmpdir}/tmp.safesearch.${src_name}"
 805                                                 break
 806                                         fi
 807                                 done
 808                                 out_rc="${?}"
 809                                 rm -f "${adb_tmpdir}/tmp.raw.safesearch.${src_name}"
 810                         fi
 811                 ;;
 812                 "backup")
 813                         (
 814                                 gzip -cf "${src_tmpfile}" > "${adb_backupdir}/${adb_dnsprefix}.${src_name}.gz"
 815                                 out_rc="${?}"
 816                         )&
 817                 ;;
 818                 "restore")
 819                         if [ -n "${src_name}" ] && [ -s "${adb_backupdir}/${adb_dnsprefix}.${src_name}.gz" ]
 820                         then
 821                                 zcat "${adb_backupdir}/${adb_dnsprefix}.${src_name}.gz" > "${src_tmpfile}"
 822                                 out_rc="${?}"
 823                         elif [ -z "${src_name}" ]
 824                         then
 825                                 for file in "${adb_backupdir}/${adb_dnsprefix}".*.gz
 826                                 do
 827                                         if [ -r "${file}" ]
 828                                         then
 829                                                 name="${file##*/}"
 830                                                 name="${name%.*}"
 831                                                 zcat "${file}" > "${adb_tmpfile}.${name}" &
 832                                                 hold=$((cnt%adb_maxqueue))
 833                                                 if [ "${hold}" -eq 0 ]
 834                                                 then
 835                                                         wait
 836                                                 fi
 837                                                 cnt=$((cnt+1))
 838                                         fi
 839                                 done
 840                                 wait
 841                                 out_rc="${?}"
 842                         else
 843                                 out_rc=4
 844                         fi
 845                         if [ "${adb_action}" != "start" ] && [ "${adb_action}" != "resume" ] && [ -n "${src_name}" ] && [ "${out_rc}" -ne 0 ]
 846                         then
 847                                 adb_sources="${adb_sources/${src_name}}"
 848                         fi
 849                 ;;
 850                 "remove")
 851                         if [ "${adb_backup}" -eq 1 ]
 852                         then
 853                                 rm "${adb_backupdir}/${adb_dnsprefix}.${src_name}.gz" 2>/dev/null
 854                         fi
 855                         out_rc="${?}"
 856                         adb_sources="${adb_sources/${src_name}}"
 857                 ;;
 858                 "merge")
 859                         if [ "${adb_backup}" -eq 1 ]
 860                         then
 861                                 for src_name in ${adb_sources}
 862                                 do
 863                                         ffiles="${ffiles} -a ! -name ${adb_dnsprefix}.${src_name}.gz"
 864                                 done
 865                                 if [ "${adb_safesearch}" -eq 1 ] && [ "${adb_dnssafesearch}" != "0" ]
 866                                 then
 867                                         ffiles="${ffiles} -a ! -name safesearch.google.gz"
 868                                 fi
 869                                 find "${adb_backupdir}" ${ffiles} -print0 2>/dev/null | xargs -0 rm 2>/dev/null
 870                         fi
 871                         unset src_name
 872                         sort ${adb_srtopts} -mu "${adb_tmpfile}".* 2>/dev/null > "${adb_tmpdir}/${adb_dnsfile}"
 873                         out_rc="${?}"
 874                         rm -f "${adb_tmpfile}".*
 875                 ;;
 876                 "final")
 877                         unset src_name
 878                         if [ -n "${adb_dnsheader}" ]
 879                         then
 880                                 printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
 881                         else
 882                                 > "${adb_dnsdir}/${adb_dnsfile}"
 883                         fi
 884                         if [ -s "${adb_tmpdir}/tmp.add.whitelist" ]
 885                         then
 886                                 cat "${adb_tmpdir}/tmp.add.whitelist" >> "${adb_dnsdir}/${adb_dnsfile}"
 887                         fi
 888                         for file in "${adb_tmpdir}/tmp.safesearch".*
 889                         do
 890                                 if [ -r "${file}" ]
 891                                 then
 892                                         cat "${file}" >> "${adb_dnsdir}/${adb_dnsfile}"
 893                                 fi
 894                         done
 895                         if [ "${adb_dnsdeny}" != "0" ]
 896                         then
 897                                 eval "${adb_dnsdeny}" "${adb_tmpdir}/${adb_dnsfile}" >> "${adb_dnsdir}/${adb_dnsfile}"
 898                         else
 899                                 mv "${adb_tmpdir}/${adb_dnsfile}" "${adb_dnsdir}/${adb_dnsfile}"
 900                         fi
 901                         out_rc="${?}"
 902                 ;;
 903         esac
 904         f_count "${mode}" "${src_name}"
 905         out_rc="${out_rc:-"${in_rc}"}"
 906         f_log "debug" "f_list   ::: name: ${src_name:-"-"}, mode: ${mode}, cnt: ${adb_cnt}, in_rc: ${in_rc}, out_rc: ${out_rc}"
 907         return "${out_rc}"
 908 }
 909
 910 # top level domain compression
 911 #
 912 f_tld()
 913 {
 914         local cnt cnt_tld source="${1}" temp_tld="${1}.tld"
 915
 916         "${adb_awk}" '{if(NR==1){tld=$NF};while(getline){if(index($NF,tld".")==0){print tld;tld=$NF}}print tld}' "${source}" | \
 917         "${adb_awk}" 'BEGIN{FS="."}{for(f=NF;f>1;f--)printf "%s.",$f;print $1}' > "${temp_tld}"
 918         if [ "${?}" -eq 0 ]
 919         then
 920                 mv -f "${temp_tld}" "${source}"
 921                 cnt_tld="$(wc -l 2>/dev/null < "${source}")"
 922         else
 923                 rm -f "${temp_tld}"
 924         fi
 925         f_log "debug" "f_tld    ::: source: ${source}, cnt: ${adb_cnt:-"-"}, cnt_tld: ${cnt_tld:-"-"}"
 926 }
 927
 928 # suspend/resume adblock processing
 929 #
 930 f_switch()
 931 {
 932         local status entry done="false" mode="${1}"
 933
 934         json_load_file "${adb_rtfile}" >/dev/null 2>&1
 935         json_select "data" >/dev/null 2>&1
 936         json_get_var status "adblock_status"
 937         if [ "${mode}" = "suspend" ] && [ "${status}" = "enabled" ]
 938         then
 939                 f_env
 940                 printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
 941                 f_count
 942                 done="true"
 943         elif [ "${mode}" = "resume" ] && [ "${status}" = "paused" ]
 944         then
 945                 f_env
 946                 f_main
 947                 done="true"
 948         fi
 949         if [ "${done}" = "true" ]
 950         then
 951                 if [ "${mode}" = "suspend" ]
 952                 then
 953                         f_bgserv "stop"
 954                         f_dnsup
 955                 fi
 956                 if [ "${mode}" = "resume" ]
 957                 then
 958                         f_bgserv "start"
 959                 fi
 960                 f_jsnup "${mode}"
 961                 f_log "info" "${mode} adblock processing"
 962         fi
 963         f_rmtemp
 964 }
 965
 966 # query blocklist for certain (sub-)domains
 967 #
 968 f_query()
 969 {
 970         local search result prefix suffix field query_start query_end query_timeout=30 domain="${1}" tld="${1#*.}"
 971
 972         if [ -z "${domain}" ] || [ "${domain}" = "${tld}" ]
 973         then
 974                 printf "%s\\n" "::: invalid input, please submit a single (sub-)domain :::"
 975         else
 976                 case "${adb_dns}" in
 977                         "dnsmasq")
 978                                 prefix=".*[\\/\\.]"
 979                                 suffix="(\\/)"
 980                                 field=2
 981                         ;;
 982                         "unbound")
 983                                 prefix=".*[\"\\.]"
 984                                 suffix="(static)"
 985                                 field=3
 986                         ;;
 987                         "named")
 988                                 prefix="[^\\*].*[\\.]"
 989                                 suffix="( \\.)"
 990                                 field=1
 991                         ;;
 992                         "kresd")
 993                                 prefix="[^\\*].*[\\.]"
 994                                 suffix="( \\.)"
 995                                 field=1
 996                         ;;
 997                         "raw")
 998                                 prefix=".*[\\.]"
 999                                 suffix=""
1000                                 field=1
1001                         ;;
1002                 esac
1003                 query_start="$(date "+%s")"
1004                 if [ "${adb_dnsfilereset}" -eq 0 ]
1005                 then
1006                         while [ "${domain}" != "${tld}" ]
1007                         do
1008                                 search="${domain//[+*~%\$&\"\']/}"
1009                                 search="${search//./\\.}"
1010                                 result="$("${adb_awk}" -F '/|\"|\t| ' "/^(${search}|${prefix}+${search}.*${suffix})$/{i++;if(i<=9){printf \"  + %s\\n\",\$${field}}else if(i==10){printf \"  + %s\\n\",\"[...]\";exit}}" "${adb_dnsdir}/${adb_dnsfile}")"
1011                                 printf "%s\\n%s\\n%s\\n" ":::" "::: domain '${domain}' in active blocklist" ":::"
1012                                 printf "%s\\n\\n" "${result:-"  - no match"}"
1013                                 domain="${tld}"
1014                                 tld="${domain#*.}"
1015                         done
1016                 fi
1017                 if [ "${adb_backup}" -eq 1 ] && [ -d "${adb_backupdir}" ]
1018                 then
1019                         search="${1//[+*~%\$&\"\']/}"
1020                         search="${search//./\\.}"
1021                         printf "%s\\n%s\\n%s\\n" ":::" "::: domain '${1}' in backups and black-/whitelist" ":::"
1022                         for file in "${adb_backupdir}/${adb_dnsprefix}".*.gz "${adb_blacklist}" "${adb_whitelist}"
1023                         do
1024                                 suffix="${file##*.}"
1025                                 if [ "${suffix}" = "gz" ]
1026                                 then
1027                                         zcat "${file}" 2>/dev/null | \
1028                                         "${adb_awk}" 'BEGIN{FS="."}{for(f=NF;f>1;f--)printf "%s.",$f;print $1}' | "${adb_awk}" -v f="${file##*/}" "BEGIN{rc=1};/^($search|.*\\.${search})$/{i++;if(i<=3){printf \"  + %-30s%s\\n\",f,\$1;rc=0}else if(i==4){printf \"  + %-30s%s\\n\",f,\"[...]\"}};END{exit rc}"
1029                                 else
1030                                         "${adb_awk}" -v f="${file##*/}" "BEGIN{rc=1};/^($search|.*\\.${search})$/{i++;if(i<=3){printf \"  + %-30s%s\\n\",f,\$1;rc=0}else if(i==4){printf \"  + %-30s%s\\n\",f,\"[...]\"}};END{exit rc}" "${file}"
1031                                 fi
1032                                 if [ "${?}" -eq 0 ]
1033                                 then
1034                                         result="true"
1035                                         query_end="$(date "+%s")"
1036                                         if [ "$((query_end-query_start))" -gt "${query_timeout}" ]
1037                                         then
1038                                                 printf "%s\\n\\n" "  - [...]"
1039                                                 break
1040                                         fi
1041                                 fi
1042                         done
1043                         if [ "${result}" != "true" ]
1044                         then
1045                                 printf "%s\\n\\n" "  - no match"
1046                         fi
1047                 fi
1048         fi
1049 }
1050
1051 # update runtime information
1052 #
1053 f_jsnup()
1054 {
1055         local runtime utils memory bg_pid status="${1:-"enabled"}"
1056
1057         case "${status}" in
1058                 "enabled"|"error")
1059                         adb_endtime="$(date "+%s")"
1060                         memory="$("${adb_awk}" '/^MemTotal|^MemFree|^MemAvailable/{ORS="/"; print int($2/1000)}' "/proc/meminfo" 2>/dev/null | "${adb_awk}" '{print substr($0,1,length($0)-1)}')"
1061                         if [ "$(( (adb_endtime-adb_starttime)/60 ))" -lt 60 ]
1062                         then
1063                                 runtime="${adb_action}, $(( (adb_endtime-adb_starttime)/60 ))m $(( (adb_endtime-adb_starttime)%60 ))s, ${memory:-0}, $(date "+%d.%m.%Y %H:%M:%S")"
1064                         else
1065                                 runtime="${adb_action}, n/a, ${memory:-0}, $(date "+%d.%m.%Y %H:%M:%S")"
1066                         fi
1067                         if [ "${status}" = "error" ]
1068                         then
1069                                 adb_cnt=0
1070                         fi
1071                 ;;
1072                 "suspend")
1073                         status="paused"
1074                 ;;
1075                 "resume")
1076                         status=""
1077                 ;;
1078         esac
1079         json_load_file "${adb_rtfile}" >/dev/null 2>&1
1080         json_select "data" >/dev/null 2>&1
1081         if [ "${?}" -eq 0 ]
1082         then
1083                 if [ -z "${adb_fetchutil}" ] || [ -z "${adb_awk}" ]
1084                 then
1085                         json_get_var utils "utilities"
1086                 else
1087                         utils="${adb_fetchutil}, ${adb_awk}"
1088                 fi
1089                 if [ -z "${adb_cnt}" ]
1090                 then
1091                         json_get_var adb_cnt "blocked_domains"
1092                         adb_cnt="${adb_cnt%% *}"
1093                 fi
1094                 if [ -z "${runtime}" ]
1095                 then
1096                         json_get_var runtime "last_run"
1097                 fi
1098         fi
1099         > "${adb_rtfile}"
1100         json_load_file "${adb_rtfile}" >/dev/null 2>&1
1101         json_init
1102         json_add_object "data"
1103         json_add_string "adblock_status" "${status:-"enabled"}"
1104         json_add_string "adblock_version" "${adb_ver}"
1105         json_add_string "blocked_domains" "${adb_cnt:-0}"
1106         json_add_array "active_sources"
1107         for entry in ${adb_sources}
1108         do
1109                 json_add_object
1110                 json_add_string "source" "${entry}"
1111                 json_close_object
1112         done
1113         json_close_array
1114         json_add_string "dns_backend" "${adb_dns:-"-"}, ${adb_dnsdir:-"-"}"
1115         json_add_string "run_utils" "${utils:-"-"}"
1116         json_add_string "run_ifaces" "trigger: ${adb_trigger:-"-"}, report: ${adb_repiface:-"-"}"
1117         json_add_string "run_directories" "base: ${adb_tmpbase}, backup: ${adb_backupdir}, report: ${adb_reportdir}, jail: ${adb_jaildir}"
1118         json_add_string "run_flags" "backup: ${adb_backup}, reset: ${adb_dnsfilereset}, flush: ${adb_dnsflush}, force: ${adb_forcedns}, search: ${adb_safesearch}, report: ${adb_report}, mail: ${adb_mail}, jail: ${adb_jail}"
1119         json_add_string "last_run" "${runtime:-"-"}"
1120         json_add_string "system" "${adb_sysver}"
1121         json_close_object
1122         json_dump > "${adb_rtfile}"
1123
1124         if [ "${adb_mail}" -eq 1 ] && [ -x "${adb_mailservice}" ] && \
1125                 { [ "${status}" = "error" ] || { [ "${status}" = "enabled" ] && [ "${adb_cnt}" -le "${adb_mailcnt}" ]; } }
1126         then
1127                 ( "${adb_mailservice}" "${adb_ver}" >/dev/null 2>&1 )&
1128                 bg_pid="${!}"
1129         fi
1130         f_log "debug" "f_jsnup  ::: status: ${status:-"-"}, cnt: ${adb_cnt}, mail: ${adb_mail}, mail_service: ${adb_mailservice}, mail_cnt: ${adb_mailcnt}, mail_pid: ${bg_pid:-"-"}"
1131 }
1132
1133 # write to syslog
1134 #
1135 f_log()
1136 {
1137         local class="${1}" log_msg="${2}"
1138
1139         if [ -n "${log_msg}" ] && { [ "${class}" != "debug" ] || [ "${adb_debug}" -eq 1 ]; }
1140         then
1141                 if [ -x "${adb_loggercmd}" ]
1142                 then
1143                         "${adb_loggercmd}" -p "${class}" -t "adblock-${adb_ver}[${$}]" "${log_msg}"
1144                 else
1145                         printf "%s %s %s\\n" "${class}" "adblock-${adb_ver}[${$}]" "${log_msg}"
1146                 fi
1147                 if [ "${class}" = "err" ]
1148                 then
1149                         f_rmdns
1150                         f_bgserv "stop"
1151                         f_jsnup "error"
1152                         exit 1
1153                 fi
1154         fi
1155 }
1156
1157 # start ubus monitor service to trace dns backend events
1158 #
1159 f_bgserv()
1160 {
1161         local bg_pid status="${1}"
1162
1163         bg_pid="$(pgrep -f "^/bin/sh ${adb_ubusservice}.*|^/bin/ubus -S -M r -m invoke monitor|^grep -qF \"method\":\"set\",\"data\":\\{\"name\":\"${adb_dns}\"" | "${adb_awk}" '{ORS=" "; print $1}')"
1164         if [ "${adb_dns}" != "raw" ] && [ -z "${bg_pid}" ] && [ "${status}" = "start" ] \
1165                 && [ -x "${adb_ubusservice}" ] && [ "${adb_dnsfilereset}" -eq 1 ]
1166         then
1167                 ( "${adb_ubusservice}" "${adb_ver}" & )
1168         elif [ -n "${bg_pid}" ] && [ "${status}" = "stop" ]
1169         then
1170                 kill -HUP "${bg_pid}" 2>/dev/null
1171         fi
1172         f_log "debug" "f_bgserv ::: status: ${status:-"-"}, bg_pid: ${bg_pid:-"-"}, dns_filereset: ${adb_dnsfilereset:-"-"}, ubus_service: ${adb_ubusservice:-"-"}"
1173 }
1174
1175 # main function for blocklist processing
1176 #
1177 f_main()
1178 {
1179         local src_tmpload src_tmpfile src_name src_rset src_url src_log src_arc src_cat src_item src_list src_entries src_suffix src_rc entry keylist memory cnt=1
1180
1181         memory="$("${adb_awk}" '/^MemTotal|^MemFree|^MemAvailable/{ORS="/"; print int($2/1000)}' "/proc/meminfo" 2>/dev/null | "${adb_awk}" '{print substr($0,1,length($0)-1)}')"
1182         f_log "debug" "f_main   ::: memory: ${memory:-0}, max_queue: ${adb_maxqueue}, safe_search: ${adb_safesearch}, force_dns: ${adb_forcedns}, awk: ${adb_awk}"
1183
1184         # white- and blacklist preparation
1185         #
1186         for entry in ${adb_locallist}
1187         do
1188                 ( f_list "${entry}" "${entry}" )&
1189         done
1190
1191         # safe search preparation
1192         #
1193         if [ "${adb_safesearch}" -eq 1 ] && [ "${adb_dnssafesearch}" != "0" ]
1194         then
1195                 if [ -z "${adb_safesearchlist}" ]
1196                 then
1197                         adb_safesearchlist="google bing duckduckgo pixabay yandex youtube"
1198                 fi
1199                 for entry in ${adb_safesearchlist}
1200                 do
1201                         ( f_list safesearch "${entry}" )&
1202                 done
1203         fi
1204         wait
1205
1206         # main loop
1207         #
1208         for src_name in ${adb_sources}
1209         do
1210                 json_select "${src_name}" >/dev/null 2>&1
1211                 if [ "${?}" -ne 0 ]
1212                 then
1213                         adb_sources="${adb_sources/${src_name}}"
1214                         continue
1215                 fi
1216                 json_get_var src_url "url" >/dev/null 2>&1
1217                 json_get_var src_rset "rule" >/dev/null 2>&1
1218                 json_get_values src_cat "categories" >/dev/null 2>&1
1219                 json_select ..
1220                 src_tmpload="${adb_tmpload}.${src_name}.load"
1221                 src_tmpsort="${adb_tmpload}.${src_name}.sort"
1222                 src_tmpfile="${adb_tmpfile}.${src_name}"
1223                 src_rc=4
1224
1225                 # basic pre-checks
1226                 #
1227                 if [ -z "${src_url}" ] || [ -z "${src_rset}" ]
1228                 then
1229                         f_list remove
1230                         continue
1231                 fi
1232
1233                 # backup mode
1234                 #
1235                 if [ "${adb_backup}" -eq 1 ] && { [ "${adb_action}" = "start" ] || [ "${adb_action}" = "resume" ]; }
1236                 then
1237                         f_list restore
1238                         if [ "${?}" -eq 0 ] && [ -s "${src_tmpfile}" ]
1239                         then
1240                                 continue
1241                         fi
1242                 fi
1243
1244                 # download queue processing
1245                 #
1246                 if [ -n "${src_cat}" ]
1247                 then
1248                         (
1249                                 src_arc="${adb_tmpdir}/${src_url##*/}"
1250                                 src_log="$("${adb_fetchutil}" ${adb_fetchparm} "${src_arc}" "${src_url}" 2>&1)"
1251                                 src_rc="${?}"
1252                                 if [ "${src_rc}" -eq 0 ] && [ -s "${src_arc}" ]
1253                                 then
1254                                         unset src_entries
1255                                         src_suffix="$(eval printf "%s" \"\$\{adb_src_suffix_${src_name}:-\"domains\"\}\")"
1256                                         src_list="$(tar -tzf "${src_arc}" 2>/dev/null)"
1257                                         for src_item in ${src_cat}
1258                                         do
1259                                                 src_entries="${src_entries} $(printf "%s" "${src_list}" | grep -E "${src_item}/${src_suffix}$")"
1260                                         done
1261                                         if [ -n "${src_entries}" ]
1262                                         then
1263                                                 tar -xOzf "${src_arc}" ${src_entries} 2>/dev/null > "${src_tmpload}"
1264                                                 src_rc="${?}"
1265                                         fi
1266                                         rm -f "${src_arc}"
1267                                 else
1268                                         src_log="$(printf "%s" "${src_log}" | "${adb_awk}" '{ORS=" ";print $0}')"
1269                                         f_log "info" "download of '${src_name}' failed, url: ${src_url}, rule: ${src_rset:-"-"}, categories: ${src_cat:-"-"}, rc: ${src_rc}, log: ${src_log:-"-"}"
1270                                 fi
1271                                 if [ "${src_rc}" -eq 0 ] && [ -s "${src_tmpload}" ]
1272                                 then
1273                                         if [ -s "${adb_tmpdir}/tmp.rem.whitelist" ]
1274                                         then
1275                                                 "${adb_awk}" "${src_rset}" "${src_tmpload}" | sed "s/\r//g" | \
1276                                                 grep -Evf "${adb_tmpdir}/tmp.rem.whitelist" | "${adb_awk}" 'BEGIN{FS="."}{for(f=NF;f>1;f--)printf "%s.",$f;print $1}' > "${src_tmpsort}"
1277                                         else
1278                                                 "${adb_awk}" "${src_rset}" "${src_tmpload}" | sed "s/\r//g" | \
1279                                                 "${adb_awk}" 'BEGIN{FS="."}{for(f=NF;f>1;f--)printf "%s.",$f;print $1}' > "${src_tmpsort}"
1280                                         fi
1281                                         rm -f "${src_tmpload}"
1282                                         sort ${adb_srtopts} -u "${src_tmpsort}" 2>/dev/null > "${src_tmpfile}"
1283                                         src_rc="${?}"
1284                                         rm -f "${src_tmpsort}"
1285                                         if [ "${src_rc}" -eq 0 ] && [ -s "${src_tmpfile}" ]
1286                                         then
1287                                                 f_list download
1288                                                 if [ "${adb_backup}" -eq 1 ]
1289                                                 then
1290                                                         f_list backup
1291                                                 fi
1292                                         elif [ "${adb_backup}" -eq 1 ] && [ "${adb_action}" != "start" ]
1293                                         then
1294                                                 f_log "info" "archive preparation of '${src_name}' failed, categories: ${src_cat:-"-"}, entries: ${src_entries}, rc: ${src_rc}"
1295                                                 f_list restore
1296                                                 rm -f "${src_tmpfile}"
1297                                         fi
1298                                 elif [ "${adb_backup}" -eq 1 ] && [ "${adb_action}" != "start" ]
1299                                 then
1300                                         f_log "info" "archive extraction of '${src_name}' failed, categories: ${src_cat:-"-"}, entries: ${src_entries}, rc: ${src_rc}"
1301                                         f_list restore
1302                                 fi
1303                         )&
1304                         continue
1305                 else
1306                         (
1307                                 src_log="$("${adb_fetchutil}" ${adb_fetchparm} "${src_tmpload}" "${src_url}" 2>&1)"
1308                                 src_rc="${?}"
1309                                 if [ "${src_rc}" -eq 0 ] && [ -s "${src_tmpload}" ]
1310                                 then
1311                                         if [ -s "${adb_tmpdir}/tmp.rem.whitelist" ]
1312                                         then
1313                                                 "${adb_awk}" "${src_rset}" "${src_tmpload}" | sed "s/\r//g" | \
1314                                                 grep -Evf "${adb_tmpdir}/tmp.rem.whitelist" | "${adb_awk}" 'BEGIN{FS="."}{for(f=NF;f>1;f--)printf "%s.",$f;print $1}' > "${src_tmpsort}"
1315                                         else
1316                                                 "${adb_awk}" "${src_rset}" "${src_tmpload}" | sed "s/\r//g" | \
1317                                                 "${adb_awk}" 'BEGIN{FS="."}{for(f=NF;f>1;f--)printf "%s.",$f;print $1}' > "${src_tmpsort}"
1318                                         fi
1319                                         rm -f "${src_tmpload}"
1320                                         sort ${adb_srtopts} -u "${src_tmpsort}" 2>/dev/null > "${src_tmpfile}"
1321                                         src_rc="${?}"
1322                                         rm -f "${src_tmpsort}"
1323                                         if [ "${src_rc}" -eq 0 ] && [ -s "${src_tmpfile}" ]
1324                                         then
1325                                                 f_list download
1326                                                 if [ "${adb_backup}" -eq 1 ]
1327                                                 then
1328                                                         f_list backup
1329                                                 fi
1330                                         elif [ "${adb_backup}" -eq 1 ] && [ "${adb_action}" != "start" ]
1331                                         then
1332                                                 f_log "info" "preparation of '${src_name}' failed, rc: ${src_rc}"
1333                                                 f_list restore
1334                                                 rm -f "${src_tmpfile}"
1335                                         fi
1336                                 else
1337                                         src_log="$(printf "%s" "${src_log}" | "${adb_awk}" '{ORS=" ";print $0}')"
1338                                         f_log "info" "download of '${src_name}' failed, url: ${src_url}, rule: ${src_rset:-"-"}, categories: ${src_cat:-"-"}, rc: ${src_rc}, log: ${src_log:-"-"}"
1339                                         if [ "${adb_backup}" -eq 1 ] && [ "${adb_action}" != "start" ]
1340                                         then
1341                                                 f_list restore
1342                                         fi
1343                                 fi
1344                         )&
1345                 fi
1346                 hold=$((cnt%adb_maxqueue))
1347                 if [ "${hold}" -eq 0 ]
1348                 then
1349                         wait
1350                 fi
1351                 cnt=$((cnt+1))
1352         done
1353         wait
1354         f_list merge
1355
1356         # tld compression and dns restart
1357         #
1358         if [ "${?}" -eq 0 ] && [ -s "${adb_tmpdir}/${adb_dnsfile}" ]
1359         then
1360                 f_tld "${adb_tmpdir}/${adb_dnsfile}"
1361                 f_list final
1362         else
1363                 printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
1364         fi
1365         chown "${adb_dnsuser}" "${adb_dnsdir}/${adb_dnsfile}" 2>/dev/null
1366         f_dnsup
1367         if [ "${?}" -eq 0 ]
1368         then
1369                 if [ "${adb_action}" != "resume" ]
1370                 then
1371                         f_jsnup "enabled"
1372                 fi
1373                 if [ "${adb_dns}" != "raw" ] && [ "${adb_dnsfilereset}" -eq 1 ]
1374                 then
1375                         printf "${adb_dnsheader}" > "${adb_dnsdir}/${adb_dnsfile}"
1376                         f_log "info" "blocklist with overall ${adb_cnt} blocked domains loaded successfully and reset afterwards (${adb_sysver})"
1377                         f_bgserv "start"
1378                 else
1379                         f_log "info" "blocklist with overall ${adb_cnt} blocked domains loaded successfully (${adb_sysver})"
1380                 fi
1381         else
1382                 f_log "err" "dns backend restart with adblock blocklist failed"
1383         fi
1384         f_rmtemp
1385 }
1386
1387 # trace dns queries via tcpdump and prepare a report
1388 #
1389 f_report()
1390 {
1391         local iface bg_pid status total start end blocked percent top_list top array item index hold ports cnt=0 search="${1}" count="${2}" process="${3}" print="${4}"
1392
1393         if [ "${adb_report}" -eq 1 ] && [ ! -x "${adb_dumpcmd}" ]
1394         then
1395                 f_log "info" "Please install the package 'tcpdump' or 'tcpdump-mini' to use the reporting feature"
1396         elif [ "${adb_report}" -eq 0 ] && [ "${adb_action}" = "report" ]
1397         then
1398                 f_log "info" "Please enable the 'DNS Report' option to use the reporting feature"
1399         fi
1400
1401         if [ -x "${adb_dumpcmd}" ]
1402         then
1403                 bg_pid="$(pgrep -f "^${adb_dumpcmd}.*adb_report\\.pcap$" | "${adb_awk}" '{ORS=" "; print $1}')"
1404                 if [ "${adb_report}" -eq 0 ] || { [ -n "${bg_pid}" ] && { [ "${adb_action}" = "stop" ] || [ "${adb_action}" = "restart" ]; } }
1405                 then
1406                         if [ -n "${bg_pid}" ]
1407                         then
1408                                 kill -HUP "${bg_pid}" 2>/dev/null
1409                                 while $(kill -0 "${bg_pid}" 2>/dev/null)
1410                                 do
1411                                         sleep 1
1412                                 done
1413                                 unset bg_pid
1414                         fi
1415                 fi
1416         fi
1417
1418         if [ -x "${adb_dumpcmd}" ] && [ "${adb_report}" -eq 1 ]
1419         then
1420                 if [ -z "${bg_pid}" ] && [ "${adb_action}" != "report" ] && [ "${adb_action}" != "stop" ]
1421                 then
1422                         for port in ${adb_replisten}
1423                         do
1424                                 if [ -z "${ports}" ]
1425                                 then
1426                                         ports="port ${port}"
1427                                 else
1428                                         ports="${ports} or port ${port}"
1429                                 fi
1430                         done
1431                         if [ -z "${adb_repiface}" ]
1432                         then
1433                                 network_get_device iface "lan"
1434                                 if [ -n "${iface}" ]
1435                                 then
1436                                         adb_repiface="${iface}"
1437                                 else
1438                                         network_get_physdev iface "lan"
1439                                         if [ -n "${iface}" ]
1440                                         then
1441                                                 adb_repiface="${iface}"
1442                                         fi
1443                                 fi
1444                                 if [ -n "${adb_repiface}" ]
1445                                 then
1446                                         uci_set adblock global adb_repiface "${adb_repiface}"
1447                                         f_uci "adblock"
1448                                 fi
1449                         fi
1450                         if [ -n "${adb_reportdir}" ] && [ ! -d "${adb_reportdir}" ]
1451                         then
1452                                 mkdir -p "${adb_reportdir}"
1453                                 f_log "info" "report directory '${adb_reportdir}' created"
1454                         fi
1455                         if [ -n "${adb_repiface}" ] && [ -d "${adb_reportdir}" ]
1456                         then
1457                                 ( "${adb_dumpcmd}" -nn -s0 -l -i ${adb_repiface} ${ports} -C${adb_repchunksize} -W${adb_repchunkcnt} -w "${adb_reportdir}/adb_report.pcap" >/dev/null 2>&1 & )
1458                                 bg_pid="$(pgrep -f "^${adb_dumpcmd}.*adb_report\\.pcap$" | "${adb_awk}" '{ORS=" "; print $1}')"
1459                         else
1460                                 f_log "info" "Please set the name of the reporting network device 'adb_repiface' manually"
1461                         fi
1462                 fi
1463
1464                 if [ "${adb_action}" = "report" ] && [ "${process}" = "true" ]
1465                 then
1466                         > "${adb_reportdir}/adb_report.raw"
1467                         for file in "${adb_reportdir}/adb_report.pcap"*
1468                         do
1469                                 (
1470                                         "${adb_dumpcmd}" -tttt -r "${file}" 2>/dev/null | \
1471                                                 "${adb_awk}" -v cnt="${cnt}" '!/\.lan\. |PTR\? | SOA\? /&&/ A[\? ]+|NXDomain|0\.0\.0\.0/{a=$1;b=substr($2,0,8);c=$4;sub(/\.[0-9]+$/,"",c);d=cnt $7;sub(/\*$/,"",d);
1472                                                 e=$(NF-1);sub(/[0-9]\/[0-9]\/[0-9]|0\.0\.0\.0/,"NX",e);sub(/\.$/,"",e);sub(/([0-9]{1,3}\.){3}[0-9]{1,3}/,"OK",e);printf "%s\t%s\t%s\t%s\t%s\n",d,e,a,b,c}' >> "${adb_reportdir}/adb_report.raw"
1473                                 )&
1474                                 hold=$((cnt%adb_maxqueue))
1475                                 if [ "${hold}" -eq 0 ]
1476                                 then
1477                                         wait
1478                                 fi
1479                                 cnt=$((cnt+1))
1480                         done
1481                         wait
1482                         if [ -s "${adb_reportdir}/adb_report.raw" ]
1483                         then
1484                                 sort ${adb_srtopts} -k1 -k3 -k4 -k5 -k1 -ur "${adb_reportdir}/adb_report.raw" | \
1485                                         "${adb_awk}" '{currA=($1+0);currB=$1;currC=substr($1,length($1),1);if(reqA==currB){reqA=0;printf "%s\t%s\n",d,$2}else if(currC=="+"){reqA=currA;d=$3"\t"$4"\t"$5"\t"$2}}' | \
1486                                         sort ${adb_srtopts} -k1 -k2 -k3 -k4 -ur > "${adb_reportdir}/adb_report.srt"
1487                                 rm -f "${adb_reportdir}/adb_report.raw"
1488                         fi
1489
1490                         if [ -s "${adb_reportdir}/adb_report.srt" ]
1491                         then
1492                                 start="$("${adb_awk}" 'END{printf "%s_%s",$1,$2}' "${adb_reportdir}/adb_report.srt")"
1493                                 end="$("${adb_awk}" 'NR==1{printf "%s_%s",$1,$2}' "${adb_reportdir}/adb_report.srt")"
1494                                 total="$(wc -l < "${adb_reportdir}/adb_report.srt")"
1495                                 blocked="$("${adb_awk}" '{if($5=="NX")cnt++}END{printf "%s",cnt}' "${adb_reportdir}/adb_report.srt")"
1496                                 percent="$("${adb_awk}" -v t="${total}" -v b="${blocked}" 'BEGIN{printf "%.2f%s",b/t*100,"%"}')"
1497                                 > "${adb_reportdir}/adb_report.json"
1498                                 printf "%s" "{ \"data\": { " >> "${adb_reportdir}/adb_report.json"
1499                                 printf "%s" "\"start_date\": \"${start%_*}\", " >> "${adb_reportdir}/adb_report.json"
1500                                 printf "%s" "\"start_time\": \"${start#*_}\", " >> "${adb_reportdir}/adb_report.json"
1501                                 printf "%s" "\"end_date\": \"${end%_*}\", " >> "${adb_reportdir}/adb_report.json"
1502                                 printf "%s" "\"end_time\": \"${end#*_}\", " >> "${adb_reportdir}/adb_report.json"
1503                                 printf "%s" "\"total\": \"${total}\", " >> "${adb_reportdir}/adb_report.json"
1504                                 printf "%s" "\"blocked\": \"${blocked}\", " >> "${adb_reportdir}/adb_report.json"
1505                                 printf "%s" "\"percent\": \"${percent}\", " >> "${adb_reportdir}/adb_report.json"
1506
1507                                 top_list="top_clients top_domains top_blocked"
1508                                 for top in ${top_list}
1509                                 do
1510                                         printf "%s" " \"${top}\": [ " >> "${adb_reportdir}/adb_report.json"
1511                                         case "${top}" in
1512                                                 "top_clients")
1513                                                         "${adb_awk}" '{print $3}' "${adb_reportdir}/adb_report.srt" | sort ${adb_srtopts} | uniq -c | \
1514                                                                 sort ${adb_srtopts} -nr | "${adb_awk}" '{ORS=" ";if(NR==1)printf "{ \"count\": \"%s\", \"address\": \"%s\" }",$1,$2; else if(NR<10)printf ", { \"count\": \"%s\", \"address\": \"%s\" }",$1,$2}' >> "${adb_reportdir}/adb_report.json"
1515                                                 ;;
1516                                                 "top_domains")
1517                                                         "${adb_awk}" '{if($5!="NX")print $4}' "${adb_reportdir}/adb_report.srt" | sort ${adb_srtopts} | uniq -c | \
1518                                                                 sort ${adb_srtopts} -nr | "${adb_awk}" '{ORS=" ";if(NR==1)printf "{ \"count\": \"%s\", \"address\": \"%s\" }",$1,$2; else if(NR<10)printf ", { \"count\": \"%s\", \"address\": \"%s\" }",$1,$2}' >> "${adb_reportdir}/adb_report.json"
1519                                                 ;;
1520                                                 "top_blocked")
1521                                                         "${adb_awk}" '{if($5=="NX")print $4}' "${adb_reportdir}/adb_report.srt" | sort ${adb_srtopts} | uniq -c | \
1522                                                                 sort ${adb_srtopts} -nr | "${adb_awk}" '{ORS=" ";if(NR==1)printf "{ \"count\": \"%s\", \"address\": \"%s\" }",$1,$2; else if(NR<10)printf ", { \"count\": \"%s\", \"address\": \"%s\" }",$1,$2}' >> "${adb_reportdir}/adb_report.json"
1523                                                 ;;
1524                                         esac
1525                                         printf "%s" " ], " >> "${adb_reportdir}/adb_report.json"
1526                                 done
1527                                 search="${search//./\\.}"
1528                                 search="${search//[+*~%\$&\"\' ]/}"
1529                                 "${adb_awk}" "BEGIN{i=0;printf \"\\\"requests\\\": [ \" }/(${search})/{i++;if(i==1)printf \"{ \\\"date\\\": \\\"%s\\\", \\\"time\\\": \\\"%s\\\", \\\"client\\\": \\\"%s\\\", \\\"domain\\\": \\\"%s\\\", \\\"rc\\\": \\\"%s\\\" }\",\$1,\$2,\$3,\$4,\$5;else if(i<=${count})printf \", { \\\"date\\\": \\\"%s\\\", \\\"time\\\": \\\"%s\\\", \\\"client\\\": \\\"%s\\\", \\\"domain\\\": \\\"%s\\\", \\\"rc\\\": \\\"%s\\\" }\",\$1,\$2,\$3,\$4,\$5}END{printf \" ] } }\n\"}" "${adb_reportdir}/adb_report.srt" >> "${adb_reportdir}/adb_report.json"
1530                                 rm -f "${adb_reportdir}/adb_report.srt"
1531                         fi
1532                 fi
1533
1534                 if [ -s "${adb_reportdir}/adb_report.json" ]
1535                 then
1536                         if [ "${print}" = "cli" ]
1537                         then
1538                                 printf "%s\\n%s\\n%s\\n" ":::" "::: Adblock DNS-Query Report" ":::"
1539                                 json_load_file "${adb_reportdir}/adb_report.json"
1540                                 json_select "data"
1541                                 json_get_keys keylist
1542                                 for key in ${keylist}
1543                                 do
1544                                         json_get_var value "${key}"
1545                                         eval "${key}=\"${value}\""
1546                                 done
1547                                 printf "  + %s\\n  + %s\\n" "Start    ::: ${start_date}, ${start_time}" "End      ::: ${end_date}, ${end_time}"
1548                                 printf "  + %s\\n  + %s %s\\n" "Total    ::: ${total}" "Blocked  ::: ${blocked}" "(${percent})"
1549
1550                                 top_list="top_clients top_domains top_blocked requests"
1551                                 for top in ${top_list}
1552                                 do
1553                                         case "${top}" in
1554                                                 "top_clients")
1555                                                         item="::: Top 10 Clients"
1556                                                 ;;
1557                                                 "top_domains")
1558                                                         item="::: Top 10 Domains"
1559                                                 ;;
1560                                                 "top_blocked")
1561                                                         item="::: Top 10 Blocked Domains"
1562                                                 ;;
1563                                         esac
1564                                         if json_get_type status "${top}" && [ "${top}" != "requests" ] && [ "${status}" = "array" ]
1565                                         then
1566                                                 printf "%s\\n%s\\n%s\\n" ":::" "${item}" ":::"
1567                                                 json_select "${top}"
1568                                                 index=1
1569                                                 while json_get_type status "${index}" && [ "${status}" = "object" ]
1570                                                 do
1571                                                         json_get_values item "${index}"
1572                                                         printf "  + %-9s::: %s\\n" ${item}
1573                                                         index=$((index+1))
1574                                                 done
1575                                         elif json_get_type status "${top}" && [ "${top}" = "requests" ] && [ "${status}" = "array" ]
1576                                         then
1577                                                 printf "%s\\n%s\\n%s\\n" ":::" "::: Latest DNS Queries" ":::"
1578                                                 printf "%-15s%-15s%-45s%-50s%s\\n" "Date" "Time" "Client" "Domain" "Answer"
1579                                                 json_select "${top}"
1580                                                 index=1
1581                                                 while json_get_type status "${index}" && [ "${status}" = "object" ]
1582                                                 do
1583                                                         json_get_values item "${index}"
1584                                                         printf "%-15s%-15s%-45s%-50s%s\\n" ${item}
1585                                                         index=$((index+1))
1586                                                 done
1587                                         fi
1588                                         json_select ".."
1589                                 done
1590                         elif [ "${print}" = "json" ]
1591                         then
1592                                 cat "${adb_reportdir}/adb_report.json"
1593                         fi
1594                 fi
1595         fi
1596         f_log "debug" "f_report ::: action: ${adb_action}, report: ${adb_report}, search: ${1}, count: ${2}, process: ${3}, print: ${4}, dump_util: ${adb_dumpcmd}, repdir: ${adb_reportdir}, repiface: ${adb_repiface:-"-"}, replisten: ${adb_replisten}, repchunksize: ${adb_repchunksize}, repchunkcnt: ${adb_repchunkcnt}, bg_pid: ${bg_pid}"
1597 }
1598
1599 # awk selection
1600 #
1601 adb_awk="$(command -v gawk)"
1602 if [ -z "${adb_awk}" ]
1603 then
1604         adb_awk="$(command -v awk)"
1605 fi
1606
1607 # source required system libraries
1608 #
1609 if [ -r "/lib/functions.sh" ] && [ -r "/lib/functions/network.sh" ] && [ -r "/usr/share/libubox/jshn.sh" ]
1610 then
1611         . "/lib/functions.sh"
1612         . "/lib/functions/network.sh"
1613         . "/usr/share/libubox/jshn.sh"
1614 else
1615         f_log "err" "system libraries not found"
1616 fi
1617
1618 # handle different adblock actions
1619 #
1620 f_load
1621 case "${adb_action}" in
1622         "stop")
1623                 f_bgserv "stop"
1624                 f_report "+" "50" "false" "false"
1625                 f_rmdns
1626         ;;
1627         "restart")
1628                 f_bgserv "stop"
1629                 f_report "+" "50" "false" "false"
1630                 f_rmdns
1631                 f_env
1632                 f_main
1633         ;;
1634         "suspend")
1635                 if [ "${adb_dns}" != "raw" ]
1636                 then
1637                         f_switch suspend
1638                 fi
1639         ;;
1640         "resume")
1641                 if [ "${adb_dns}" != "raw" ]
1642                 then
1643                         f_switch resume
1644                 fi
1645         ;;
1646         "report")
1647                 f_report "${2}" "${3}" "${4}" "${5}"
1648         ;;
1649         "query")
1650                 f_query "${2}"
1651         ;;
1652         "start"|"reload")
1653                 f_bgserv "stop"
1654                 f_report "+" "50" "false" "false"
1655                 f_env
1656                 f_main
1657         ;;
1658 esac