Namen 'ARIA' aus Dateinamen und Texten entfernen (nur noch 'geoblock')

LAENDERCODES.md

@@ -1,6 +1,6 @@
 # Länderkürzel (ISO 3166-1 alpha-2)
 
-Referenzliste für die `countries`-Option in `aria_geoblock.ini`. Dort werden
+Referenzliste für die `countries`-Option in `geoblock.ini`. Dort werden
 kommagetrennte, kleingeschriebene Zwei-Buchstaben-Codes eingetragen, z. B.:
 
 ```ini
@@ -9,7 +9,7 @@ countries = de,at,ch
 ```
 
 Die Codes stammen aus den MaxMind-GeoLite2-Country-Datenbanken (Standard
-ISO-3166-1-alpha-2), die `aria_geoblock.py` zur Auflösung von IP → Land nutzt.
+ISO-3166-1-alpha-2), die `geoblock.py` zur Auflösung von IP → Land nutzt.
 
 ## Europa
 

README.md

@@ -1,4 +1,4 @@
-# ARIA Geoblocking
+# Geoblocking
 
 Blockt Verbindungen aus bestimmten Laendern auf Kernel-Ebene (iptables +
 ipset). Die IP-Bereiche je Land kommen kostenlos (kein API-Key) von
@@ -13,15 +13,15 @@ und droppt Pakete bereits auf Netzwerk-Ebene.
 
 | Datei | Zweck |
 |---|---|
-| `aria_geoblock.py` | Hauptscript: laedt Laender-IPs, setzt/entfernt ipset+iptables-Regeln |
+| `geoblock.py` | Hauptscript: laedt Laender-IPs, setzt/entfernt ipset+iptables-Regeln |
-| `aria_geoblock.ini` | Konfiguration (Laenderliste, Chain, Logging, ...) |
+| `geoblock.ini` | Konfiguration (Laenderliste, Chain, Logging, ...) |
-| `aria-geoblock.service` | systemd-Unit, fuehrt `--apply` aus |
+| `geoblock.service` | systemd-Unit, fuehrt `--apply` aus |
-| `aria-geoblock.timer` | systemd-Timer: beim Booten + einmal taeglich |
+| `geoblock.timer` | systemd-Timer: beim Booten + einmal taeglich |
-| `install_aria_geoblock.sh` | Installer: kopiert alles nach `/opt/aria-geoblock`, richtet Timer ein (Testserver optional, siehe unten) |
+| `install_geoblock.sh` | Installer: kopiert alles nach `/opt/geoblock`, richtet Timer ein (Testserver optional, siehe unten) |
-| `aria_geoblock_checkmk` | checkmk local-check Plugin (manuell kopieren) |
+| `geoblock_checkmk` | checkmk local-check Plugin (manuell kopieren) |
-| `aria_geoblock_testserver.py` | Kleiner Test-Webserver, um die Regeln von aussen zu pruefen |
+| `geoblock_testserver.py` | Kleiner Test-Webserver, um die Regeln von aussen zu pruefen |
-| `aria-geoblock-testserver.service` | systemd-Unit, startet den Test-Webserver dauerhaft |
+| `geoblock-testserver.service` | systemd-Unit, startet den Test-Webserver dauerhaft |
-| `uninstall_aria_geoblock.sh` | Deinstaller: raeumt Timer/Service/Testserver/Regeln wieder ab (siehe unten) |
+| `uninstall_geoblock.sh` | Deinstaller: raeumt Timer/Service/Testserver/Regeln wieder ab (siehe unten) |
 
 ## Installation
 
@@ -30,36 +30,36 @@ Auf dem zu schuetzenden Host (root, `iptables`+`ipset`+`python3` installiert):
 ```bash
 git clone https://git.hacker-net.de/Aria-Software/geoblocking-python-script.git
 cd geoblocking-python-script
-sudo ./install_aria_geoblock.sh
+sudo ./install_geoblock.sh
 ```
 
 Das:
-- installiert `aria_geoblock.py` + `aria_geoblock.ini` nach `/opt/aria-geoblock/`
+- installiert `geoblock.py` + `geoblock.ini` nach `/opt/geoblock/`
   (bestehende `.ini` wird NICHT ueberschrieben, neue landet als `.example`)
-- legt `/var/log/aria_geoblock/` an
+- legt `/var/log/geoblock/` an
-- installiert + aktiviert `aria-geoblock.timer` (`systemctl enable --now`)
+- installiert + aktiviert `geoblock.timer` (`systemctl enable --now`)
 
 **Der Test-Webserver wird standardmaessig NICHT installiert.** Wer ihn
 braucht (siehe Abschnitt "Verbindungstest" unten), haengt die Option
 `--with-testserver` an:
 
 ```bash
-sudo ./install_aria_geoblock.sh --with-testserver
+sudo ./install_geoblock.sh --with-testserver
 # optional mit eigenem Zielverzeichnis:
-sudo ./install_aria_geoblock.sh --with-testserver /opt/aria-geoblock
+sudo ./install_geoblock.sh --with-testserver /opt/geoblock
 ```
 
-Nur dann wird `aria_geoblock_testserver.py` kopiert und
+Nur dann wird `geoblock_testserver.py` kopiert und
-`aria-geoblock-testserver.service` installiert + gestartet (offener Port
+`geoblock-testserver.service` installiert + gestartet (offener Port
 8899 standardmaessig). Ohne die Option bleibt der Port zu — nachtraeglich
 installieren geht jederzeit per erneutem Aufruf mit `--with-testserver`.
 
-Danach `/opt/aria-geoblock/aria_geoblock.ini` anpassen (Laenderliste!) und
+Danach `/opt/geoblock/geoblock.ini` anpassen (Laenderliste!) und
 einmal manuell testen:
 
 ```bash
-sudo systemctl start aria-geoblock.service
+sudo systemctl start geoblock.service
-journalctl -u aria-geoblock.service -f
+journalctl -u geoblock.service -f
 ```
 
 Der Timer laeuft danach automatisch: **~2 Minuten nach jedem Systemstart**
@@ -69,28 +69,28 @@ werden dank `Persistent=true` beim naechsten Boot nachgeholt.
 
 ## Deinstallation
 
-`uninstall_aria_geoblock.sh` macht die Installation wieder rueckgaengig.
+`uninstall_geoblock.sh` macht die Installation wieder rueckgaengig.
 Zwei Modi:
 
 ```bash
 # Alles runter: Timer/Service, Testserver (falls installiert),
 # iptables/ipset-Regeln, Installationsverzeichnis
-sudo ./uninstall_aria_geoblock.sh
+sudo ./uninstall_geoblock.sh
 
 # Nur den Test-Webserver entfernen, Geoblocking selbst bleibt aktiv
-sudo ./uninstall_aria_geoblock.sh --testserver-only
+sudo ./uninstall_geoblock.sh --testserver-only
 ```
 
 Weitere Optionen:
 
 ```bash
-sudo ./uninstall_aria_geoblock.sh --purge-logs        # zusaetzlich /var/log/aria_geoblock loeschen
+sudo ./uninstall_geoblock.sh --purge-logs        # zusaetzlich /var/log/geoblock loeschen
-sudo ./uninstall_aria_geoblock.sh /opt/aria-geoblock   # abweichendes Zielverzeichnis (Default: /opt/aria-geoblock)
+sudo ./uninstall_geoblock.sh /opt/geoblock   # abweichendes Zielverzeichnis (Default: /opt/geoblock)
 ```
 
 Ohne `--purge-logs` bleiben die bisherigen Logs unter
-`/var/log/aria_geoblock` erhalten. Bei der Komplett-Deinstallation wird
+`/var/log/geoblock` erhalten. Bei der Komplett-Deinstallation wird
-VOR dem Loeschen automatisch `aria_geoblock.py --remove` ausgefuehrt, damit
+VOR dem Loeschen automatisch `geoblock.py --remove` ausgefuehrt, damit
 die iptables-Regel und das `ipset` sauber aus dem Kernel entfernt werden
 (kein verwaistes DROP, keine offene Verbindung bleibt blockiert). Fehlen
 Script/Config bereits, wird gewarnt und man sollte manuell pruefen:
@@ -103,10 +103,10 @@ ipset list -n | grep -i geoblock
 ## Manuelle Nutzung (ohne systemd)
 
 ```bash
-sudo python3 aria_geoblock.py --config aria_geoblock.ini --apply            # aktivieren/aktualisieren
+sudo python3 geoblock.py --config geoblock.ini --apply            # aktivieren/aktualisieren
-sudo python3 aria_geoblock.py --config aria_geoblock.ini --apply --dry-run  # nur simulieren
+sudo python3 geoblock.py --config geoblock.ini --apply --dry-run  # nur simulieren
-sudo python3 aria_geoblock.py --config aria_geoblock.ini --status           # Zustand pruefen
+sudo python3 geoblock.py --config geoblock.ini --status           # Zustand pruefen
-sudo python3 aria_geoblock.py --config aria_geoblock.ini --remove           # rueckgaengig
+sudo python3 geoblock.py --config geoblock.ini --remove           # rueckgaengig
 ```
 
 `--apply` ist idempotent (kein doppeltes Anlegen von Regeln) und tauscht
@@ -120,18 +120,18 @@ frischen `--apply`-Lauf, das reicht in der Praxis meist aus.
 
 ## Verbindungstest (Test-Webserver)
 
-`aria_geoblock_testserver.py` ist ein winziger HTTP-Server ohne
+`geoblock_testserver.py` ist ein winziger HTTP-Server ohne
 Abhaengigkeiten (nur Python-Stdlib). Er beantwortet jeden Request mit einer
 kleinen Info-Seite (Client-IP, Zeitstempel, User-Agent) und loggt jeden
 Request. Er weiss selbst NICHTS von Laendern/Blocklisten — der eigentliche
 Test ist der Netzwerkeffekt: **geblockte** IPs erreichen ihn gar nicht erst
 (iptables droppt vor dem TCP-Handshake), **erlaubte** IPs bekommen die Seite.
 
-Wird nur installiert, wenn `install_aria_geoblock.sh` mit der Option
+Wird nur installiert, wenn `install_geoblock.sh` mit der Option
 `--with-testserver` aufgerufen wurde (Default: nicht installiert, siehe
 Abschnitt "Installation" oben). Ist er installiert, laeuft er als
-`aria-geoblock-testserver.service` auf Port `8899` (einstellbar unter
+`geoblock-testserver.service` auf Port `8899` (einstellbar unter
-`[testserver]` in `aria_geoblock.ini`, siehe unten).
+`[testserver]` in `geoblock.ini`, siehe unten).
 
 **Testablauf:**
 
@@ -139,9 +139,9 @@ Abschnitt "Installation" oben). Ist er installiert, laeuft er als
 # 1) Von einem ERLAUBTEN Netz/Land aus aufrufen -> sollte laden
 curl http://<host>:8899/
 
-# 2) Testweise den eigenen Laendercode (z.B. DE) in aria_geoblock.ini
+# 2) Testweise den eigenen Laendercode (z.B. DE) in geoblock.ini
 #    eintragen und aktivieren:
-sudo python3 aria_geoblock.py --config aria_geoblock.ini --apply
+sudo python3 geoblock.py --config geoblock.ini --apply
 
 # 3) Jetzt von einem Client MIT einer IP aus diesem Land connecten
 #    (z.B. Handy im Mobilfunknetz) -> sollte jetzt TIMEOUT geben
@@ -153,10 +153,10 @@ curl --max-time 5 http://<host>:8899/
 Manuell ohne systemd starten:
 
 ```bash
-python3 aria_geoblock_testserver.py --config aria_geoblock.ini
+python3 geoblock_testserver.py --config geoblock.ini
 # oder komplett ohne .ini:
-python3 aria_geoblock_testserver.py --port 8899 --bind 0.0.0.0 \
+python3 geoblock_testserver.py --port 8899 --bind 0.0.0.0 \
-    --log-file /var/log/aria_geoblock/testserver.log
+    --log-file /var/log/geoblock/testserver.log
 ```
 
 Requests landen (Zeit, Client-IP, Methode/Pfad, User-Agent) in der unter
@@ -202,33 +202,33 @@ Variante stehen.
 
 ## Logging
 
-In `aria_geoblock.ini` unter `log_file` einen Pfad eintragen (Default:
+In `geoblock.ini` unter `log_file` einen Pfad eintragen (Default:
-`/var/log/aria_geoblock/aria_geoblock.log`, wird vom Installer angelegt).
+`/var/log/geoblock/geoblock.log`, wird vom Installer angelegt).
 Bei jedem Lauf wird eine Zeile angehaengt, u.a. eine maschinenlesbare
 `RESULT status=OK/ERROR ...`-Zeile — genau die wertet das checkmk-Plugin
 aus. Leer lassen = keine Datei-Logs (nur stderr/systemd-Journal).
 
 ## checkmk-Monitoring
 
-`aria_geoblock_checkmk` ist ein klassisches checkmk **local check**-Plugin
+`geoblock_checkmk` ist ein klassisches checkmk **local check**-Plugin
 (kein extra Agent-Plugin-Verzeichnis noetig). Manuell einrichten:
 
 1. Im Script-Kopf `LOG_FILE` auf den Pfad aus der `.ini` (`log_file`) anpassen.
 2. Ausfuehrbar machen und kopieren:
    ```bash
-   chmod 755 aria_geoblock_checkmk
+   chmod 755 geoblock_checkmk
-   cp aria_geoblock_checkmk /usr/lib/check_mk_agent/local/
+   cp geoblock_checkmk /usr/lib/check_mk_agent/local/
    ```
    (Pfad haengt vom Setup ab — bei OMD-Sites z.B.
    `~/local/lib/check_mk_agent/local/`.)
-3. Naechster Agent-Abruf zeigt den Service **ARIA_Geoblock**.
+3. Naechster Agent-Abruf zeigt den Service **Geoblock**.
 
 Status-Logik: `ERROR` im letzten Lauf → CRIT. Letzter erfolgreicher Lauf
 > 36h alt → WARN, > 72h alt → CRIT (Timer laeuft taeglich, das faengt
 einen einzelnen verpassten Lauf ab, ohne sofort zu alarmieren). Sonst OK,
 inkl. Perfdata (Alter in Sekunden, Anzahl geblockter IP-Bereiche).
 
-## Konfiguration (`aria_geoblock.ini`)
+## Konfiguration (`geoblock.ini`)
 
 Siehe Kommentare in der Datei selbst — kurz:
 
@@ -246,7 +246,7 @@ Siehe Kommentare in der Datei selbst — kurz:
 - `protocol`: nur relevant wenn `ports` gesetzt ist — `tcp` (Default), `udp`
   oder `tcp,udp`
 
-Abschnitt `[testserver]` (fuer `aria_geoblock_testserver.py`):
+Abschnitt `[testserver]` (fuer `geoblock_testserver.py`):
 
 - `port`: TCP-Port des Test-Webservers (Default `8899`)
 - `bind`: Bind-Adresse (`0.0.0.0` = alle IPv4-Interfaces)
@@ -282,7 +282,7 @@ zum jeweiligen Host aufbaut — unabhaengig davon, was in HTTP-Headern steht.
 
 **Praktische Konsequenz fuer den Verbindungstest:**
 
-Um den Testserver (`aria_geoblock_testserver.py`, siehe oben) sinnvoll von
+Um den Testserver (`geoblock_testserver.py`, siehe oben) sinnvoll von
 aussen zu testen, muss er entweder:
 
 1. selbst direkt mit einer oeffentlichen IP/Port erreichbar sein (kein Proxy

geoblock-testserver.service

@@ -1,17 +1,17 @@
 [Unit]
-Description=ARIA Geoblocking - Test-Webserver fuer Verbindungstests von aussen
+Description=Geoblocking - Test-Webserver fuer Verbindungstests von aussen
 Documentation=https://git.hacker-net.de/Aria-Software/geoblocking-python-script
 After=network-online.target
 Wants=network-online.target
-ConditionPathExists=__INSTALL_DIR__/aria_geoblock.ini
+ConditionPathExists=__INSTALL_DIR__/geoblock.ini
 
 [Service]
 Type=simple
 User=root
-ExecStart=/usr/bin/python3 __INSTALL_DIR__/aria_geoblock_testserver.py --config __INSTALL_DIR__/aria_geoblock.ini
+ExecStart=/usr/bin/python3 __INSTALL_DIR__/geoblock_testserver.py --config __INSTALL_DIR__/geoblock.ini
 Restart=on-failure
 RestartSec=5
-# Laeuft dauerhaft (kein oneshot wie aria-geoblock.service) - beantwortet
+# Laeuft dauerhaft (kein oneshot wie geoblock.service) - beantwortet
 # Requests solange der Host laeuft. Port/Bind/Log kommen aus [testserver]
 # in der .ini. User=root nur wegen evtl. niedriger Portnummer/Log-Verzeichnis-
 # Rechten - wer will kann hier einen unprivilegierten User eintragen, sofern

geoblock.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-aria_geoblock.py — Geoblocking via ipset + iptables
+geoblock.py — Geoblocking via ipset + iptables
 
 Liest eine .ini-Datei mit einer Laenderliste, laedt die zugehoerigen
 IP-Bereiche (CIDR) kostenlos von ipdeny.com (kein API-Key noetig) und
@@ -15,26 +15,26 @@ WARUM ipset+iptables statt "Verbindung live pruefen":
     schon auf Netzwerk-Ebene, bevor sie den Server ueberhaupt erreichen.
   - Das ist der Standard-Ansatz den auch fail2ban/CSF-Firewalls nutzen.
 
-VORAUSSETZUNGEN (auf dem Ziel-Host, NICHT im ARIA-Container):
+VORAUSSETZUNGEN (auf dem Ziel-Host, NICHT im Container):
   - root-Rechte (iptables/ipset aendern den Kernel-Netfilter)
   - Pakete installiert: iptables, ipset
       Debian/Ubuntu: apt install iptables ipset
   - Internetzugang zum Laden der Zonefiles von ipdeny.com
 
 BENUTZUNG:
-  sudo python3 aria_geoblock.py --config geoblock.ini --apply
+  sudo python3 geoblock.py --config geoblock.ini --apply
       -> laedt IP-Ranges, befuellt das ipset, setzt die iptables-Regel
 
-  sudo python3 aria_geoblock.py --config geoblock.ini --apply --dry-run
+  sudo python3 geoblock.py --config geoblock.ini --apply --dry-run
       -> zeigt nur an was gemacht wuerde, aendert nichts
 
-  sudo python3 aria_geoblock.py --config geoblock.ini --remove
+  sudo python3 geoblock.py --config geoblock.ini --remove
       -> entfernt die iptables-Regel und loescht das ipset wieder
 
-  sudo python3 aria_geoblock.py --config geoblock.ini --status
+  sudo python3 geoblock.py --config geoblock.ini --status
       -> zeigt aktuellen Stand (Set vorhanden? wie viele Eintraege? Regel aktiv?)
 
-.ini-Format siehe mitgelieferte aria_geoblock.ini (Beispiel).
+.ini-Format siehe mitgelieferte geoblock.ini (Beispiel).
 
 LOGGING:
   Jeder Lauf schreibt nach stderr (systemd-Journal). Zusaetzlich kann in
@@ -44,8 +44,8 @@ LOGGING:
   diese Zeile wertet das mitgelieferte checkmk-Plugin aus.
 
 AUTOMATISCH AKTUELL HALTEN (Systemstart + taeglich):
-  Siehe systemd/aria-geoblock.service + aria-geoblock.timer sowie
+  Siehe systemd/geoblock.service + geoblock.timer sowie
-  install_aria_geoblock.sh im gleichen Repo — das richtet Timer fuer
+  install_geoblock.sh im gleichen Repo — das richtet Timer fuer
   "beim Booten" + "einmal taeglich" automatisch ein.
   --apply ist idempotent: es flusht das bestehende Set und befuellt es neu,
   legt aber KEINE doppelte iptables-Regel an (wird vorher geprueft).
@@ -56,7 +56,7 @@ PORT-EINSCHRAENKUNG (optional):
   auf bestimmte Anwendungen/Ports eingrenzen — z.B. nur den Testserver
   (8899) blocken, waehrend SSH (22) fuer die Laender offen bleibt. Praktisch
   zum gefahrlosen Testen, damit man sich nicht selbst aussperrt. Siehe
-  Kommentare in aria_geoblock.ini.
+  Kommentare in geoblock.ini.
 """
 
 import argparse
@@ -99,7 +99,7 @@ def log(msg):
 def log_result(status, action, countries=None, entries=None, msg=""):
     """Schreibt eine strukturierte, maschinenlesbare Ergebniszeile.
 
-    Wird vom checkmk-Plugin (aria_geoblock_checkmk) ausgewertet, um den
+    Wird vom checkmk-Plugin (geoblock_checkmk) ausgewertet, um den
     Zustand des letzten Laufs zu beurteilen (OK/WARN/CRIT/UNKNOWN).
     """
     parts = [f"RESULT ts={_timestamp()}", f"status={status}", f"action={action}"]

geoblock.service

@@ -1,12 +1,12 @@
 [Unit]
-Description=ARIA Geoblocking - Laender-IP-Sperrliste aktualisieren (ipset+iptables)
+Description=Geoblocking - Laender-IP-Sperrliste aktualisieren (ipset+iptables)
 Documentation=https://git.hacker-net.de/Aria-Software/geoblocking-python-script
 After=network-online.target
 Wants=network-online.target
-ConditionPathExists=__INSTALL_DIR__/aria_geoblock.ini
+ConditionPathExists=__INSTALL_DIR__/geoblock.ini
 
 [Service]
 Type=oneshot
 User=root
-ExecStart=/usr/bin/python3 __INSTALL_DIR__/aria_geoblock.py --config __INSTALL_DIR__/aria_geoblock.ini --apply
+ExecStart=/usr/bin/python3 __INSTALL_DIR__/geoblock.py --config __INSTALL_DIR__/geoblock.ini --apply
 # iptables/ipset aendern den Kernel-Netfilter, braucht root (siehe User=root oben)

geoblock.timer

@@ -1,8 +1,8 @@
 [Unit]
-Description=ARIA Geoblocking - beim Systemstart + einmal taeglich aktualisieren
+Description=Geoblocking - beim Systemstart + einmal taeglich aktualisieren
 
 [Timer]
-# Einmal kurz nach dem Booten (Netzwerk muss stehen -> aria-geoblock.service
+# Einmal kurz nach dem Booten (Netzwerk muss stehen -> geoblock.service
 # wartet selbst per After=network-online.target)
 OnBootSec=2min
 # Und danach einmal taeglich
@@ -11,7 +11,7 @@ OnCalendar=daily
 RandomizedDelaySec=15min
 # Verpasste Laeufe (Host war aus) beim naechsten Boot nachholen
 Persistent=true
-Unit=aria-geoblock.service
+Unit=geoblock.service
 
 [Install]
 WantedBy=timers.target

geoblock_checkmk

@@ -1,23 +1,23 @@
 #!/usr/bin/env python3
 """
-checkmk local check: ARIA Geoblocking
+checkmk local check: Geoblocking
 
-Wertet die Log-Datei von aria_geoblock.py aus und meldet an checkmk, ob
+Wertet die Log-Datei von geoblock.py aus und meldet an checkmk, ob
 der letzte Lauf (systemd-Timer: beim Boot + taeglich) erfolgreich und
 aktuell war.
 
 INSTALLATION:
-  1. LOG_FILE unten auf den Pfad anpassen, der in der aria_geoblock.ini
+  1. LOG_FILE unten auf den Pfad anpassen, der in der geoblock.ini
      unter [geoblock] log_file konfiguriert ist (Default passt zum
-     mitgelieferten install_aria_geoblock.sh).
+     mitgelieferten install_geoblock.sh).
   2. Datei ausfuehrbar machen und ins checkmk-Agent local-Verzeichnis legen:
-       cp aria_geoblock_checkmk /usr/lib/check_mk_agent/local/
+       cp geoblock_checkmk /usr/lib/check_mk_agent/local/
-       chmod 755 /usr/lib/check_mk_agent/local/aria_geoblock_checkmk
+       chmod 755 /usr/lib/check_mk_agent/local/geoblock_checkmk
      (Pfad haengt von Distro/Checkmk-Setup ab - ueblich sind
       /usr/lib/check_mk_agent/local/ oder bei OMD-Sites
       ~/local/lib/check_mk_agent/local/. Bei Bedarf: 'check_mk_agent' Pfad
       des jeweiligen Hosts pruefen.)
-  3. Naechster Agent-Abruf zeigt den Service "ARIA_Geoblock" in checkmk.
+  3. Naechster Agent-Abruf zeigt den Service "Geoblock" in checkmk.
 
 AUSGABE-LOGIK:
   - Keine Log-Datei / keine RESULT-Zeile gefunden -> UNKNOWN (3)
@@ -32,17 +32,17 @@ import os
 import re
 import time
 
-# --- Anpassen: muss zum log_file-Pfad aus der aria_geoblock.ini passen ---
+# --- Anpassen: muss zum log_file-Pfad aus der geoblock.ini passen ---
-LOG_FILE = "/var/log/aria_geoblock/aria_geoblock.log"
+LOG_FILE = "/var/log/geoblock/geoblock.log"
 
 # Timer laeuft taeglich -> grosszuegig bemessen, damit ein einzelner
 # verpasster Lauf (Host kurz aus) nicht sofort CRIT ausloest.
 WARN_AGE_SEC = 36 * 3600   # 36h
 CRIT_AGE_SEC = 72 * 3600   # 72h
 
-SERVICE_NAME = "ARIA_Geoblock"
+SERVICE_NAME = "Geoblock"
 
-# Beispiel-Zeile in der Log-Datei (von aria_geoblock.py log_result() geschrieben):
+# Beispiel-Zeile in der Log-Datei (von geoblock.py log_result() geschrieben):
 # 2026-07-21T10:00:00+02:00 [geoblock] RESULT ts=2026-07-21T10:00:00+02:00
 #   status=OK action=apply countries=4 entries=123456 msg="Geoblock aktualisiert (..)"
 RESULT_RE = re.compile(
@@ -59,7 +59,7 @@ def emit(status, perfdata, text):
 
 def main():
     if not os.path.isfile(LOG_FILE):
-        emit(3, "-", f"Log-Datei nicht gefunden ({LOG_FILE}) - lief aria_geoblock.py schon einmal mit --apply?")
+        emit(3, "-", f"Log-Datei nicht gefunden ({LOG_FILE}) - lief geoblock.py schon einmal mit --apply?")
         return
 
     last_match = None
@@ -74,7 +74,7 @@ def main():
         return
 
     if not last_match:
-        emit(3, "-", f"Keine RESULT-Zeile in {LOG_FILE} gefunden - lief aria_geoblock.py schon mit --apply?")
+        emit(3, "-", f"Keine RESULT-Zeile in {LOG_FILE} gefunden - lief geoblock.py schon mit --apply?")
         return
 
     ts_raw = last_match.group("ts")

geoblock_testserver.py

@@ -1,12 +1,12 @@
 #!/usr/bin/env python3
 """
-aria_geoblock_testserver.py — kleiner Test-Webserver fuer aria-geoblock
+geoblock_testserver.py — kleiner Test-Webserver fuer geoblock
 
 ZWECK:
   Ein minimaler HTTP-Server (nur Python-Stdlib, keine Abhaengigkeiten),
   gegen den man von AUSSEN (Handy im Mobilfunknetz, VPN mit anderem Land,
   Freund im Ausland, ...) connecten kann, um zu pruefen ob die Geoblocking-
-  Regeln (ipset/iptables aus aria_geoblock.py) wirklich greifen.
+  Regeln (ipset/iptables aus geoblock.py) wirklich greifen.
 
   Die Logik ist bewusst simpel: der Server selbst weiss NICHTS von Laendern
   oder Blocklisten. Er beantwortet einfach jeden Request, der ihn erreicht,
@@ -20,24 +20,24 @@ ZWECK:
   Land/Netz laedt die Seite ganz normal.
 
   Testablauf (siehe auch README.md):
-    1. Testserver starten (systemd-Service aria-geoblock-testserver, oder
+    1. Testserver starten (systemd-Service geoblock-testserver, oder
        manuell: siehe unten).
     2. Von einem Client aus einem ERLAUBTEN Land/Netz aufrufen:
          curl http://<host>:<port>/
        -> sollte die Test-Seite liefern.
-    3. Ziel-Land testweise in aria_geoblock.ini eintragen (z.B. den eigenen
+    3. Ziel-Land testweise in geoblock.ini eintragen (z.B. den eigenen
-       Ländercode DE), aria_geoblock.py --apply ausfuehren, dann von einem
+       Ländercode DE), geoblock.py --apply ausfuehren, dann von einem
        Client MIT dieser Landes-IP erneut connecten
        -> sollte jetzt in ein Timeout laufen (kein TCP-Connect möglich).
     4. Land wieder aus der .ini entfernen, --apply, Zugriff geht wieder.
 
 BENUTZUNG:
-  python3 aria_geoblock_testserver.py --config aria_geoblock.ini
+  python3 geoblock_testserver.py --config geoblock.ini
       -> Port/Bind-Adresse/Log-Pfad kommen aus dem Abschnitt [testserver]
-         der .ini (siehe aria_geoblock.ini im gleichen Repo)
+         der .ini (siehe geoblock.ini im gleichen Repo)
 
-  python3 aria_geoblock_testserver.py --port 8899 --bind 0.0.0.0 \
+  python3 geoblock_testserver.py --port 8899 --bind 0.0.0.0 \
-      --log-file /var/log/aria_geoblock/testserver.log
+      --log-file /var/log/geoblock/testserver.log
       -> alternativ komplett ohne .ini, per CLI-Argumenten
 
   CLI-Argumente ueberschreiben, falls angegeben, die Werte aus der .ini.
@@ -49,8 +49,8 @@ LOGGING:
   geloggt.
 
 AUTOSTART:
-  Siehe aria-geoblock-testserver.service im gleichen Repo sowie
+  Siehe geoblock-testserver.service im gleichen Repo sowie
-  install_aria_geoblock.sh, das den Service optional mit einrichtet.
+  install_geoblock.sh, das den Service optional mit einrichtet.
 """
 
 import argparse
@@ -91,9 +91,9 @@ def log(msg):
 
 
 def load_config(path):
-    """Liest [testserver] aus der aria_geoblock.ini. Fehlt der Abschnitt
+    """Liest [testserver] aus der geoblock.ini. Fehlt der Abschnitt
     komplett, werden die Defaults benutzt (die .ini ist fuer den Testserver
-    also optional, im Gegensatz zu aria_geoblock.py)."""
+    also optional, im Gegensatz zu geoblock.py)."""
     cfg = configparser.ConfigParser()
     read_ok = cfg.read(path)
     if not read_ok:
@@ -131,7 +131,7 @@ PAGE_TMPL = """<!DOCTYPE html>
 <html lang="de">
 <head>
 <meta charset="utf-8">
-<title>ARIA Geoblock — Verbindungstest</title>
+<title>Geoblock — Verbindungstest</title>
 <style>
   body {{ font-family: -apple-system, Segoe UI, Roboto, sans-serif;
          background: #0b1220; color: #e6ebf5; margin: 0;
@@ -158,7 +158,7 @@ PAGE_TMPL = """<!DOCTYPE html>
       <tr><td class="k">User-Agent</td><td>{ua}</td></tr>
       <tr><td class="k">Host-Header</td><td>{host}</td></tr>
     </table>
-    <p class="hint">Kommt eine Anfrage aus einem in aria_geoblock.ini geblockten Land,
+    <p class="hint">Kommt eine Anfrage aus einem in geoblock.ini geblockten Land,
     sieht dieser Server sie gar nicht erst — iptables droppt sie vorher.
     Der Client bekommt dann ein Timeout statt dieser Seite.</p>
   </div>
@@ -168,7 +168,7 @@ PAGE_TMPL = """<!DOCTYPE html>
 
 
 class TestHandler(BaseHTTPRequestHandler):
-    server_version = "ARIA-Geoblock-Testserver/1.0"
+    server_version = "Geoblock-Testserver/1.0"
 
     def log_message(self, format, *args):
         # Default-Logging von BaseHTTPRequestHandler unterdruecken,
@@ -220,7 +220,7 @@ def main():
 
     parser = argparse.ArgumentParser(
         description="Kleiner Test-Webserver um Geoblocking-Regeln von aussen zu pruefen")
-    parser.add_argument("--config", help="Pfad zur aria_geoblock.ini (Abschnitt [testserver])")
+    parser.add_argument("--config", help="Pfad zur geoblock.ini (Abschnitt [testserver])")
     parser.add_argument("--port", type=int, help="TCP-Port (ueberschreibt .ini)")
     parser.add_argument("--bind", help="Bind-Adresse (ueberschreibt .ini)")
     parser.add_argument("--log-file", help="Pfad zur Request-Log-Datei (ueberschreibt .ini)")

install_aria_geoblock.sh

@@ -1,137 +0,0 @@
-#!/usr/bin/env bash
-# ARIA Geoblocking - Installer
-#
-# Installiert aria_geoblock.py + .ini nach /opt/aria-geoblock (oder ein
-# anderes Zielverzeichnis), legt das Log-Verzeichnis an und richtet einen
-# systemd-Timer ein, der den Block beim Systemstart UND einmal taeglich
-# aktualisiert.
-#
-# Nutzung (als root, im Verzeichnis mit allen Repo-Dateien):
-#   sudo ./install_aria_geoblock.sh [--with-testserver] [ZIELVERZEICHNIS]
-#
-# Der kleine Test-Webserver (aria_geoblock_testserver.py +
-# aria-geoblock-testserver.service), gegen den man von aussen connecten
-# kann um die Geoblocking-Regeln zu pruefen, wird NUR installiert wenn
-# die Option --with-testserver angegeben wird. Ohne die Option passiert
-# in Sachen Testserver gar nichts (kein Copy, kein systemd-Unit, kein
-# offener Port).
-#
-# Beispiele:
-#   sudo ./install_aria_geoblock.sh
-#   sudo ./install_aria_geoblock.sh --with-testserver
-#   sudo ./install_aria_geoblock.sh --with-testserver /opt/aria-geoblock
-#   sudo ./install_aria_geoblock.sh /opt/aria-geoblock
-#
-# Benoetigt im selben Verzeichnis:
-#   aria_geoblock.py
-#   aria_geoblock.ini
-#   aria-geoblock.service
-#   aria-geoblock.timer
-#   (nur bei --with-testserver:)
-#   aria_geoblock_testserver.py
-#   aria-geoblock-testserver.service
-#
-# Voraussetzungen auf dem Host: python3, iptables, ipset, systemd.
-
-set -euo pipefail
-
-if [[ $EUID -ne 0 ]]; then
-    echo "Bitte als root ausfuehren (sudo ./install_aria_geoblock.sh)." >&2
-    exit 1
-fi
-
-SRC_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-WITH_TESTSERVER=0
-INSTALL_DIR=""
-for arg in "$@"; do
-    case "$arg" in
-        --with-testserver)
-            WITH_TESTSERVER=1
-            ;;
-        -h|--help)
-            grep '^# ' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
-            exit 0
-            ;;
-        *)
-            INSTALL_DIR="$arg"
-            ;;
-    esac
-done
-INSTALL_DIR="${INSTALL_DIR:-/opt/aria-geoblock}"
-LOG_DIR="/var/log/aria_geoblock"
-
-REQUIRED_FILES=(aria_geoblock.py aria_geoblock.ini aria-geoblock.service aria-geoblock.timer)
-if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
-    REQUIRED_FILES+=(aria_geoblock_testserver.py aria-geoblock-testserver.service)
-fi
-
-for f in "${REQUIRED_FILES[@]}"; do
-    if [[ ! -f "$SRC_DIR/$f" ]]; then
-        echo "FEHLER: $f fehlt in $SRC_DIR - bitte komplettes Repo verwenden." >&2
-        exit 1
-    fi
-done
-
-for bin in python3 iptables ipset systemctl; do
-    if ! command -v "$bin" >/dev/null 2>&1; then
-        echo "FEHLER: '$bin' ist nicht installiert. Bitte nachinstallieren (z.B. apt install iptables ipset)." >&2
-        exit 1
-    fi
-done
-
-echo "==> Installiere Script + Config nach $INSTALL_DIR"
-mkdir -p "$INSTALL_DIR"
-cp "$SRC_DIR/aria_geoblock.py" "$INSTALL_DIR/aria_geoblock.py"
-chmod 755 "$INSTALL_DIR/aria_geoblock.py"
-
-if [[ -f "$INSTALL_DIR/aria_geoblock.ini" ]]; then
-    echo "==> Bestehende $INSTALL_DIR/aria_geoblock.ini gefunden - wird NICHT ueberschrieben."
-    cp "$SRC_DIR/aria_geoblock.ini" "$INSTALL_DIR/aria_geoblock.ini.example"
-    echo "    Neue Beispiel-Config liegt unter $INSTALL_DIR/aria_geoblock.ini.example (zum Vergleich)."
-else
-    cp "$SRC_DIR/aria_geoblock.ini" "$INSTALL_DIR/aria_geoblock.ini"
-    echo "    -> bitte $INSTALL_DIR/aria_geoblock.ini pruefen/anpassen (Laenderliste!)."
-fi
-
-echo "==> Lege Log-Verzeichnis an: $LOG_DIR"
-mkdir -p "$LOG_DIR"
-chmod 750 "$LOG_DIR"
-
-echo "==> Installiere systemd-Units (Geoblock-Timer)"
-sed "s#__INSTALL_DIR__#$INSTALL_DIR#g" "$SRC_DIR/aria-geoblock.service" \
-    > /etc/systemd/system/aria-geoblock.service
-cp "$SRC_DIR/aria-geoblock.timer" /etc/systemd/system/aria-geoblock.timer
-
-if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
-    echo "==> --with-testserver gesetzt: installiere Test-Webserver nach $INSTALL_DIR"
-    cp "$SRC_DIR/aria_geoblock_testserver.py" "$INSTALL_DIR/aria_geoblock_testserver.py"
-    chmod 755 "$INSTALL_DIR/aria_geoblock_testserver.py"
-
-    sed "s#__INSTALL_DIR__#$INSTALL_DIR#g" "$SRC_DIR/aria-geoblock-testserver.service" \
-        > /etc/systemd/system/aria-geoblock-testserver.service
-else
-    echo "==> Test-Webserver wird NICHT installiert (Option --with-testserver nicht angegeben)."
-fi
-
-systemctl daemon-reload
-systemctl enable --now aria-geoblock.timer
-
-if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
-    systemctl enable --now aria-geoblock-testserver.service
-fi
-
-echo ""
-echo "==> Fertig."
-echo "    Config anpassen:      $INSTALL_DIR/aria_geoblock.ini"
-echo "    Jetzt sofort testen:  systemctl start aria-geoblock.service && journalctl -u aria-geoblock.service -f"
-echo "    Timer-Status:         systemctl list-timers aria-geoblock.timer"
-echo "    Naechste/letzte Läufe: systemctl status aria-geoblock.timer"
-echo "    Log-Datei:             $LOG_DIR/aria_geoblock.log"
-if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
-    echo "    Test-Webserver:        systemctl status aria-geoblock-testserver.service"
-    echo "                           Port/Bind/Log siehe [testserver] in $INSTALL_DIR/aria_geoblock.ini"
-else
-    echo "    Test-Webserver:        nicht installiert (spaeter nachruesten mit: sudo $0 --with-testserver $INSTALL_DIR)"
-fi
-echo "    checkmk-Plugin:        siehe aria_geoblock_checkmk im Repo (manuell kopieren, README beachten)"

install_geoblock.sh

@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+# Geoblocking - Installer
+#
+# Installiert geoblock.py + .ini nach /opt/geoblock (oder ein
+# anderes Zielverzeichnis), legt das Log-Verzeichnis an und richtet einen
+# systemd-Timer ein, der den Block beim Systemstart UND einmal taeglich
+# aktualisiert.
+#
+# Nutzung (als root, im Verzeichnis mit allen Repo-Dateien):
+#   sudo ./install_geoblock.sh [--with-testserver] [ZIELVERZEICHNIS]
+#
+# Der kleine Test-Webserver (geoblock_testserver.py +
+# geoblock-testserver.service), gegen den man von aussen connecten
+# kann um die Geoblocking-Regeln zu pruefen, wird NUR installiert wenn
+# die Option --with-testserver angegeben wird. Ohne die Option passiert
+# in Sachen Testserver gar nichts (kein Copy, kein systemd-Unit, kein
+# offener Port).
+#
+# Beispiele:
+#   sudo ./install_geoblock.sh
+#   sudo ./install_geoblock.sh --with-testserver
+#   sudo ./install_geoblock.sh --with-testserver /opt/geoblock
+#   sudo ./install_geoblock.sh /opt/geoblock
+#
+# Benoetigt im selben Verzeichnis:
+#   geoblock.py
+#   geoblock.ini
+#   geoblock.service
+#   geoblock.timer
+#   (nur bei --with-testserver:)
+#   geoblock_testserver.py
+#   geoblock-testserver.service
+#
+# Voraussetzungen auf dem Host: python3, iptables, ipset, systemd.
+
+set -euo pipefail
+
+if [[ $EUID -ne 0 ]]; then
+    echo "Bitte als root ausfuehren (sudo ./install_geoblock.sh)." >&2
+    exit 1
+fi
+
+SRC_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+WITH_TESTSERVER=0
+INSTALL_DIR=""
+for arg in "$@"; do
+    case "$arg" in
+        --with-testserver)
+            WITH_TESTSERVER=1
+            ;;
+        -h|--help)
+            grep '^# ' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+            exit 0
+            ;;
+        *)
+            INSTALL_DIR="$arg"
+            ;;
+    esac
+done
+INSTALL_DIR="${INSTALL_DIR:-/opt/geoblock}"
+LOG_DIR="/var/log/geoblock"
+
+REQUIRED_FILES=(geoblock.py geoblock.ini geoblock.service geoblock.timer)
+if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
+    REQUIRED_FILES+=(geoblock_testserver.py geoblock-testserver.service)
+fi
+
+for f in "${REQUIRED_FILES[@]}"; do
+    if [[ ! -f "$SRC_DIR/$f" ]]; then
+        echo "FEHLER: $f fehlt in $SRC_DIR - bitte komplettes Repo verwenden." >&2
+        exit 1
+    fi
+done
+
+for bin in python3 iptables ipset systemctl; do
+    if ! command -v "$bin" >/dev/null 2>&1; then
+        echo "FEHLER: '$bin' ist nicht installiert. Bitte nachinstallieren (z.B. apt install iptables ipset)." >&2
+        exit 1
+    fi
+done
+
+echo "==> Installiere Script + Config nach $INSTALL_DIR"
+mkdir -p "$INSTALL_DIR"
+cp "$SRC_DIR/geoblock.py" "$INSTALL_DIR/geoblock.py"
+chmod 755 "$INSTALL_DIR/geoblock.py"
+
+if [[ -f "$INSTALL_DIR/geoblock.ini" ]]; then
+    echo "==> Bestehende $INSTALL_DIR/geoblock.ini gefunden - wird NICHT ueberschrieben."
+    cp "$SRC_DIR/geoblock.ini" "$INSTALL_DIR/geoblock.ini.example"
+    echo "    Neue Beispiel-Config liegt unter $INSTALL_DIR/geoblock.ini.example (zum Vergleich)."
+else
+    cp "$SRC_DIR/geoblock.ini" "$INSTALL_DIR/geoblock.ini"
+    echo "    -> bitte $INSTALL_DIR/geoblock.ini pruefen/anpassen (Laenderliste!)."
+fi
+
+echo "==> Lege Log-Verzeichnis an: $LOG_DIR"
+mkdir -p "$LOG_DIR"
+chmod 750 "$LOG_DIR"
+
+echo "==> Installiere systemd-Units (Geoblock-Timer)"
+sed "s#__INSTALL_DIR__#$INSTALL_DIR#g" "$SRC_DIR/geoblock.service" \
+    > /etc/systemd/system/geoblock.service
+cp "$SRC_DIR/geoblock.timer" /etc/systemd/system/geoblock.timer
+
+if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
+    echo "==> --with-testserver gesetzt: installiere Test-Webserver nach $INSTALL_DIR"
+    cp "$SRC_DIR/geoblock_testserver.py" "$INSTALL_DIR/geoblock_testserver.py"
+    chmod 755 "$INSTALL_DIR/geoblock_testserver.py"
+
+    sed "s#__INSTALL_DIR__#$INSTALL_DIR#g" "$SRC_DIR/geoblock-testserver.service" \
+        > /etc/systemd/system/geoblock-testserver.service
+else
+    echo "==> Test-Webserver wird NICHT installiert (Option --with-testserver nicht angegeben)."
+fi
+
+systemctl daemon-reload
+systemctl enable --now geoblock.timer
+
+if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
+    systemctl enable --now geoblock-testserver.service
+fi
+
+echo ""
+echo "==> Fertig."
+echo "    Config anpassen:      $INSTALL_DIR/geoblock.ini"
+echo "    Jetzt sofort testen:  systemctl start geoblock.service && journalctl -u geoblock.service -f"
+echo "    Timer-Status:         systemctl list-timers geoblock.timer"
+echo "    Naechste/letzte Läufe: systemctl status geoblock.timer"
+echo "    Log-Datei:             $LOG_DIR/geoblock.log"
+if [[ "$WITH_TESTSERVER" -eq 1 ]]; then
+    echo "    Test-Webserver:        systemctl status geoblock-testserver.service"
+    echo "                           Port/Bind/Log siehe [testserver] in $INSTALL_DIR/geoblock.ini"
+else
+    echo "    Test-Webserver:        nicht installiert (spaeter nachruesten mit: sudo $0 --with-testserver $INSTALL_DIR)"
+fi
+echo "    checkmk-Plugin:        siehe geoblock_checkmk im Repo (manuell kopieren, README beachten)"

uninstall_geoblock.sh

@@ -1,32 +1,32 @@
 #!/usr/bin/env bash
-# ARIA Geoblocking - Deinstaller
+# Geoblocking - Deinstaller
 #
-# Macht die Installation von install_aria_geoblock.sh wieder rueckgaengig.
+# Macht die Installation von install_geoblock.sh wieder rueckgaengig.
 # Standardmaessig wird ALLES entfernt: Timer/Service, ggf. der Testserver,
 # die iptables/ipset-Regeln und das Installationsverzeichnis. Mit
 # --testserver-only wird NUR der Test-Webserver entfernt, das eigentliche
 # Geoblocking (Timer, Regeln, Config) bleibt unangetastet.
 #
 # Nutzung (als root):
-#   sudo ./uninstall_aria_geoblock.sh [--testserver-only] [--purge-logs] [ZIELVERZEICHNIS]
+#   sudo ./uninstall_geoblock.sh [--testserver-only] [--purge-logs] [ZIELVERZEICHNIS]
 #
 # Beispiele:
-#   sudo ./uninstall_aria_geoblock.sh                        # alles runter
+#   sudo ./uninstall_geoblock.sh                        # alles runter
-#   sudo ./uninstall_aria_geoblock.sh --testserver-only       # nur Testserver runter
+#   sudo ./uninstall_geoblock.sh --testserver-only       # nur Testserver runter
-#   sudo ./uninstall_aria_geoblock.sh --purge-logs            # alles + Logs loeschen
+#   sudo ./uninstall_geoblock.sh --purge-logs            # alles + Logs loeschen
-#   sudo ./uninstall_aria_geoblock.sh /opt/aria-geoblock       # abweichendes Zielverzeichnis
+#   sudo ./uninstall_geoblock.sh /opt/geoblock       # abweichendes Zielverzeichnis
 #
-# Ohne --purge-logs bleibt /var/log/aria_geoblock erhalten (falls vorhanden),
+# Ohne --purge-logs bleibt /var/log/geoblock erhalten (falls vorhanden),
 # damit alte Laeufe/Fehler weiter nachvollziehbar sind.
 #
 # Ohne --testserver-only werden VOR dem Entfernen der Regeln automatisch
-# "aria_geoblock.py --remove" ausgefuehrt, damit iptables/ipset sauber
+# "geoblock.py --remove" ausgefuehrt, damit iptables/ipset sauber
 # aufgeraeumt werden (kein verwaistes DROP, kein verwaistes ipset).
 
 set -euo pipefail
 
 if [[ $EUID -ne 0 ]]; then
-    echo "Bitte als root ausfuehren (sudo ./uninstall_aria_geoblock.sh)." >&2
+    echo "Bitte als root ausfuehren (sudo ./uninstall_geoblock.sh)." >&2
     exit 1
 fi
 
@@ -50,8 +50,8 @@ for arg in "$@"; do
             ;;
     esac
 done
-INSTALL_DIR="${INSTALL_DIR:-/opt/aria-geoblock}"
+INSTALL_DIR="${INSTALL_DIR:-/opt/geoblock}"
-LOG_DIR="/var/log/aria_geoblock"
+LOG_DIR="/var/log/geoblock"
 
 stop_disable_rm_unit() {
     local unit="$1"
@@ -68,8 +68,8 @@ stop_disable_rm_unit() {
 # --- Nur Testserver entfernen -----------------------------------------------
 if [[ "$TESTSERVER_ONLY" -eq 1 ]]; then
     echo "==> --testserver-only: entferne NUR den Test-Webserver, Geoblocking bleibt aktiv"
-    stop_disable_rm_unit "aria-geoblock-testserver.service"
+    stop_disable_rm_unit "geoblock-testserver.service"
-    rm -f "$INSTALL_DIR/aria_geoblock_testserver.py"
+    rm -f "$INSTALL_DIR/geoblock_testserver.py"
     systemctl daemon-reload
     echo ""
     echo "==> Fertig. Testserver entfernt, Geoblock-Timer/Regeln unveraendert."
@@ -77,29 +77,29 @@ if [[ "$TESTSERVER_ONLY" -eq 1 ]]; then
 fi
 
 # --- Komplett-Deinstallation -------------------------------------------------
-echo "==> Deinstalliere ARIA Geoblocking komplett ($INSTALL_DIR)"
+echo "==> Deinstalliere Geoblocking komplett ($INSTALL_DIR)"
 
 # Testserver zuerst (falls vorhanden), damit kein Dienst mehr auf die
 # Config/das Verzeichnis zugreift, waehrend wir aufraeumen.
-stop_disable_rm_unit "aria-geoblock-testserver.service"
+stop_disable_rm_unit "geoblock-testserver.service"
-rm -f "$INSTALL_DIR/aria_geoblock_testserver.py"
+rm -f "$INSTALL_DIR/geoblock_testserver.py"
 
 # iptables/ipset-Regeln sauber abbauen, SOLANGE Script+Config noch da sind.
-if [[ -f "$INSTALL_DIR/aria_geoblock.py" && -f "$INSTALL_DIR/aria_geoblock.ini" ]]; then
+if [[ -f "$INSTALL_DIR/geoblock.py" && -f "$INSTALL_DIR/geoblock.ini" ]]; then
-    echo "==> Entferne iptables/ipset-Regeln (aria_geoblock.py --remove)"
+    echo "==> Entferne iptables/ipset-Regeln (geoblock.py --remove)"
     if command -v python3 >/dev/null 2>&1; then
-        python3 "$INSTALL_DIR/aria_geoblock.py" --config "$INSTALL_DIR/aria_geoblock.ini" --remove || \
+        python3 "$INSTALL_DIR/geoblock.py" --config "$INSTALL_DIR/geoblock.ini" --remove || \
             echo "WARNUNG: --remove ist fehlgeschlagen - iptables/ipset ggf. manuell pruefen (iptables -L, ipset list)." >&2
     else
         echo "WARNUNG: python3 nicht gefunden - Regeln konnten nicht automatisch entfernt werden. Manuell pruefen (iptables -L, ipset list)." >&2
     fi
 else
-    echo "WARNUNG: $INSTALL_DIR/aria_geoblock.py oder .ini nicht gefunden - ueberspringe automatischen Regel-Abbau. Manuell pruefen (iptables -L, ipset list)." >&2
+    echo "WARNUNG: $INSTALL_DIR/geoblock.py oder .ini nicht gefunden - ueberspringe automatischen Regel-Abbau. Manuell pruefen (iptables -L, ipset list)." >&2
 fi
 
 echo "==> Stoppe/deaktiviere Timer + Service"
-stop_disable_rm_unit "aria-geoblock.timer"
+stop_disable_rm_unit "geoblock.timer"
-stop_disable_rm_unit "aria-geoblock.service"
+stop_disable_rm_unit "geoblock.service"
 
 systemctl daemon-reload
 
@@ -116,7 +116,7 @@ else
 fi
 
 echo ""
-echo "==> Fertig. ARIA Geoblocking wurde komplett deinstalliert."
+echo "==> Fertig. Geoblocking wurde komplett deinstalliert."
 echo "    Kurze Kontrolle falls gewuenscht:"
 echo "      iptables -L -n | grep -i geoblock"
 echo "      ipset list -n | grep -i geoblock"