533 lines
20 KiB
Bash
533 lines
20 KiB
Bash
#!/bin/bash
|
||
###############################################################################
|
||
# AdGuard Shield - Externer Whitelist-Worker
|
||
# Lädt externe Whitelist-Dateien herunter, löst Domains zu IPs auf und
|
||
# stellt diese dem Hauptscript als dynamische Whitelist zur Verfügung.
|
||
# Ideal für DynDNS-Domains mit wechselnden IP-Adressen.
|
||
# Wird als Hintergrundprozess vom Hauptscript gestartet.
|
||
#
|
||
# Autor: Patrick Asmus
|
||
# E-Mail: support@techniverse.net
|
||
# Datum: 2026-04-04
|
||
# Lizenz: MIT
|
||
###############################################################################
|
||
|
||
set -euo pipefail
|
||
|
||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||
CONFIG_FILE="${SCRIPT_DIR}/adguard-shield.conf"
|
||
|
||
# ─── Konfiguration laden ───────────────────────────────────────────────────────
|
||
if [[ ! -f "$CONFIG_FILE" ]]; then
|
||
echo "FEHLER: Konfigurationsdatei nicht gefunden: $CONFIG_FILE" >&2
|
||
exit 1
|
||
fi
|
||
# shellcheck source=adguard-shield.conf
|
||
source "$CONFIG_FILE"
|
||
|
||
# ─── Standardwerte ────────────────────────────────────────────────────────────
|
||
EXTERNAL_WHITELIST_CACHE_DIR="${EXTERNAL_WHITELIST_CACHE_DIR:-/var/lib/adguard-shield/external-whitelist}"
|
||
EXTERNAL_WHITELIST_RESOLVED_FILE="${EXTERNAL_WHITELIST_CACHE_DIR}/resolved_ips.txt"
|
||
|
||
# ─── Worker PID-File ──────────────────────────────────────────────────────────
|
||
WORKER_PID_FILE="/var/run/adguard-whitelist-worker.pid"
|
||
|
||
# ─── Logging (eigene Funktion, nutzt gleiche Log-Datei) ───────────────────────
|
||
declare -A LOG_LEVELS=([DEBUG]=0 [INFO]=1 [WARN]=2 [ERROR]=3)
|
||
|
||
log() {
|
||
local level="$1"
|
||
shift
|
||
local message="$*"
|
||
local configured_level="${LOG_LEVEL:-INFO}"
|
||
|
||
if [[ ${LOG_LEVELS[$level]:-1} -ge ${LOG_LEVELS[$configured_level]:-1} ]]; then
|
||
local timestamp
|
||
timestamp="$(date '+%Y-%m-%d %H:%M:%S')"
|
||
local log_entry="[$timestamp] [$level] [WHITELIST-WORKER] $message"
|
||
echo "$log_entry" | tee -a "$LOG_FILE" >&2
|
||
fi
|
||
}
|
||
|
||
# ─── Verzeichnisse erstellen ──────────────────────────────────────────────────
|
||
init_directories() {
|
||
mkdir -p "$EXTERNAL_WHITELIST_CACHE_DIR"
|
||
mkdir -p "$(dirname "$LOG_FILE")"
|
||
}
|
||
|
||
# ─── Eintrag-Validierung ─────────────────────────────────────────────────────
|
||
|
||
# Prüft IPv4-Adresse mit optionalem CIDR
|
||
_is_valid_ipv4() {
|
||
local ip="$1" addr="$1" prefix=""
|
||
if [[ "$ip" == */* ]]; then
|
||
addr="${ip%/*}"
|
||
prefix="${ip#*/}"
|
||
{ [[ "$prefix" =~ ^[0-9]+$ ]] && [[ "$prefix" -le 32 ]]; } || return 1
|
||
fi
|
||
local IFS='.'
|
||
read -ra _octets <<< "$addr"
|
||
[[ ${#_octets[@]} -eq 4 ]] || return 1
|
||
local o
|
||
for o in "${_octets[@]}"; do
|
||
[[ "$o" =~ ^[0-9]+$ ]] || return 1
|
||
[[ "$o" -le 255 ]] || return 1
|
||
done
|
||
return 0
|
||
}
|
||
|
||
# Prüft IPv6-Adresse mit optionalem CIDR
|
||
_is_valid_ipv6() {
|
||
local ip="$1" addr="$1"
|
||
if [[ "$ip" == */* ]]; then
|
||
addr="${ip%/*}"
|
||
local prefix="${ip#*/}"
|
||
{ [[ "$prefix" =~ ^[0-9]+$ ]] && [[ "$prefix" -le 128 ]]; } || return 1
|
||
fi
|
||
[[ "$addr" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+:[0-9] ]] && return 1
|
||
[[ "$addr" == *:* ]] || return 1
|
||
[[ "$addr" =~ ^[0-9a-fA-F:\.]+$ ]] || return 1
|
||
return 0
|
||
}
|
||
|
||
# Prüft ob ein Hostname syntaktisch plausibel ist
|
||
_is_valid_hostname() {
|
||
local host="$1"
|
||
host="${host%.}" # trailing dot entfernen
|
||
[[ -z "$host" ]] && return 1
|
||
[[ ${#host} -gt 253 ]] && return 1
|
||
[[ "$host" =~ ^[a-zA-Z0-9._-]+$ ]] || return 1
|
||
[[ "$host" =~ ^[.\-] ]] && return 1
|
||
[[ "$host" == *.* ]] || return 1
|
||
return 0
|
||
}
|
||
|
||
# ─── Externe Whitelist herunterladen ─────────────────────────────────────────
|
||
download_whitelist() {
|
||
local url="$1"
|
||
local index="$2"
|
||
local cache_file="${EXTERNAL_WHITELIST_CACHE_DIR}/whitelist_${index}.txt"
|
||
local etag_file="${EXTERNAL_WHITELIST_CACHE_DIR}/whitelist_${index}.etag"
|
||
local tmp_file="${EXTERNAL_WHITELIST_CACHE_DIR}/whitelist_${index}.tmp"
|
||
|
||
log "DEBUG" "Prüfe externe Whitelist: $url"
|
||
|
||
local -a curl_args=(
|
||
-s
|
||
-L
|
||
--connect-timeout 10
|
||
--max-time 30
|
||
-o "$tmp_file"
|
||
-w "%{http_code}"
|
||
)
|
||
|
||
if [[ -f "$etag_file" ]]; then
|
||
local stored_etag
|
||
stored_etag=$(cat "$etag_file")
|
||
curl_args+=(-H "If-None-Match: ${stored_etag}")
|
||
fi
|
||
|
||
local http_code
|
||
http_code=$(curl "${curl_args[@]}" -D "${tmp_file}.headers" "$url" 2>/dev/null) || {
|
||
log "WARN" "Fehler beim Download der Whitelist: $url"
|
||
rm -f "$tmp_file" "${tmp_file}.headers"
|
||
return 1
|
||
}
|
||
|
||
if [[ "$http_code" == "304" ]]; then
|
||
log "DEBUG" "Whitelist nicht geändert (HTTP 304): $url"
|
||
rm -f "$tmp_file" "${tmp_file}.headers"
|
||
# Auch bei 304 müssen wir DNS neu auflösen (dynamische IPs!)
|
||
return 0
|
||
fi
|
||
|
||
if [[ "$http_code" != "200" ]]; then
|
||
log "WARN" "Whitelist Download fehlgeschlagen (HTTP $http_code): $url"
|
||
rm -f "$tmp_file" "${tmp_file}.headers"
|
||
return 1
|
||
fi
|
||
|
||
if [[ -f "${tmp_file}.headers" ]]; then
|
||
local new_etag
|
||
new_etag=$(grep -i '^etag:' "${tmp_file}.headers" | head -1 | sed 's/^[^:]*: *//;s/\r$//')
|
||
if [[ -n "$new_etag" ]]; then
|
||
echo "$new_etag" > "$etag_file"
|
||
fi
|
||
fi
|
||
rm -f "${tmp_file}.headers"
|
||
|
||
if [[ -f "$cache_file" ]]; then
|
||
if diff -q "$tmp_file" "$cache_file" &>/dev/null; then
|
||
log "DEBUG" "Whitelist Inhalt unverändert: $url"
|
||
rm -f "$tmp_file"
|
||
return 0
|
||
fi
|
||
fi
|
||
|
||
mv "$tmp_file" "$cache_file"
|
||
log "INFO" "Whitelist aktualisiert: $url"
|
||
return 0
|
||
}
|
||
|
||
# ─── Einträge aus Whitelist-Datei parsen und IPs auflösen ───────────────────
|
||
# Gibt pro Zeile eine IP-Adresse aus (aufgelöste Domains + direkte IPs)
|
||
parse_whitelist_entries() {
|
||
local cache_file="$1"
|
||
|
||
[[ -f "$cache_file" ]] || return
|
||
|
||
while IFS= read -r line; do
|
||
line="${line%$'\r'}"
|
||
line="${line#$'\xef\xbb\xbf'}"
|
||
|
||
[[ -z "$line" ]] && continue
|
||
[[ "$line" =~ ^[[:space:]]*# ]] && continue
|
||
|
||
line=$(echo "$line" | xargs)
|
||
line=$(echo "$line" | sed 's/[[:space:]]*[#;].*$//' | xargs)
|
||
[[ -z "$line" ]] && continue
|
||
|
||
# URLs ablehnen
|
||
if [[ "$line" =~ ^[a-zA-Z][a-zA-Z0-9+.-]*:// ]]; then
|
||
log "WARN" "Whitelist-Eintrag übersprungen (URL nicht erlaubt): $line"
|
||
continue
|
||
fi
|
||
|
||
# Hosts-Datei-Format erkennen
|
||
if [[ "$line" =~ ^[^[:space:]]+[[:space:]]+[^[:space:]] ]]; then
|
||
local _first="${line%% *}"
|
||
local _rest="${line#* }"
|
||
local _second="${_rest%% *}"
|
||
if [[ "$_first" == "0.0.0.0" || "$_first" =~ ^127\. ||
|
||
"$_first" == "::1" || "$_first" == "::0" ||
|
||
"$_first" == "::" ]]; then
|
||
log "DEBUG" "Whitelist Hosts-Format erkannt, extrahiere: $_second"
|
||
line="$_second"
|
||
else
|
||
log "WARN" "Whitelist-Eintrag übersprungen (unbekanntes Format): $line"
|
||
continue
|
||
fi
|
||
fi
|
||
|
||
# Klassifizieren und validieren
|
||
if [[ "$line" == *:* ]]; then
|
||
# IPv6
|
||
if _is_valid_ipv6 "$line"; then
|
||
echo "$line"
|
||
else
|
||
log "WARN" "Whitelist-Eintrag übersprungen (ungültige IPv6): $line"
|
||
fi
|
||
|
||
elif [[ "$line" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+(/[0-9]+)?$ ]]; then
|
||
# IPv4 (nur Ziffern, Punkte und optionaler CIDR-Suffix)
|
||
[[ "$line" == "0.0.0.0"* ]] && continue
|
||
if _is_valid_ipv4 "$line"; then
|
||
echo "$line"
|
||
else
|
||
log "WARN" "Whitelist-Eintrag übersprungen (ungültige IPv4): $line"
|
||
fi
|
||
|
||
else
|
||
# Hostname → DNS-Auflösung (wird bei jedem Durchlauf neu aufgelöst!)
|
||
if ! _is_valid_hostname "$line"; then
|
||
log "WARN" "Whitelist-Eintrag übersprungen (kein gültiger Hostname): $line"
|
||
continue
|
||
fi
|
||
local resolved
|
||
resolved=$(getent ahosts "$line" 2>/dev/null | awk '{print $1}' | sort -u) || resolved=""
|
||
if [[ -z "$resolved" ]]; then
|
||
log "WARN" "Whitelist-Hostname konnte nicht aufgelöst werden: $line"
|
||
continue
|
||
fi
|
||
local resolved_count=0
|
||
while IFS= read -r resolved_ip; do
|
||
[[ -z "$resolved_ip" ]] && continue
|
||
[[ "$resolved_ip" == "0.0.0.0" ]] && continue
|
||
[[ "$resolved_ip" == "::" ]] && continue
|
||
[[ "$resolved_ip" == "::0" ]] && continue
|
||
echo "$resolved_ip"
|
||
resolved_count=$((resolved_count + 1))
|
||
done <<< "$resolved"
|
||
if [[ $resolved_count -gt 0 ]]; then
|
||
log "DEBUG" "Whitelist-Hostname aufgelöst: $line → $resolved_count IP(s)"
|
||
else
|
||
log "WARN" "Whitelist-Hostname lieferte nur ungültige Adressen: $line"
|
||
fi
|
||
fi
|
||
done < "$cache_file"
|
||
}
|
||
|
||
# ─── Whitelisten synchronisieren ─────────────────────────────────────────────
|
||
sync_whitelists() {
|
||
# Alle URLs herunterladen
|
||
IFS=',' read -ra urls <<< "$EXTERNAL_WHITELIST_URLS"
|
||
local index=0
|
||
|
||
for url in "${urls[@]}"; do
|
||
url=$(echo "$url" | xargs)
|
||
[[ -z "$url" ]] && continue
|
||
|
||
download_whitelist "$url" "$index" || true
|
||
index=$((index + 1))
|
||
done
|
||
|
||
# Alle Einträge aus Cache-Dateien parsen und IPs auflösen
|
||
local all_ips_file="${EXTERNAL_WHITELIST_CACHE_DIR}/.all_ips.tmp"
|
||
> "$all_ips_file"
|
||
|
||
for cache_file in "${EXTERNAL_WHITELIST_CACHE_DIR}"/whitelist_*.txt; do
|
||
[[ -f "$cache_file" ]] || continue
|
||
parse_whitelist_entries "$cache_file" >> "$all_ips_file"
|
||
done
|
||
|
||
# Duplikate entfernen und in die resolved-Datei schreiben
|
||
local unique_count
|
||
sort -u "$all_ips_file" > "${EXTERNAL_WHITELIST_RESOLVED_FILE}.tmp"
|
||
mv "${EXTERNAL_WHITELIST_RESOLVED_FILE}.tmp" "$EXTERNAL_WHITELIST_RESOLVED_FILE"
|
||
unique_count=$(wc -l < "$EXTERNAL_WHITELIST_RESOLVED_FILE" | xargs)
|
||
|
||
rm -f "$all_ips_file"
|
||
|
||
log "DEBUG" "Externe Whitelist: $unique_count eindeutige IPs aufgelöst"
|
||
|
||
# Prüfe ob gesperrte IPs jetzt auf der Whitelist stehen und entsperrt werden müssen
|
||
check_banned_whitelist_ips
|
||
}
|
||
|
||
# ─── Gesperrte IPs prüfen die jetzt gewhitelistet sind ──────────────────────
|
||
# Wenn eine IP nach einer Whitelist-Aktualisierung nun auf der externen
|
||
# Whitelist steht, wird sie automatisch entsperrt.
|
||
check_banned_whitelist_ips() {
|
||
local state_dir="${STATE_DIR:-/var/lib/adguard-shield}"
|
||
[[ -d "$state_dir" ]] || return
|
||
[[ -f "$EXTERNAL_WHITELIST_RESOLVED_FILE" ]] || return
|
||
|
||
for state_file in "${state_dir}"/*.ban "${state_dir}"/ext_*.ban; do
|
||
[[ -f "$state_file" ]] || continue
|
||
local client_ip
|
||
client_ip=$(grep '^CLIENT_IP=' "$state_file" | cut -d= -f2)
|
||
[[ -z "$client_ip" ]] && continue
|
||
|
||
if grep -qxF "$client_ip" "$EXTERNAL_WHITELIST_RESOLVED_FILE" 2>/dev/null; then
|
||
log "INFO" "Gesperrte IP $client_ip ist jetzt auf externer Whitelist – entsperre automatisch"
|
||
|
||
# iptables-Regel entfernen
|
||
if [[ "$client_ip" == *:* ]]; then
|
||
ip6tables -D "$IPTABLES_CHAIN" -s "$client_ip" -j DROP 2>/dev/null || true
|
||
else
|
||
iptables -D "$IPTABLES_CHAIN" -s "$client_ip" -j DROP 2>/dev/null || true
|
||
fi
|
||
|
||
rm -f "$state_file"
|
||
|
||
# Ban-History Eintrag
|
||
if [[ -f "${BAN_HISTORY_FILE:-/var/log/adguard-shield-bans.log}" ]]; then
|
||
local timestamp
|
||
timestamp="$(date '+%Y-%m-%d %H:%M:%S')"
|
||
printf "%-19s | %-6s | %-39s | %-30s | %-8s | %-10s | %-10s | %s\n" \
|
||
"$timestamp" "UNBAN" "$client_ip" "-" "-" "-" "-" "external-whitelist" \
|
||
>> "${BAN_HISTORY_FILE:-/var/log/adguard-shield-bans.log}"
|
||
fi
|
||
fi
|
||
done
|
||
}
|
||
|
||
# ─── PID-Management ──────────────────────────────────────────────────────────
|
||
write_pid() {
|
||
echo $$ > "$WORKER_PID_FILE"
|
||
}
|
||
|
||
cleanup() {
|
||
log "INFO" "Externer Whitelist-Worker wird beendet..."
|
||
rm -f "$WORKER_PID_FILE"
|
||
exit 0
|
||
}
|
||
|
||
check_already_running() {
|
||
if [[ -f "$WORKER_PID_FILE" ]]; then
|
||
local old_pid
|
||
old_pid=$(cat "$WORKER_PID_FILE")
|
||
if kill -0 "$old_pid" 2>/dev/null; then
|
||
log "DEBUG" "Whitelist-Worker läuft bereits (PID: $old_pid)"
|
||
return 1
|
||
else
|
||
rm -f "$WORKER_PID_FILE"
|
||
fi
|
||
fi
|
||
return 0
|
||
}
|
||
|
||
# ─── Status anzeigen ─────────────────────────────────────────────────────────
|
||
show_status() {
|
||
echo "═══════════════════════════════════════════════════════════════"
|
||
echo " Externer Whitelist-Worker - Status"
|
||
echo "═══════════════════════════════════════════════════════════════"
|
||
echo ""
|
||
|
||
if [[ "$EXTERNAL_WHITELIST_ENABLED" != "true" ]]; then
|
||
echo " ⚠️ Externer Whitelist-Worker ist deaktiviert"
|
||
echo " Aktivieren: EXTERNAL_WHITELIST_ENABLED=true in $CONFIG_FILE"
|
||
echo ""
|
||
return
|
||
fi
|
||
|
||
# Worker-Prozess Status
|
||
if [[ -f "$WORKER_PID_FILE" ]]; then
|
||
local pid
|
||
pid=$(cat "$WORKER_PID_FILE")
|
||
if kill -0 "$pid" 2>/dev/null; then
|
||
echo " ✅ Worker läuft (PID: $pid)"
|
||
else
|
||
echo " ❌ Worker nicht aktiv (veraltete PID-Datei)"
|
||
fi
|
||
else
|
||
echo " ❌ Worker nicht aktiv"
|
||
fi
|
||
|
||
echo ""
|
||
|
||
# Konfigurierte URLs
|
||
echo " Konfigurierte Whitelisten:"
|
||
IFS=',' read -ra urls <<< "$EXTERNAL_WHITELIST_URLS"
|
||
local index=0
|
||
for url in "${urls[@]}"; do
|
||
url=$(echo "$url" | xargs)
|
||
[[ -z "$url" ]] && continue
|
||
local cache_file="${EXTERNAL_WHITELIST_CACHE_DIR}/whitelist_${index}.txt"
|
||
if [[ -f "$cache_file" ]]; then
|
||
local entry_count
|
||
entry_count=$(grep -cv '^\s*#\|^\s*$' "$cache_file" 2>/dev/null || echo "0")
|
||
local last_modified
|
||
last_modified=$(date -r "$cache_file" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || echo "unbekannt")
|
||
echo " [$index] $url"
|
||
echo " Einträge: $entry_count | Zuletzt aktualisiert: $last_modified"
|
||
else
|
||
echo " [$index] $url (noch nicht heruntergeladen)"
|
||
fi
|
||
index=$((index + 1))
|
||
done
|
||
|
||
echo ""
|
||
|
||
# Aufgelöste IPs
|
||
if [[ -f "$EXTERNAL_WHITELIST_RESOLVED_FILE" ]]; then
|
||
local resolved_count
|
||
resolved_count=$(wc -l < "$EXTERNAL_WHITELIST_RESOLVED_FILE" | xargs)
|
||
local last_resolved
|
||
last_resolved=$(date -r "$EXTERNAL_WHITELIST_RESOLVED_FILE" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || echo "unbekannt")
|
||
echo " Aufgelöste IPs: $resolved_count"
|
||
echo " Letzte Auflösung: $last_resolved"
|
||
|
||
if [[ "$resolved_count" -gt 0 && "$resolved_count" -le 20 ]]; then
|
||
echo ""
|
||
echo " Aktuelle IPs:"
|
||
while IFS= read -r ip; do
|
||
echo " ✅ $ip"
|
||
done < "$EXTERNAL_WHITELIST_RESOLVED_FILE"
|
||
elif [[ "$resolved_count" -gt 20 ]]; then
|
||
echo ""
|
||
echo " Erste 20 IPs:"
|
||
head -20 "$EXTERNAL_WHITELIST_RESOLVED_FILE" | while IFS= read -r ip; do
|
||
echo " ✅ $ip"
|
||
done
|
||
echo " ... ($((resolved_count - 20)) weitere)"
|
||
fi
|
||
else
|
||
echo " Aufgelöste IPs: 0 (noch keine Synchronisation durchgeführt)"
|
||
fi
|
||
|
||
echo ""
|
||
echo " Prüfintervall: ${EXTERNAL_WHITELIST_INTERVAL}s"
|
||
echo ""
|
||
echo "═══════════════════════════════════════════════════════════════"
|
||
}
|
||
|
||
# ─── Einmalig synchronisieren ────────────────────────────────────────────────
|
||
run_once() {
|
||
init_directories
|
||
|
||
if [[ -z "${EXTERNAL_WHITELIST_URLS:-}" ]]; then
|
||
log "ERROR" "Keine externen Whitelist-URLs konfiguriert (EXTERNAL_WHITELIST_URLS)"
|
||
exit 1
|
||
fi
|
||
|
||
log "INFO" "Einmalige Whitelist-Synchronisation..."
|
||
sync_whitelists
|
||
log "INFO" "Whitelist-Synchronisation abgeschlossen"
|
||
}
|
||
|
||
# ─── Hauptschleife ──────────────────────────────────────────────────────────
|
||
main_loop() {
|
||
init_directories
|
||
|
||
if [[ -z "${EXTERNAL_WHITELIST_URLS:-}" ]]; then
|
||
log "ERROR" "Keine externen Whitelist-URLs konfiguriert (EXTERNAL_WHITELIST_URLS)"
|
||
exit 1
|
||
fi
|
||
|
||
log "INFO" "═══════════════════════════════════════════════════════════"
|
||
log "INFO" "Externer Whitelist-Worker gestartet"
|
||
log "INFO" " URLs: ${EXTERNAL_WHITELIST_URLS}"
|
||
log "INFO" " Prüfintervall: ${EXTERNAL_WHITELIST_INTERVAL}s"
|
||
log "INFO" "═══════════════════════════════════════════════════════════"
|
||
|
||
while true; do
|
||
sync_whitelists
|
||
sleep "$EXTERNAL_WHITELIST_INTERVAL"
|
||
done
|
||
}
|
||
|
||
# ─── Signal-Handler ──────────────────────────────────────────────────────────
|
||
trap cleanup SIGTERM SIGINT SIGHUP
|
||
|
||
# ─── Kommandozeilen-Argumente ────────────────────────────────────────────────
|
||
case "${1:-start}" in
|
||
start)
|
||
if ! check_already_running; then
|
||
exit 0
|
||
fi
|
||
write_pid
|
||
main_loop
|
||
;;
|
||
stop)
|
||
if [[ -f "$WORKER_PID_FILE" ]]; then
|
||
kill "$(cat "$WORKER_PID_FILE")" 2>/dev/null || true
|
||
rm -f "$WORKER_PID_FILE"
|
||
echo "Whitelist-Worker gestoppt"
|
||
else
|
||
echo "Whitelist-Worker läuft nicht"
|
||
fi
|
||
;;
|
||
sync)
|
||
run_once
|
||
;;
|
||
status)
|
||
init_directories
|
||
show_status
|
||
;;
|
||
flush)
|
||
init_directories
|
||
echo "Entferne aufgelöste externe Whitelist-IPs..."
|
||
rm -f "$EXTERNAL_WHITELIST_RESOLVED_FILE"
|
||
echo "Externe Whitelist-IPs entfernt"
|
||
;;
|
||
*)
|
||
cat << USAGE
|
||
AdGuard Shield - Externer Whitelist-Worker
|
||
|
||
Nutzung: $0 {start|stop|sync|status|flush}
|
||
|
||
Befehle:
|
||
start Startet den Worker (Dauerbetrieb)
|
||
stop Stoppt den Worker
|
||
sync Einmalige Synchronisation (DNS-Auflösung)
|
||
status Zeigt Status und aufgelöste IPs
|
||
flush Entfernt alle aufgelösten Whitelist-IPs
|
||
|
||
Konfiguration: $CONFIG_FILE
|
||
|
||
USAGE
|
||
exit 0
|
||
;;
|
||
esac
|