# BEH:Wiki # Headless sourcing-fähige Snippets Hier werden kleine Helferscripte vorgeführt, die in Scripten included oder per if-then abgefragt werden können. # mailer (Bash) Dieser Mailer schickt einfach eine Mail vom System aus. Dabei muss darauf geachtet werden, dass der Server Mails versenden kann mit "mail". Es schickt je nach Einstellung eine Text-Mail oder Mail mit Anhang. Der Rückgabewert besagt, ob die Mail erfolgreich versendet wurde - oder nicht. Eigener Anwendungsfall: Einfacher Text, Bestätigungscode, Link, Nachricht. HOWTO: ```bash $0 -f "/var/file.png" -e mail@domain.tld -s "Betreff" $0 -t "Text" -m mail@domain.tld -s "Betreff" # -e ODER -m = Mailadresse ``` Beispiel: ```bash # Direktaufruf (Tests) mailer.sh -e "mail@domain.tld" -s "Testbetreff" -t "Hallo, ich bin ein Test!" # im Script empfaenger="mail@domain.tld" betreff="Testbetreff" nachricht="Hallo, ich bin ein Test!" if bash lib/mailer.sh -e "$empfaenger" -s "$betreff" -t "$nachricht"; then echo "Mail erfolgreich gesendet" else echo "Fehler beim Mailversand" fi ``` Script: ```bash #!/bin/bash while [[ $# -gt 0 ]]; do case "$1" in -f) file="$2"; shift 2 ;; -t) text="$2"; shift 2 ;; -e|-m) mail="$2"; shift 2 ;; -s) subj="$2"; shift 2 ;; esac done if [ -z "$mail" ] || [ -z "$subj" ]; then echo "ERROR" exit 1 fi if [ -n "$file" ] && [ -z "$text" ]; then cat "$file" | mail -s "$subj" "$mail" elif [ -n "$text" ] && [ -z "$file" ]; then echo "$text" | mail -s "$subj" "$mail" else echo "ERROR" exit 1 fi exit 0 ``` # mailer (Python3) Dieser Mailer schickt einfach eine Mail vom System aus. Dabei muss darauf geachtet werden, dass der Server Mails versenden kann mit "mail". Es schickt je nach Einstellung eine Text-Mail oder Mail mit Anhang. Der Rückgabewert besagt, ob die Mail erfolgreich versendet wurde - oder nicht. Eigener Anwendungsfall: Einfacher Text, Bestätigungscode, Link, Nachricht. HOWTO: ```python python3 $0 -f "/var/file.png" -e mail@domain.tld -s "Betreff" python3 $0 -t "Text" -m mail@domain.tld -s "Betreff" # -e ODER -m = Mailadresse ``` Beispiel: ```python import subprocess empfaenger = "mail@domain.tld" betreff = "Testbetreff" nachricht = "Hallo, ich bin ein Test!" try: result = subprocess.run( ['python3', 'lib/mailer.py', '-e', empfaenger, '-s', betreff, '-t', nachricht], check=True ) print("Mail erfolgreich gesendet") except subprocess.CalledProcessError: print("Fehler beim Mailversand") ``` Script: ```python #!/usr/bin/env python3 import sys import subprocess args = sys.argv[1:] file = None text = None mail = None subj = None # Argument-Parsing i = 0 while i < len(args): if args[i] == '-f': file = args[i + 1] i += 2 elif args[i] == '-t': text = args[i + 1] i += 2 elif args[i] in ['-e', '-m']: mail = args[i + 1] i += 2 elif args[i] == '-s': subj = args[i + 1] i += 2 else: i += 1 # Fehlerprüfung if not mail or not subj: print("ERROR") sys.exit(1) # Mailversand if file and not text: try: subprocess.run(['mail', '-s', subj, mail], input=open(file, 'rb').read(), check=True) except Exception as e: print("Fehler beim Senden:", e) sys.exit(1) elif text and not file: try: subprocess.run(['mail', '-s', subj, mail], input=text.encode(), check=True) except Exception as e: print("Fehler beim Senden:", e) sys.exit(1) else: print("ERROR") sys.exit(1) ``` # fillortrim.sh (Bash) Auffüllen oder trimmen von einem Text auf X Zeichen. Es erzeugt kein typischer Rückgabewert, sondern gibt den Text bearbeitet aus. Klassischer Anwendungsfall: textbasierte Tabelle, bei der ein Text immer die gleiche Länge haben soll, um eine sinnvolle, visuelle Tabelle zu bilden. HOWTO: ```bash $0 $var $length $0 "Hallo ich bin ein Beispiel" 24 # immer 24 Zeichen ``` Beispiel: ```bash var="Hallo ich bin ein Beispiel" length="24" filltext=$(bash lib/fillortrim.sh "$var" "$length") echo "|...|$formfilltext|...|" ``` Script: ```bash #!/bin/bash var="$1" length=${#var} while [ $length -lt "$2" ]; do var="$var " ((length++)) done var="${var:0:$2}" echo "$var" exit 0 ``` # fillortrim.sh (Python3) Auffüllen oder trimmen von einem Text auf X Zeichen. Es erzeugt kein typischer Rückgabewert, sondern gibt den Text bearbeitet aus. Klassischer Anwendungsfall: textbasierte Tabelle, bei der ein Text immer die gleiche Länge haben soll, um eine sinnvolle, visuelle Tabelle zu bilden. HOWTO: ```python python3 $0 $var $length python3 $0 "Hallo ich bin ein Beispiel" 24 # immer 24 Zeichen ``` Beispiel: ```python var = "Hallo ich bin ein Beispiel" length = 24 formfilltext = var.ljust(length)[:length] print(f"|...|{formfilltext}|...|") ``` Script: ```python import sys def fill_or_trim(var, length): # Füllen bis zur gewünschten Länge while len(var) < length: var += " " # Abschneiden auf die gewünschte Länge var = var[:length] return var if __name__ == "__main__": if len(sys.argv) != 3: print("Usage: python fillortrim.py ") sys.exit(1) var = sys.argv[1] length = int(sys.argv[2]) result = fill_or_trim(var, length) print(result) ``` # dabch2hz.sh Ausgabe von DAB-Kanal in Hertz. Ideal für Scripte, die einen Kanal übergeben und den Rückgabewert verarbeiten. Eigener Anwendungsfall: Frequenzumrechnung in Verbindung mit einem HackRF. Der Rückgabewert ist Hertz. HOWTO: ```bash $0 12D ``` Beispiel: ```bash ch="12D" freq=$(bash lib/dabch2hz.sh "$ch") # Hier kann mit $freq weitergearbeitet werden ``` Script: ```bash #!/bin/bash ch=$(echo "$1" | sed 's/\([A-Z]\)/\L\1/g') case "$ch" in 5a) freq="174928000" ;; 5b) freq="176640000" ;; 5c) freq="178352000" ;; 5d) freq="180064000" ;; 6a) freq="181936000" ;; 6b) freq="183648000" ;; 6c) freq="185360000" ;; 6d) freq="187072000" ;; 7a) freq="188928000" ;; 7b) freq="190640000" ;; 7c) freq="192352000" ;; 7d) freq="194064000" ;; 8a) freq="195936000" ;; 8b) freq="197648000" ;; 8c) freq="199360000" ;; 8d) freq="201072000" ;; 9a) freq="202928000" ;; 9b) freq="204640000" ;; 9c) freq="206352000" ;; 9d) freq="208064000" ;; 10a) freq="209936000" ;; 10n) freq="210096000" ;; 10b) freq="211648000" ;; 10c) freq="213360000" ;; 10d) freq="215072000" ;; 11a) freq="216928000" ;; 11n) freq="217088000" ;; 11b) freq="218640000" ;; 11c) freq="220352000" ;; 11d) freq="222064000" ;; 12a) freq="223936000" ;; 12n) freq="224096000" ;; 12b) freq="225648000" ;; 12c) freq="227360000" ;; 12d) freq="229072000" ;; 13a) freq="230784000" ;; 13b) freq="232496000" ;; 13c) freq="234208000" ;; 13d) freq="235776000" ;; 13e) freq="237488000" ;; 13f) freq="239200000" ;; la) freq="1452960000" ;; lb) freq="1454672000" ;; lc) freq="1456384000" ;; ld) freq="1458096000" ;; le) freq="1459808000" ;; lf) freq="1461520000" ;; lg) freq="1463232000" ;; lh) freq="1464944000" ;; li) freq="1466656000" ;; lj) freq="1468368000" ;; lk) freq="1470080000" ;; ll) freq="1471792000" ;; lm) freq="1473504000" ;; ln) freq="1475216000" ;; lo) freq="1476928000" ;; lp) freq="1478640000" ;; 2a) freq="47936000" ;; 2b) freq="49648000" ;; 2c) freq="51360000" ;; 2d) freq="53072000" ;; 3a) freq="54928000" ;; 3b) freq="56640000" ;; 3c) freq="58352000" ;; 3d) freq="60064000" ;; 4a) freq="61936000" ;; 4b) freq="63648000" ;; 4c) freq="65360000" ;; 4d) freq="67072000" ;; esac echo "$freq" exit 0 ``` # fm2hz.sh Ausgabe einer Frequenz von FM in Hertz. Ideal für Scripte, die eine Frequenz übergeben und den Rückgabewert verarbeiten. Es ist egal, ob die Frequenz mit Punkt oder Komma geschrieben wird. Eigener Anwendungsfall: Frequenzumrechnung in Verbindung mit einem HackRF. Der Rückgabewert ist Hertz. HOWTO: ```bash $0 89.7 ``` Beispiel: ```bash # Eingabe-Beispiele eingabe="89.7" eingabe="106,4" eingabe="102.70" freq=$(bash lib/fm2hz.sh "$eingabe") # Hier kann mit $freq weitergearbeitet werden ``` Script: ```bash #!/bin/bash input=$(echo "$1" | sed 's/,/./g') if [[ "$input" == *.* ]]; then integer_part=$(echo "$input" | cut -d'.' -f1) decimal_part=$(echo "$input" | cut -d'.' -f2) else integer_part=$input decimal_part="" fi freq="${integer_part}${decimal_part}" zeros_to_add=$((6 - ${#decimal_part})) while [ $zeros_to_add -gt 0 ]; do freq="${freq}0" ((zeros_to_add--)) done echo "$freq" exit 0 ``` # checkpackage.sh Es wird geprüft, ob übergebene System-Packages installiert sind. Kann auf mehreren Distros verwendet werden: Debian, Red Hat, Arch, OpenSUSE und alle Derivate davon. Der Rückgabewert ist 0 (true) oder 1 (false). HOWTO: ```bash $0 wget ``` Beispiel: ```bash if [ "$(bash lib/checkpackage.sh wget)" = "0" ]; then echo "installiert" else echo "nicht installiert" fi ```
Script: ```bash #!/bin/bash if [ -f /etc/debian_version ]; then # Debian-based if dpkg -s "$1" &> /dev/null; then echo "0" else echo "1" fi elif [ -f /etc/redhat-release ]; then # Red Hat-based if rpm -q "$1" &> /dev/null; then echo "0" else echo "1" fi elif [ -f /etc/arch-release ]; then # Arch-based if pacman -Qi "$1" &> /dev/null; then echo "0" else echo "1" fi elif [ -f /etc/SuSE-release ]; then # openSUSE if zypper se --installed-only "$1" &> /dev/null; then echo "0" else echo "1" fi else echo "Unsupported Linux distribution" exit 1 fi exit 0 ``` # picorvid.sh Ausgabe des Typs einer Webcam/Kamera. Ist es ein Bild oder Video - der Rückgabewert ist zur Weiterverarbeitung. Dabei ist der Rückgabewert wie folgt: 0 = Bild 1 = Video 2 = nicht unterstützt 3 = Fehler/ungültig. Die Weiterverarbeitung ist mit ffmpeg oder wget/curl ideal, wenn man vorher einsortieren muss, um welchen Typ es sich handelt. Bilder lassen sich wie gewohnt herunterladen und ffmpeg kann Einzelbilder aus Streams extrahieren. HOWTO: ```bash $0 URL ``` Beispiel: ```bash url="http://192.168.1.10/video.cgi" typ=$(bash lib/picorvid.sh "$url") # VARIANTE 1 case "$typ" in 1) echo "MJPEG-Stream erkannt" ;; 0) echo "Einzelbild erkannt" ;; 2) echo "Bekannt, aber nicht unterstützt" ;; 3) echo "Ungültige oder unbekannte URL" ;; esac # VARIANTE 2 if [ "$typ" = "1" ]; then echo "Video/Stream" elif [ "$typ" = "0" ]; then echo "Bild" fi ``` Script: ```bash #!/bin/bash # Video if echo "$1" | grep -qE '\.mjpg|\.mjpeg|faststream|video\.cgi|GetOneShot|mjpg\.cgi|videostream\.cgi|\/image|\?action\=stream|\/cam_.\.cgi|\.r-kom\.de'; then echo "1" exit 0 # Bild elif echo "$1" | grep -qE 'snapshot\.cgi|SnapshotJPEG|\.jpg|api\.cgi|cgi-bin\/camera|alarmimage|oneshotimage|image\/Index|CGIProxy\.fcgi|nph-jpeg\.cgi|onvif\/snapshot|GetImage\.cgi'; then echo "0" exit 0 # nicht unterstützt elif echo "$1" | grep -qE 'GetData\.cgi|mjpeg\.cgi|\.png'; then echo "2" exit 0 else # ansonsten ungültig echo "3" exit 0 fi ``` # port.sh Gibt aus der übergebenen URL den Port aus. Falls keiner übergeben wurde, bezieht man sich auf den Standardport je nach HTTP oder HTTPS. http://abc.de:8080/test --> 8080 https://abc.de/test --> 443 http://abc.de/test --> 80 HOWTO: ```bash $0 URL ``` Beispiel: ```bash url="http://beispiel.de:8080/snapshot.cgi" port=$(bash src/port.sh "$url") echo "Verwendeter Port: $port" # --> 8080 ``` Script: ```bash #!/bin/bash url=$(echo "$1" | sed ':a; s/\([^ ]\) /\1%20/g; ta; s/^%20//; s/%20$//' | sed s'/ //'g) #zerlege URL in Adresse und Port addr=$(echo "$url" | grep -oP '^https?://\K[^:/]+') port=$(echo "$url" | grep -oP ':\K[0-9]+') #setze Standard-Port, wenn nicht anders angegeben if [ -z "$port" ]; then if echo "$url" | grep -q "https"; then port="443" else port="80" fi fi echo "$port" exit 0 ``` # rdm.sh Ausgabe einer random Zahl zwischen $1 und $2. Obergrenze: 32767, da RANDOM nicht mehr verarbeiten kann. HOWTO: ```bash $0 100 199 ``` Beispiel: ```bash min="100" max="199" zahl=$(bash lib/rdm.sh "$min" "$max") ``` Script: ```bash #!/bin/bash min=$1 max=$2 echo $((RANDOM % (max - min + 1) + min)) ``` # rdmfreqfm.sh Es entstehen $1 random Frequenzen in einer vordefinierten Range (FM). Es kann auch ein Abstand $2 zwischen den Frequenzen eingegeben werden. Dies eignet sich gut für Frequenzplanlogistik oder Experimente. HOWTO: ```bash $0 3 5 ``` Ausagabe: 88.1 107.5 97.7 Der Abstand $2 besagt, dass bei Eingabe von "2" bei einer Frequenz von 90.0 MHz NICHT 89.8, 89.9 und 90.1, 90.2 generiert werden darf. Beispiel: ```bash anzahl="3" abstand="5" # BEISPIEL 1 frequenzen=$(bash lib/rdmfreqfm.sh "$anzahl" "$abstand") # BEISPIEL 2 mapfile -t freqenzen < <(bash inc/gen_frequencies.sh "$anzahl" "$abstand") for f in "${frequenzen[@]}"; do echo "Frequenz: $f MHz" done ``` Script: ```bash #!/bin/bash count="$1" scope="$2" min="876" max="1079" max_attempts="500" # Maximale Anzahl von Versuchen, um eine nicht überlappende Zufallszahl zu finden if [ -z "$2" ]; then scope="3" fi generated_numbers=() function is_nearby { local number=$1 for n in "${generated_numbers[@]}"; do if (( number >= n - $scope && number <= n + $scope )); then return 1 fi done return 0 } while [ ${#generated_numbers[@]} -lt $count ]; do attempts=0 while true; do if (( attempts >= max_attempts )); then echo "ERROR" exit 1 fi random_number=$(shuf -i ${min}-${max} -n 1) if is_nearby $random_number; then generated_numbers+=($random_number) formatted_number=$(echo "$random_number" | sed 's/\(.*\)\(.\)$/\1.\2/') echo "$formatted_number" break else (( attempts++ )) fi done attempts=0 done ``` # rdsps.sh RDS wird generiert und fix auf 8 Zeichen gesetzt. Ideal für die Weitergabe an einen RDS-Decoder. Hier kann der Name/Text an $1 übergeben werden und ein Modus für Großbuchstaben eingeschaltet werden: $2=0 --> Großbuchstaben, $2=1 --> normal, wie Input. Bei kurzen Namen/Texten wird das RDS zentriert. Bei langen Namen/Texten wird das RDS gekapert auf 8 Zeichen. Untypische Zeichen fürs RDS werden ersetzt. HOWTO: ```bash input="Regio 8" mode=1 # oder 0 für erzwungene Großbuchstaben rds=$(bash lib/rdsps.sh "$input" "$mode") echo "RDS-PS: [$rds]" ``` Script: ```bash #!/bin/bash if [ "$2" = "1" ]; then # Entferne alle Zeichen außer Großbuchstaben, Zahlen und bestimmten Satzzeichen var=$(echo "$1" | sed 's/[^A-Za-z0-9.,!?*-]/_/g; s/ /_/g; s/Ä/A/g; s/Ö/O/g; s/Ü/U/g; s/ä/a/g; s/ö/o/g; s/ü/u/g') elif [ "$2" = "0" ]; then # Ersetze Kleinbuchstaben durch Großbuchstaben und entferne alle anderen nicht gewünschten Zeichen var=$(echo "$1" | sed 's/[a-z]/\U&/g' | sed 's/[^A-Z0-9.,!?*-]/_/g; s/ /_/g; s/Ä/A/g; s/Ö/O/g; s/Ü/U/g; s/ä/a/g; s/ö/o/g; s/ü/u/g') fi length=${#var} if [ "$length" = "1" ]; then echo "___${var}____" elif [ "$length" = "2" ]; then echo "___${var}___" elif [ "$length" = "3" ]; then echo "__${var}___" elif [ "$length" = "4" ]; then echo "__${var}__" elif [ "$length" = "5" ]; then echo "_${var}__" elif [ "$length" = "6" ]; then echo "_${var}_" elif [ "$length" = "7" ]; then echo "${var}_" elif [ "$length" = "8" ]; then echo "${var}" elif [ "$length" -ge "9" ]; then var="${var:0:8}" echo "$var" fi exit 0 ``` # runtxt.sh Hier kann ein Text $1 in einem textbasierten Programm durchlaufen. Hierbei lässt sich die Länge der anzuzeigenden Zeichen mit $2 bestimmen und die Schnelligkeit in ms in $3. Ideal für z. B. Displays mit begrenzter Ausgabelänge. Hier kann der Text ganz einfach durchlaufen. $1 --> Text, der gescrollt wird $2 --> Blockgröße (sichtbare Länge) $3 --> Pausenzeit pro Schritt (in ms) HOWTO: ```bash $0 "Hallo Welt!" 8 100 ``` Beispiel: ```bash text="System läuft normal, keine Vorkommnisse" display="16" ms="120" bash src/runtxt.sh "$text" "$display" "$ms" ``` Script: ```bash #!/bin/bash if [ -z "$3" ]; then exit 1 fi text="$1" block_size="$2" sleep_time=$(echo "scale=3; $3 / 1000" | bc) # Den Text erweitern, um eine ausreichende Anzahl von Leerzeichen für nahtloses Scrollen hinzuzufügen padded_text="$(printf '%*s' $block_size)${text}" padded_length=${#padded_text} while true; do for (( i=0; i
``` zip archiv.zip inhalt1 inhalt2 ```
Komplette Ordner in einem komprimierten Archiv zusammenfassen:
``` zip -r archiv.zip ordner1 ordner2 ordner3 ```
Komprimiertes Archiv entpacken:
``` unzip archiv.zip ```
Inhalt eines komprimierten Archivs anzeigen:
``` unzip -l archiv.zip ```
# bz2, bzip2 Neben gzip gibt es noch bzip2, es ist gzip sehr ähnlich, verwendet aber einen anderen Algorithmus. Eine Datei komprimieren:
``` bzip2 file ```
Datei dekomprimieren:
``` bunzip2 file.bz2 ```
Dateien in einem komprimierten Archiv zusammenfassen:
``` tar cfvj archiv.tar.bz2 inhalt1 inhalt2 ```
Archiv dekomprimieren und auspacken:
``` tar xfvj archiv.tar.bz2 ```
# gz, gzip Da ein tar-Archiv, wie oben erwähnt, ohne Zusatzoptionen nicht komprimiert ist, kann dies mit der Zusatzoption gzip geschehen. gzip steht für GNU zip und dem tar-Archiv wird die Dateiendung .gz angehängt. Eine Datei komprimieren:
``` gzip file ```
Datei dekomprimieren:
``` gunzip file ```
Dateien in einem komprimierten Archiv zusammenfassen:
``` tar cfvz archiv.tar.gz inhalt1 inhalt2 ```
Archiv dekomprimieren und auspacken:
``` tar xfvz archiv.tar.gz ```
# tar Das Programm tar steht ursprünglich für **T**ape **Ar**chiver, es wurde verwendet um Daten auf Bandlaufwerken zu sichern. Es ist heute noch sehr beliebt und verbreitet. Ein reines tar-Archiv ist **nicht** komprimiert. Entpacken eines Archivs:
``` tar xfv archiv.tar ```
Dateien/Ordner in ein Archiv packen:
``` tar cfv archiv.tar inhalt1 inhalt2 inhalt3 ```
Komprimierte Archive erstellen:
``` tar cfzv archiv.tar inhalt1 inhalt2 inhalt3 ```
Inhalt eines Archivs auflisten:
``` tar tfv archiv.tar ```
Legende: x = entpacken (extract) f = Datei (file) v = Details anzeigen (verbose) c = erstellen (create) # VPN-Server mit Wireguard / Side-to-Side-VPN / alles tunneln Es kann mehrere Gründe geben, einen VPN-Tunnel zu nutzen. Sei es zwecks der Anonymität, weil man geogeblockte Seiten öffnen möchte oder die normale Praxis - einfach nur, weil man auf der Gegenstelle einen Server hat, deren Dienste man sicher erreichen möchte. In unserem Fall möchten wir als IP gerne diese externe IP haben, sodass wir geogeblockte Seiten öffnen können. Als Server kommt ein V-Server in einem Rechenzentrum zum Einsatz (Debian), als Client ist es lokal ein LXC-Container in Proxmox (Ubuntu). Dies kann natürlich auch der lokale Rechner sein oder ein lokaler Laptop mit Linux drauf. Wir gehen davon aus, dass wir auf beiden Systemen root sind, ansonsten ist - in diesem Fall - vor **jedem** Befehl ein sudo zu setzen. ### Allgemein/Vorbereiten Dieser Abschnitt ist auf beiden Systemen auszuführen. Sollte das System recht frisch sein, ist unbedingt ein Aktualisieren der apt-Datenbank von nöten, in allen anderen Fällen kann es nicht schaden: ```bash apt update -y && apt upgrade -y ``` Ggf. Wireguard selbst installieren - sollte es nicht vorhanden sein: ```bash apt install wireguard ``` Als nächstes muss in der Datei */etc/sysctl.conf* unbedingt die Zeile *\#net.ipv4.ip\_forward=1* auskommentiert werden: ```bash nano /etc/sysctl.conf ``` aus ```bash #net.ipv4.ip_forward=1 ``` wird ```bash net.ipv4.ip_forward=1 ``` Als nächstes generieren wir die Schlüssel für den gegenseitigen Austausch: ```bash umask 077; wg genkey | tee /etc/wireguard/privatekey | wg pubkey > /etc/wireguard/publickey ``` Diesen lassen wir uns jeweils auf beiden Systemen anzeigen für die Konfigurationsdatei nachher: ```bash cat /etc/wireguard/privatekey && cat /etc/wireguard/publickey ``` ### Serverkonfiguration Als erstes fragen wir ab, welches Interface hardwareseitig benutzt wird. Dies ist meist eth0. Über dieses Interface soll nachher alles laufen. Dieses ist mit ```bash ip a ``` abzufragen. Nun beginnen wir mit der Erstellung der Konfigurationsdatei auf dem Server. Folgender Inhalt muss in die Wireguard-Konfiguration *wg0.conf*, wie wir sie hier nennen. Wenn ein anderer Name als wg0 verwendet wird, muss in allen Fällen, wo wir wg0 verwenden, natürlich der individuelle Name stehen. ```bash nano /etc/wireguard/wg0.conf ``` ```ini [Interface] PrivateKey = SERVER-PRIVATEKEY Address = 172.31.0.1/32 SaveConfig = true PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE ListenPort = 51820 [Peer] PublicKey = CLIENT-PUBLICKEY AllowedIPs = 172.31.0.2/32, X.X.X.X/XX ``` Hier gibt es einiges zu beachten. Der SERVER-PRIVATEKEY und CLIENT-PUBLICKEY muss mit den Keys vom Server und Clienten ersetzt werden. Das Interface ist zu beachten, wie oben beschrieben. Die IP-Adresse 172.31.0.1/32 suggeriert ein Netz, deren /32-Subnetz technischer Weise nur 2 IP-Adressen erlaubt. Nämlich Server (172.31.0.1) und Client (172.31.0.2). Diese beiden benutzen dieses Netz und kommunizieren über den Tunnel. Der Port 51820 ist der Wireguard-Standard-Port, kann aber geändert werden, muss aber dann natürlich auf beiden Seiten gleich sein. Die PostUp und PostDown-Zeilen bilden einfach die IPtables, wie wo was geroutet wird. Im Abschnitt Peer bei den Allowed IPs muss unbedingt die IP des Clienten enthalten sein, in diesem Fall eben 172.31.0.2/32. Für unseren Fall des Gateways ist es unbedingt erforderlich, das eigene Netz, welches wir daheim haben, dort einzusetzen. Haben wir die 192.168.1.6 als IP in einem /24er-Netz, ist, sofern das ganze Netz geroutet werden darf, die 192.168.1.0/24 stehen. Im Falle eines 172.20.2.86 als IP bei einem /16er-Netz, ist dort auch die 172.20.0.0/16 zu wählen. Einzelne IPs können auch gewählt werden, wenn nur ein Gerät durch den Tunnel sollte. ### Clientkonfiguration Wir legen auch auf dem Client die Konfigurationsdatei mit gleichem Namen wg0 an: ```bash nano /etc/wireguard/wg0.conf ``` ```ini [Interface] PrivateKey = CLIENT-PRIVATEKEY Address = 172.31.0.2/32 [Peer] PublicKey = SERVER-PUBLICKEY Endpoint = Adresse:51820 AllowedIPs = 0.0.0.0/0 PersistentKeepalive = 25 ``` Hier ist natürlich wieder zu beachten, dass die Keys entsprechend eingesetzt werden. Bei Adresse kann die IP des Servers oder auch eine Domain stehen. Die AllowedIPs mit dem Wert 0.0.0.0/0 sagt aus, dass alles über den VPN-Server geroutet wird, also auch Internet. Und da wir hier mit Wireguard im UDP-Protokoll unterwegs sind, gibt es keine Bestätigung der Verbindung. Demzufolge muss permanent der PersistentKeepalive abgefragt werden, hier alle 25 Sekunden. ### Abschluss
Sollte der Dienst nach einem Neustart eines der beiden Systemen automatisch wieder starten, ist folgender Befehl abzusetzen:
[![Screenshot_2023-05-18_094530.png](https://wiki.mariobeh.de/uploads/images/gallery/2024-11/scaled-1680-/screenshot-2023-05-18-094530.png)](https://wiki.mariobeh.de/uploads/images/gallery/2024-11/screenshot-2023-05-18-094530.png)
War man erfolgreich, sollte dies bei [https://wieistmeineip.de](https://wieistmeineip.de/) erscheinen.
```bash systemctl enable wg-quick@wg0 ``` # Zeitumstellung via timedatectl Nach dem Installieren einiger Distributionen, insbesondere die des Raspberry Pi, kann es immer mal wieder vorkommen, dass sich die Zeitzone nicht von selbst einstellt. Abhilfe schafft folgender Befehl: ```bash sudo timedatectl set-timezone Europe/Berlin ``` Wobei "Europe/Berlin" dementsprechend anzupassen ist. Mit diesem Befehl ```bash timedatectl list-timezones ``` werden alle möglichen Timezones gelistet. Sonstige Tags: timezone # Systemdienst einrichten Um einen Systemdienst auf Linux einzurichten, um ihn als "service XYZ start" starten zu können, sind folgende Schritte nötig: Es wird davon ausgegangen, dass diese Schritte als sudo-Mitglied gemacht werden. `sudo nano /etc/systemd/system/dienst.service` Im einfachsten Fall reicht folgendes aus: ```ini [Unit] Description=Eigener Dienst [Service] WorkingDirectory=/srv ExecStart=/srv/script.sh arg1 arg2 User=scripter Restart=always [Install] WantedBy=multi-user.target ``` In einigen Fällen, vor allem wenn while-Schleifen zum Einsatz kommen, kann dies auch komplexer werden: ```ini [Unit] Description=Eigener dienst After=network.target Restart=always RestartSec=5 [Service] ExecStart=/srv/script.sh arg1 arg2 WorkingDirectory=/srv User=scripter Group=scripter Restart=always StandardOutput=journal StandardError=journal [Install] WantedBy=multi-user.target ``` Zum Schluss muss der Dienst noch aktiviert werden: `sudo systemctl enable dienst.service` Und anschließend kann der dienst gestartet und auf den Status geschaut werden: `sudo service dienst start` `sudo service dienst status` `sudo service dienst stop` # SSH Forwarding (Portweiterleitung via SSH) Oft ist man gezwungen, z. B. auf Proxmox zuzugreifen aber aus Sicherheitsgründen wird von einer öffentlichen Portfreigabe abgesehen. Demnach wäre eine Portweiterleitung nur über SSH interessant. Voraussetzung ist hier natürlich, dass SSH öffentlich freigegeben wurde. Dabei muss es nicht einmal direkt der Proxmox-Server, sondern es kann auch ein Zwischenserver, wie hier in diesem Beispiel erklärt wird, sein. Ein SSH Forwarding von Client zu Server funktioniert hier im Beispiel wie folgt. Der Client (localhost) möchte einen Port auf dem Server (lokal) öffnen. Hier wird zunächst ein SSH-Tunnel aufgebaut, der den Verkehr entsprechend portiert. ```bash ssh -N -L 443:localhost:8006 user@beispielserver.de -p 2222 ``` Hier wird der lokale Port 443 (HTTPS) auf dem am SERVER.DE befindlichen Port 8006 über SSH Port 2222 weitergeleitet. In diesem konkreten Beispiel lässt sich auf den Proxmox-Server zugreifen, ohne den Port nach außen hin öffnen zu müssen. Sollte ein Zwischenserver vorhanden sein, der vor Proxmox agiert, sodass Proxmox keinen SSH-Port öffentlich geöffnet haben muss, muss zudem sichergestellt sein, dass der Zwischenserver mit dem gleichen SSH Forwarding versehen ist, sodass am Zwischenserver der Port 8006 auch zum Proxmox-Server auf Port 8006 führt. Dieser ist mit ```bash ssh -N -L 8006:localhost:8006 sshuser@172.16.99.10 -p 22 ``` einzureichen. In diesem konkreten Beispiel wird eben der Port 8006 auf dem Zwischenserver auf die IP und ebenfalls Port 8006 weitergeleitet. Um diesen SSH Forwarding am Zwischenserver nicht immer aufmachen zu müssen, kann alternativ eine screen-Session mit genau dieser Portweiterleitung geschaffen werden oder idealer, die SSH-Verbindung im Hintergrund auszuführen mit ```bash ssh -f -N -L 8006:localhost:8006 sshuser@172.16.99.10 -p 22 ``` Auf dem Client kann auf die gleiche Weise agiert werden. Hinweis: Beim Standard-Port 22 kann diese Port-Angabe auch weggelassen werden. -L: local port forwarding -f: Hintergrund -N: kein einloggen erforderlich. Demzufolge kann auf dem Client mit folgender Adresse nun entfernt der Port 8006 aufgerufen werden: ```bash https://localhost ``` ```bash https://127.0.0.1 ``` Den HTTPS-Standardport :443 schenken wir uns in diesem Fall. # Root-Login verbieten Nach dem Installieren einiger Distributionen, insbesondere die des Raspberry Pi oder im Proxmox bei den LXC-Containern, ist es sicherheitsrelevant und deshalb erforderlich, wenn die Maschinen ans Netz gehen, dass der root-Login unterbunden wird. Dies wird in der Datei **/etc/ssh/sshd\_config** möglich gemacht. ```bash sudo nano /etc/ssh/sshd_config ``` Aus ```bash PermitRootLogin yes ``` wird ```bash PermitRootLogin no ``` und fertig. Anschließend den SSH-Dienst neustarten mit ```bash sudo service sshd restart ``` sshd = ssh daemon. Der root-Login ist somit nicht mehr möglich, es kann aber weiterhin als Benutzer mit ```bash su ``` in den root-Account gewechselt werden. Unabhängig davon kann in einigen [Distributionen](https://public.mariobeh.de/mediawiki/index.php?title=Distribution&action=edit&redlink=1 "Distribution (Seite nicht vorhanden)") mit ```bash sudo befehl ``` interagiert werden, sofern der Benutzer in der [sudoers](https://public.mariobeh.de/mediawiki/index.php/Benutzer_zum_sudo_(sudoers)_hinzuf%C3%BCgen "Benutzer zum sudo (sudoers) hinzufügen")-Tabelle gelistet ist. # PhpMyAdmin - Installation Verwendet man eine Datenbank und möchte nicht alles mit dem Terminal regeln, ist es oft sinnvoller, eine Datenbankkonfigurationssoftware herbei zu ziehen. Es bietet sich PhpMyAdmin an. In unserem Fall verwenden wir PhpMyAdmin mit MySQL8.0-Server, PHP8.3 und Apache2 als Webserver. Dateispeicherort wird der hauseigene Web-Pfad */var/www/html* verwendet. Ferner gibt es mehrere Möglichkeiten, das ganze auf Linux mit den Rechten zu verbinden, in unserem Beispielfall läuft PhpMyAdmin unter demselben Benutzer wie der Webserver. PHP, MySQL und Apache2 werden zuerst heruntergeladen, wenn noch nicht vorhanden: ```bash sudo apt install mysql-server php8.3 apache2 ``` Danach wechseln wir in unser Webverzeichnis: ```bash cd /var/www/html ``` In diesem könnte es Rechteprobleme geben. Dann einfach das Verzeichnis für den Web-Benutzer freigeben: ```bash sudo chown webuser:webuser -R /var/www/html ``` chown für *change owner* vom Verzeichnis */var/www/html*, das ganze rekursiv auf alle Unterverzeichnisse von dort, an den Benutzer *webuser* in der gleichnamigen Gruppe. Danach laden wir uns PhpMyAdmin auf der offiziellen Seite *phpmyadmin.net* herunter, direkt auf den Server. Bitte die Versionsnummer beachten. ```bash wget https://files.phpmyadmin.net/phpMyAdmin/5.2.1/phpMyAdmin-5.2.1-all-languages.zip ``` Dies entpacken wir dann an dieser Ort und Stelle. ... # PhpMyAdmin - Fehlermeldung Konfigurationsspeicher Bei einer recht frischen Installation von phpMyAdmin kann es vorkommen, dass folgender Fehler im Webinterface angezeigt wird: *Der phpMyAdmin-Konfigurationsspeicher ist nicht vollständig konfiguriert, einige erweiterte Funktionen wurden deaktiviert. Finden Sie heraus warum. Oder wechseln Sie in einer beliebigen Datenbank zum Tab "Operationen", um die Einstellung dort vorzunehmen.* *[![Screenshot_2023-05-17_214330.png](https://wiki.mariobeh.de/uploads/images/gallery/2024-11/scaled-1680-/screenshot-2023-05-17-214330.png) ](https://wiki.mariobeh.de/uploads/images/gallery/2024-11/screenshot-2023-05-17-214330.png) Screenshot der Fehlermeldung (v5.2.1)* Dieser Konfigurationsspeicher von phpMyAdmin benötigt eine eigene Datenbank oder eine eigene Tabelle auf dem MySQL-Server. Dies kann zur Abhilfe führen oder aber auch einfacher, diese Meldung ignorieren. Hierzu muss die Datei config.inc.php im root-Verzeichnis von phpMyAdmin editiert und am Ende davon folgendes eingefügt werden: ```bash $cfg['PmaNoRelation_DisableWarning'] = true; ``` Ist die individuelle Konfigurationsdatei *config.inc.php* nicht vorhanden, dann muss im ersten Schritt die *config.sample.inc.php* umbenannt, bzw. kopiert und dann editiert werden. Umbenennen: ```bash mv config.sample.inc.php config.inc.php ``` ..oder Kopieren: ```bash cp config.sample.inc.php config.inc.php ``` ..in allen Fällen bearbeiten: ```bash nano config.inc.php ``` # Mount - HDD/SSD mounten Um eine Festplatte/SSD im Terminal zu mounten, muss eine Voraussetzung gegeben sein. Als erstes muss die Platte ermittelt werden, wo sie zu finden ist in */dev/*. ```bash fdisk -l ``` bzw. - einfacher ist bei fortgeschrittenen Systemkenntnisse auch das hier: ```bash ls /dev/ | grep sd ``` Wir gehen davon aus, dass die Platte neu ist, bzw. neu erstellt wurde und es noch keine Formatierung gegeben hat. Ansonsten kann dieser Schritt übersprungen werden. Die Platte kann in ext4 (Linux), NTFS (Windows) oder andere Optionen formatiert werden. Hier sind zwei Beispiele: ```bash sudo mkfs.ext4 /dev/sdX ``` ```bash sudo mkfs.ntfs /dev/sdX ``` ...wobei das X in sdX ersetzt werden muss auf den Laufwerksbuchstaben, der vorher ermittelt wurde. Jetzt kann die Platte gemountet werden: ```bash sudo mount /dev/sdX /mnt/hdd ``` Der Zielpfad, hier */mnt/hdd*, kann natürlich individuell sein. Das Verzeichnis muss aber im Vorfeld bereits erstellt worden sein. ```bash sudo mkdir /mnt/hdd ``` Die Verwendung von sudo im letzten Schritt ist nicht immer erforderlich, da es auch in einem Benutzerordner stattfinden kann. Hier, bei */mnt/* wird aber sudo vorausgesetzt. # Benutzer zum sudo (sudoers) hinzufügen Um einen Benutzer in die sudo-Administration hinzuzufügen, reicht nach dem Erstellen des Benutzers mit ``` sudo adduser BENUTZER ``` folgender Befehl aus: ``` sudo usermod -aG sudo BENUTZER ``` # Apt-get Autocomplete / Autocompletion Teilweise kommt es unter einem frisch installiertem Linux vor, dass bei *apt* bzw. *apt-get* die Autokomplettierung mit der Tab-Taste nicht funktioniert. Um dies zu aktivieren, sind folgende Schritte nötig. Sudo wird ggf. benötigt, wenn kein root. ```bash sudo apt install bash-completion ``` Danach ist diese Datei ohne root-Rechte zu editieren. Diese Datei ist benutzerspezifisch und erfordert in keinem Fall sudo: ```bash nano ~/.bashrc ``` Inhalt am Ende der Datei einfügen: ```bash if [ -f /etc/bash_completion ]; then . /etc/bash_completion fi ``` Fertig. Normalerweise funktioniert die Autokomplettierung ohne erneutes Einloggen. # eigene Programme, headless Linux, Bash, Serversysteme. Diese Scripte nutzen ausnahmslos den Auslagerungsordner /home/$NAME/script-data/script-name/$0.Der Stand des Scripts ist in Klammern versehen der einzelnen Scripts.Die Distribution der Scripte findet sich ebenfalls in den Klammern. # IP Logger (Debian / 04.01.2024) Dieser IP Logger loggt die eigene IP-Adresse in eine CSV-Datei. Dies hat den Grund, dass man Vorwürfe jeder Art durch Vorlage der zu der Zeit genutzten IP-Adresse vorweisen könnte. Nützlich in Verbindung mit einem Cronjob. Das Script holt via "icanhazip.com" die aktuelle IP-Adresse und speichert sie in die CSV-Datei. Wenn via Cronjob das Script ausgeführt wird, empfehle ich den Intervall auf stündlich zu setzen. Eine Zeit von-bis einzubauen halte ich für nicht sinnvoll, da das Internet zu dieser Zeit auch ausfallen könnte. Daher halte ich es für nicht sinnvoll, die IP-Adresse zu speichern und erst bei Änderung erneut zu schreiben. ### 🧾 **Was macht das Script?** #### 📁 **Allgemeine Initialisierung:** - Bestimme den aktuellen Benutzer (`whoami`) - Setze `$data` auf: `/home//script-data/` (z. B. `/home/pi/script-data/iplogger.sh`) - Setze `$ippage` auf `icanhazip.com` - Hole aktuelle öffentliche IP via `curl` #### **📬 Benötigte Tools:** - `curl` - `nc` (netcat) - `sed`, `awk`, `grep`, `uniq` - Bash >= 4 Script: ```bash #!/bin/bash user=$(whoami) data="/home/$user/script-data/$(basename "$0")" ippage="icanhazip.com" ipneu=$(curl -s "$ippage") if [ ! -d "$data" ]; then mkdir -p "$data" fi if [ -n "$1" ] && [ "$1" = "suche" ]; then cat "$data/ipdb.csv" | sed 's/;/ /g' | sed 's/\([0-9]\{4\}\)-\([0-9]\{2\}\)-\([0-9]\{2\}\)/\3.\2.\1/' | grep "$2" | awk '{print $1, "", "", $3}' | uniq exit else if nc -z -w 1 "$ippage" 443 2>/dev/null; then echo "$(date +"%Y-%m-%d;%H:%M");$ipneu" >> "$data/ipdb.csv" echo "OK: $ipneu" else if nc -z -w 1 "google.de" 443 2>/dev/null; then echo "Fehler, $ippage nicht erreichbar." echo "$(date +"%Y-%m-%d;%H:%M");$ippage nicht erreichbar" >> "$data/ipdb.csv" else echo "Kein Internet." echo "$(date +"%Y-%m-%d;%H:%M");offline" >> "$data/ipdb.csv" fi fi fi ``` # M4A zu MP3 Massenumwandlung (Debian / 09.04.2025) Das Script wandelt rekursiv beginnend ab einem Pfad ($1) M4A-Audiodateien in MP3 um. Die Qualität bleibt nahezu gleich. Der Pfad ist dem $1-Argument zu übergeben. Die daraus entstehende MP3 ist gleichnamig wie die M4A Datei. ffmpeg und find werden dafür benötigt. Script: ```bash #!/bin/bash DIR="$1" if [ -z "$DIR" ] || [ ! -d "$DIR" ]; then echo "Usage: $0 /pfad/zum/verzeichnis" exit 1 fi find "$DIR" -type f -iname "*.m4a" | while read -r M4A; do MP3="${M4A%.m4a}.mp3" # Nur umwandeln, wenn mp3 nicht schon existiert if [ -f "$MP3" ]; then echo "Überspringe (bereits vorhanden): $MP3" continue fi echo "Wandle um: $M4A → $MP3" ffmpeg -i "$M4A" -codec:a libmp3lame -qscale:a 4 "$MP3" -y < /dev/null if [ $? -eq 0 ]; then echo "Erfolg: $MP3" else echo "Fehler bei: $M4A" fi done ``` # DynDNS Updater (Debian / 10.07.2024) Der DynDNS Updater aktualisiert eine DynDNS-Domain mit der aktuellen IP-Adresse. Wenn das Script zum ersten Mal ausgeführt wird, muss man die API zur Aktualisierung eingeben, die dieses Script dann aufruft. Diese API wird dann im script-data-Ordner gespeichert. **Genaue Zusammenfassung:** *data=/home/$USER/script-data/$0* Wenn noch keine IP vorhanden ist ($data/ip.txt), dann wird die IP-Adresse von "icanhazip.com" abgerufen. API wird aufgerufen, IP wurde aktualisiert. Jeder Schritt wird mitgeloggt in $data/allgemein.csv (besondere Ereignisse), tagesaktuell in $data/logs/YYYYMMTT.csv (Updates). ### 🧾 **Was macht das Script?** #### **📁 Lade bisherigen Status:** - Wenn `ip.txt` vorhanden ist, wird die bisherige öffentliche IP geladen. - Wenn nicht: → erste Ausführung → IP bleibt leer, Log-Eintrag in `allgemein.csv`. --- #### **🌐 Prüfe Update-URL:** - Wenn `updateurl.txt` existiert → lese erste Zeile ein. - Wenn nicht vorhanden: - Benutzer wird zur Eingabe einer gültigen `http(s)`-URL aufgefordert. - Wenn gültig: speichere in `updateurl.txt` & logge es. - Wenn ungültig: Abbruch & Fehlerlog. --- #### **📶 Online-Check:** - Ping an `icanhazip.com` (IPv4, 1 Paket, Timeout 3s) - Wenn erreichbar: - Hole neue IP mit `curl` - Vergleiche mit vorheriger IP - Unverändert: nur Statusmeldung - Geändert: - speichere neue IP in `ip.txt` - rufe `updateurl` auf (z. B. DynDNS-Anbieter) - logge Aktualisierung in Tageslog - sende E-Mail-Benachrichtigung - Wenn nicht online: - logge, dass keine Aktualisierung möglich ist #### **📬 Benötigte Tools:** - `curl` - `ping` - `mail` - `sed`, `head`, `tail` - Bash >= 4 Inhalt der $data/updateurl.txt: ``` https://api.dyndns.tld/update.php?key=q12w3e4r5t6z7u8i9o0p ``` Script: ```bash user=$(whoami) data="/home/$user/script-data/$(basename "$0")" ippage="icanhazip.com" if [ ! -d "$data" ]; then mkdir -p "$data" fi if [ ! -d "$data/logs" ]; then mkdir "$data/logs" fi function ipcheck { echo "$(date +"[%d.%m.%Y %H:%M:%S]")" if [ -f "$data/ip.txt" ]; then ip=$(head -n1 "$data/ip.txt") echo "Bisherige IP: $ip" else echo "Erste Ausführung." ip="" echo "$(date +"%d.%m.%Y;%H:%M:%S");Erste Ausführung;$1" >> "$data/logs/allgemein.csv" fi if [ -f "$data/updateurl.txt" ]; then updateurl=$(sed 's/ //g' "$data/updateurl.txt" | head -n1 | tail -n1) else echo "Keine Update-URL hinterlegt. URL hier einfügen:" echo "$(date +"%d.%m.%Y;%H:%M:%S");Update-URL fehlt" >> "$data/logs/allgemein.csv" read -p "Update-URL: " updateurl # Überprüfe, ob die URL mit "http://" oder "https://" beginnt if [[ "$updateurl" =~ ^(http|https):// ]]; then echo "URL OK." echo "$updateurl" > "$data/updateurl.txt" echo "$(date +"%d.%m.%Y;%H:%M:%S");Update-URL hinterlegt;$1" >> "$data/logs/allgemein.csv" else echo "Die URL ist ungültig." echo "$(date +"%d.%m.%Y;%H:%M:%S");Update-URL ungültig;$1" >> "$data/logs/allgemein.csv" exit 1 fi fi echo "Prüfe Online-Status" if ping -4 -c 1 -W 3 "$ippage" >/dev/null 2>&1; then echo "Anschluss Online" ipneu=$(curl -s "$ippage") echo "IP: $ipneu" if [ "$ip" = "$ipneu" ]; then echo "IP unverändert." # echo "$(date +"%d.%m.%Y;%H:%M:%S");IP unverändert;$1" >> "$data/logs/$(date +"%Y%m%d").csv" else echo "Bisherige IP: $ip" echo "Neue IP : $ipneu" echo "Aktualisiere..." echo "$ipneu" > "$data/ip.txt" curl -sSL "$updateurl" >/dev/null echo "OK." echo "$(date +"%d.%m.%Y;%H:%M:%S");Aktualisiert auf $ipneu;$1" >> "$data/logs/$(date +"%Y%m%d").csv" echo "$(date +"[%d.%m.%Y %H:%M:%S]") IP aktualisiert auf $ipneu" | mail -s "DynDNSupdater" "mail@mariobeh.de" fi else echo "Client ist selbst offline, kein Aktualisieren möglich." echo "$(date +"%d.%m.%Y;%H:%M:%S");Client offline;$1" >> "$data/logs/$(date +"%Y%m%d").csv" fi } if [ -z "$1" ]; then ipcheck fi exit 0 ``` # Webcamloader 🐧 **Webcamloader, Debian (+Derivate) *Wiki-Stand: 27.12.2025* *Script-Stand: 28.12.2025*** [***Download***](https://wiki.mariobeh.de/link/54#bkmrk-script-download) --- ### **🚀 Vorwort** Der **Webcamloader** ist ein universelles Bash-Script zur automatisierten Erfassung von Kamerabildern. Es eignet sich ideal für den Einsatz bei **Baufortschrittsdokumentationen**, **Wetter- und Landschaftsbeobachtungen**, **Langzeitstudien** und ähnlichen Zeitraffer-Projekten. Das Script lädt in regelmäßigen Intervallen **Einzelbilder von Bildquellen oder Videostreams** herunter und speichert diese lokal. Die Bilder können später zu einem Zeitraffer-Video weiterverarbeitet werden. Unterstützte Quellen: **Bildquellen:** z. B. `snapshot.jpg`, `snapshot.cgi` und **Videostreams:** z. B. `faststream`, `motion-jpeg`, `video.cgi`. Das Script speichert alle Daten zentral unter `/home/$USER/script-data/webcamloader/` Darin befinden sich: **Projektverzeichnisse, Statusdaten, Logfiles und Konfigurationen**. Optional kann ein abweichender **Medienordner** (z. B. auf einer externen Festplatte) angegeben werden. Falls keiner definiert ist, wird der Medienpfad automatisch unterhalb des `script-data/webcamloader/`-Verzeichnisses angelegt. Bitte unbedingt Datenschutzbestimmungen beachten. Mehr dazu weiter unten im [Haftungsausschluss](https://wiki.mariobeh.de/link/54#bkmrk-disclaimer). ### **⚙️ Funktionen im Wesentlichen** Das Script prüft zu Beginn, ob die Kamera erreichbar ist, lädt ein Testbild, errechnet anhand diesem den erforderlichen Speicher für die angegebene Gesamtbildanzahl, erstellt im nächsten Schritt Projektordner und Statusdatei und nimmt die Arbeit auf. Falls ein Zeitfenster angegeben wurde, wird dieses berücksichtigt. Im Fehlerfall wird der Benutzer benachrichtigt per Email, sofern angegeben. Wenn ein Projekt abgeschlossen wurde, erhält man wahlweise eine Mail. Daraufhin kann man über einen Menüpunkt ein Video erstellen. Hierfür sind die FPS (Frame per second) nötig anzugeben. Das Script bietet drei Modi zum Besorgen der Bilder, die weiter unten genauer erklärt werden: • **Menü**: Interaktives Menü mit allen Funktionen. • **Quicky**: Komplette Steuerung via Argumente, kein Menü. • **Cron**: Einmalaufrufe, zeitgesteuert z. B. über Crontab. Für die **Videoerstellung** steht ein geführter Ablauf über das Menü zur Verfügung, der Schritt für Schritt und intuitiv durch den Prozess führt. ### **☝ Technische Hinweise** • Die **Kamera-URL muss direkt** auf ein Bild oder einen Videostream verweisen – nicht auf eine HTML-Seite oder Steueroberfläche. • Für **E-Mail-Benachrichtigungen** muss der Server `mail` installiert und korrekt eingerichtet haben. • Bei dem **Funktionsschalter** gilt: -f 0 ist Hintergrundmodus (keine Ausgabe), -f 1 ist Vordergrundmodus, komplette Ausgabe. Falls Ausgabe erwünscht ist, wird das Programm `screen` empfohlen, da beim Schließen des Terminals auch das Script beendet wird. • Wird keine Funktion -f angegeben, startet automatisch der Vordergrundmodus. • **Hinweis:** Nicht jede Kamera wird unterstützt, da manche Videostreams nicht mit dem Script kompatibel sind. In solchen Fällen liefert die Kamera entweder ungeeignetes Material oder einen endlosen Stream, der das Script dauerhaft blockiert. Dieses Verhalten ist technisch bedingt und wurde im Rahmen der Möglichkeiten umfassend getestet. Wenn die Kamera ein klares Einzelbild liefert, funktioniert alles reibungslos, bei Videostreams kann es jedoch zu Problemen kommen. Sollte ein inkompatibler Stream erkannt werden, verweigert das Script automatisch die weitere Verarbeitung. Das Script ist ressourcenschonend und benötigt keine Root-Rechte. Es erzeugt keine externen Weiterleitungen außer zur Kamera selbst. Die heruntergeladenen Bilder werden im vorher festgelegten Medien-Ordner gespeichert und können dort jederzeit angeschaut werden. Videos landen ebenfalls dort. ### **🧭 Das Menü** [![image.png](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/4oYimage.png)](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/4oYimage.png) Hier sieht man das Hauptmenü, welches beim Aufruf ohne Parameter gestartet wird. Dieses ist nötig für den geführten Modus, der Videoerstellung, Projekte abzubrechen oder den Status laufender Projekte zu begutachten. ### **📷 Geführter Modus 🤝🏻** Der geführte Modus über das Hauptmenü ist die zentrale und **benutzerfreundlichste** Funktion des Webcamloaders. Wird das Skript ohne Parameter aufgerufen, startet es automatisch im interaktiven Hauptmenü. Hier erfolgt die Bedienung schrittweise und intuitiv – ganz ohne Kenntnisse über Parameter oder deren Syntax. Besonders für Einsteiger ist dieser Modus ideal: Alle Einstellungen werden nacheinander abgefragt und erklärt, sodass man sicher und zielgerichtet zum gewünschten Ergebnis kommt. Im Menü kann zwischen verschiedenen Aktionen gewählt werden: Ein neues Projekt starten, ein bestehendes Projekt fortsetzen, Einstellungen ändern, den Status prüfen oder das Projekt abbrechen. Auch ein Video lässt sich hier erstellen, diese Funktion ist im Videosektor genauer erklärt. Der Einstieg erfolgt über die Eingabe grundlegender Informationen wie Kamera-URL, Projektname, Anzahl der Bilder und Aufnahmeintervall. Optional kann ein Zeitfenster für die aktiven Aufnahmezeiten angegeben werden. Außerdem besteht die Möglichkeit, eine Benachrichtigungs-Mailadresse zu hinterlegen und zu entscheiden, ob die Ausgabe im Vordergrund oder still im Hintergrund erfolgen soll. Sobald alle Angaben gemacht wurden, erhält man eine Übersicht mit geschätztem Speicherbedarf und Laufzeit. Mit einem einfachen Tastendruck startet die Aufzeichnung. Auch nach Projektstart können noch Informationen zum Projektstatus abgerufen oder Einstellungen angepasst werden, etwa um das Projekt frühzeitig zu beenden oder ein neues zu beginnen. Der Menümodus ist somit der flexibelste und komfortabelste Weg, ein Zeitraffer-Projekt zu starten, und bietet zugleich volle Kontrolle über den Ablauf – ohne direkte Kommandozeilenparameter. ***Hinweis: im geführtem Modus wird derzeit die Funktion des Zeitfensters und der Zeitzone noch nicht unterstüzt. Wird diese Funktion benötigt, bitte ich den [Quicky-Modus ](https://wiki.mariobeh.de/link/54#bkmrk-%F0%9F%93%B7-quicky-modus)zu benutzen.*** [![image.png](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/image.png)](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/image.png) Hier sieht man die Durchführung des geführten Modus', bei dem beispielhaft Daten eingetragen wurden ### **📷 Quicky-Modus 💨** Der Quicky-Modus ist für erfahrene Benutzer gedacht, die ein Projekt schnell starten möchten. Nach Übergabe aller erforderlichen Parameter zeigt der Webcamloader eine Zusammenfassung inklusive Berechnung der Aufnahmedauer. Mit ENTER kann das Projekt sofort gestartet werden. Aufruf: ```bash ./webcamloader.sh quicky -u -n -b -i -e -f -t ``` Parameter im Einzelnen: `-u` Kamera URL komplett mit http(s). `-n` Projektname. Freier Name für das Projekt. `-b` Bilderanzahl für das Gesamtprojekt. `-i` Intervall für die Pausenzeiten zwischen den Bilderdownloads. `-e` E-Mail für die Benachrichtigung (optional). `-f` Funktion/Ausführung - 0 oder 1 (optional). `-t` Zeitfenster im Format 8-18 (optional). `-T` Zeitzone, [hier nachlesen](https://wiki.mariobeh.de/link/54#bkmrk-%E2%8F%B0zeitzonen) (optional). ```bash ./webcamloader.sh quicky -u "http://192.168.7.199/cgi-bin/api.cgi?cmd=Snap&channel=0&rs=0&user=user1&password=passwort" -b 15000 -p 15 -n "Vordach" -e "name@domain.tld" -f 0 -t 7-20 ./webcamloader.sh quicky -u "http://192.168.7.199/mjpg/video.mjpg" -b 15000 -p 15 -n "Vordach" -e "name@domain.tld" -f 0 -t 7-20 ... -t 7-20 -T ch ... -t 7-20 -T usa-nc ``` Hier sieht man demonstrativ und beispielhaft Varianten zur Eingabe im schnellen Quicky-Modus. Hier übergibt man alles, was wichtig ist, einmal dem Script und es kann dann nach einer Bestätigung die Arbeit beginnen. Beide Varianten haben als Beispiel 15.000 Bilder mit einem Intervall von 15 Sekunden. Zeile 1 zeigt eine Reolink-Kamera mit Passwortschutz (via URL) und Zeile 2 zeigt einen MJPEG-Videostream ohne Passwortschutz. Zeile 3 und 4 zeigt jeweils eine Zeitzone, die hinten an den ganzen Webcamloader-Aufruf angehängt wird. Zeile 3 "ch" (stellvertretend für Europe/Zurich) und 4 "usa-nc" (North Carolina, stellvertretend für America/New\_York). ### **📷 Cron-Modus ⏰** Der Cron-Modus ist ein Einmalaufruf, bei dem genau ein Bild gespeichert wird. Dieser ist gedacht für Langzeitaufnahmen mit Bild einmal am Tag per Crontab. Dabei können auch Folgebilder gesetzt werden. Dies ist sinnvoll, wenn der Cron-Befehl um 12:00 Uhr losgeht aber man nochmal ein Bild um 16:00 Uhr haben möchte. Klar könnte man den Crontab als *12,16* kennzeichnen - man könnte hier auch 2 Bilder definieren im Abstand von 4 Stunden. Ist Geschmackssache. Aufruf: ```bash ./webcamloader.sh cron -u -n -b -i ``` Parameter im Einzelnen: `-u` Kamera URL komplett mit http(s). `-n` Projektname. Freier Name für das Projekt. `-b` Folgebilder (optional). `-i` Intervall (optional). ```bash ./webcamloader.sh cron -u http://192.168.7.199/cgi-bin/faststream.jpg -n "Testkamera" ./webcamloader.sh cron -u http://192.168.7.199/cgi-bin/faststream.jpg -n "Testkamera" -b 2 -i 4h ``` Der Cron-Aufruf wie hier beispielhaft zu sehen, ist dasselbe Thema wie bei Quicky, nur einmalig ein Bild. Die Daten von Quicky sind hier auch parallel anzuwenden. In Zeile 1 sieht man einen normalen, einmaligen Aufruf wie es standard- & zweckmäßig beim Script mit Cron erwartet wird, bei Zeile 2 sieht man einen Folgeauftrag, der dann 2 Bilder im Abstand von 4 Stunden macht. Hier wird als Beispiel um 12:00 Uhr ein Cronjob gestartet mit der Ausführung um ein Bild. Dann erfolgt nach 4 Stunden das Bild 2. Hier könnte man auch klassisch einen Cronjob mit einer Einmalausführung mit *00 12,16 \* \* \** anlegen, hier passiert genau dasselbe. ### **📷 Bildherstellung Zusammenfassung 📋** Die Zusammenfassung ist bei den Varianten vom geführten Modus und des Quickys gleich. Hier eine Übersicht der Zusammenfassung, die in den Fällen bestätigt werden muss. [![image.png](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/gPOimage.png)](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/gPOimage.png) Hier wieder beispielhafte Daten. Zum Thema Berechnung, zum Zeitpunkt dieses Bildes ist der 25.07.25, 21:45. Mit 24/7 Aufnahme und Intervall von 25 Sekunden mit 15.000 Bildern dauert die Bildspeicherung also ca. 4,5 Tage. ### **📊 Status laufender Projekte** Unter diesem Menüpunkt lässt sich der aktuelle Status aller laufenden Projekte einsehen. Die Übersicht ist besonders hilfreich zur Kontrolle – etwa wenn ein Projekt aufgrund von Netzwerkproblemen nur selten neue Bilder liefert. Der Status wird visuell durch ein **✔** (alles in Ordnung) oder ein **✖** (Problem erkannt) angezeigt. Zusätzlich ist ersichtlich, ob beim Start des Projekts eine Benachrichtigungs-E-Mail aktiviert wurde. **Wichtig:** Projekte, die per Cron gestartet wurden, gelten technisch als immer abgeschlossen und erscheinen **nicht** in dieser Übersicht. Die Tabelle enthält folgende Informationen: - Projektnummer (ID) - Projektname - Bilder (Bildanzahl IST / SOLL) - Intervall - letzte Aktion (Download oder Fehler) - errechnete Fertigstellung - Benachrichtigung aktiv? (als ✖ oder ✔) - Projekt OK? (als ✖ oder ✔) - Fertigstellung in % Außerdem werden die Projekte aufgezählt. [![Screenshot 2025-07-27 153814.png](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/HEVscreenshot-2025-07-27-153814.png)](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/HEVscreenshot-2025-07-27-153814.png) ### **🚩 Fertige Projekte** Sobald ein Projekt abgeschlossen ist – entweder durch Erreichen der definierten Bildanzahl oder durch manuellen Abbruch bei aktiviertem unbegrenztem Download – wird es unter dem Menüpunkt **Fertige Projekte** aufgelistet. Hier werden alle beendeten Projekte zentral gesammelt. Dieser Schritt ist zwingend notwendig für die spätere Videoerstellung - an diesem Menü führt kein Weg vorbei. **Wichtig:** Projekte, die per Cron gestartet wurden, gelten technisch als immer abgeschlossen und erscheinen **grundsätzlich** in dieser Übersicht. Sie gelten immer als fertig und können zu jeder Zeit ein weiterverarbeitet werden. Die Tabelle enthält folgende Informationen: - Projektnummer (ID) - Projektname - Bildanzahl - Intervall (nur bei manuell gestarteten Projekten sichtbar, also nicht via Cron) - Aufnahmedatum (als Zeitraum *von–bis*, als *einzelner Tag* oder bis *heute*). [![Screenshot 2025-07-27 154640.png](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/screenshot-2025-07-27-154640.png)](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/screenshot-2025-07-27-154640.png) ### **❌ Projekt abbrechen** Coming soon! ### **🎥 Videoerstellung** Im oben erwähnten Menü zur Bilderstellung ist die Videoerstellung ebenfalls ein Punkt davon. Darüber lassen sich mit fertigen, abgeschlossenen Projekten ein Video erstellen. Im geführten Ablauf wird zunächst die gewünschte Bildrate (FPS – Frames per Second) abgefragt. Danach folgt eine Zusammenfassung aller relevanten Angaben zur Kontrolle. Da FPS und Bildanzahl maßgeblich die Videolänge beeinflussen, sollte hier sorgfältig geprüft werden. Dieses landet dann ebenfalls im Medienverzeichnis, parallel zu den Bildern. Ist das Video fertig, kann man das Projekt abschließen oder die FPS erneut mit anderem Wert setzen, sollte das Ergebnis des Videos nicht befriedigend sein. Wird das Projekt abgeschlossen, wird das rohe Projekt, also die Bilder als solches, gelöscht. Das Video bleibt selbstverständlich erhalten. [![image.png](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/scaled-1680-/SPBimage.png)](https://wiki.mariobeh.de/uploads/images/gallery/2025-07/SPBimage.png) Hier zu sehen ist das Menü für die Videoerstellung bis hin zur 📋 Zusammenfassung. ### **⏰Zeitzonen** Das Script kann mit frei wählbaren Zeitzonen arbeiten. Die eingestellte Zeitzone bestimmt, **in welcher lokalen Zeit** das konfigurierte Zeitfenster ausgewertet wird. **Beispiel:** Ist die Zeitzone auf *New York* gesetzt und das Zeitfenster auf **9-16 Uhr**, dann arbeitet das Script zu diesen Zeiten **in New Yorker Ortszeit**. Entsprechend entspricht dies in Deutschland (MEZ/MESZ) etwa **15:00–22:00 Uhr**. Auf diese Weise können Webcams weltweit zeitgesteuert betrieben werden, ohne Aufnahmen während der Nacht zu erzeugen. Wird **keine Zeitzone** angegeben, verwendet das Script automatisch die **Systemzeitzone** des Hosts. Folgene Zeitzonen sind verfügbar, bzw. eingearbeitet worden. Für Vollständigkeit möchte ich nicht garantieren, aber es können Ausweichzeiten wie UTC+X genommen werden, falls wirklich. Aufgrund der Masse habe ich die Zeitzonen ausgelagert. Zu finden hier: [Link (intern)](https://wiki.mariobeh.de/books/behwiki/page/webcamloader-timezones). Bitte exakt so verwenden, wie sie in der linken Spalte geschrieben sind. ### **⚠️ Haftungsausschluss (Disclaimer)** ##### **Allgemein**
Dieses Skript ist zur Ausführung **eigener Kamerasysteme** konzipiert. Fremdquellen wie Wetterkameras, Baustellenkameras etc. dürfen nur nach ausdrücklicher Zustimmung des Rechteinhabers genutzt werden.
**Hinweis zum Datenschutz:** Die Erfassung und Speicherung von Kamerabildern unterliegt der **DSGVO** und ggf. weiteren gesetzlichen Regelungen. Insbesondere bei **Personenerkennbarkeit** ist eine vorherige Klärung und ggf. Meldung verpflichtend.
Nutze dieses Tool **verantwortungsvoll** und **transparent** - ausschließlich im Rahmen geltender Gesetze. Oder mit anderen Worten: Die **Verantwortung** für die rechtmäßige Nutzung **liegt ausschließlich beim Anwender**.
Ich übernehme **keine Haftung** für:
- missbräuchliche Verwendung - technische Schäden - Datenschutzverletzungen jeglicher Art
##### **Öffentliche Kameras**
Viele Webcams von Gemeinden, Tourismusportalen, Stauseen oder Skigebieten dürfen ausdrücklich genutzt oder eingebunden werden. Bitte unbedingt bei der betreibenden Gesellschaft der Kamera selbst informieren.
### **💾 Script Download** Das Programm kann hier in immer der neuesten Version heruntergeladen werden: ##### **[Webcamloader Script](https://public.mariobeh.de/scripts/webcamloader.sh)** (via mariobeh.de) [Webcamloader auf Github](https://github.com/mariobeh/webcamloader) Ich bitte um Verständnis, wenn ich das Programm selbst vertreiben möchte. Das Script gibt es auch auf Github aber auf dem Server hier ist die Version stets aktuell. --- *Nur in Deutsch verfügbar, Umbau auf anderen Sprachen auf Anfrage.* Vielen Dank, mariobeh. # Faultnotify 🐧

**Faultnotify, Debian (+Derivate) *Wiki-Stand: 10.04.2026* *Script-Stand: 10.04.2026*** *Sprachdateien-Referenz: 24.01.2026 ([mehr...](https://wiki.mariobeh.de/link/59#bkmrk-%F0%9F%97%A3%EF%B8%8F-sprachdateien))*

[***Download***](https://wiki.mariobeh.de/link/59#bkmrk-script-download) --- ### **📖 Vorwort** Faultnotify ist ein leichtgewichtiges, modular aufgebautes Bash-Script zur Überwachung von Geräten und Diensten. Es wurde mit dem Ziel entwickelt, Störungen **zuverlässig und frühzeitig** zu erkennen. Dazu überprüft Faultnotify Geräte und Dienste fortlaufend und informiert im Fehlerfall automatisch per Benachrichtigung. Alle benötigten Daten werden zentral in einem festen Verzeichnis abgelegt. Dort befinden sich unter anderem die Konfiguration, Statusinformationen sowie Steuer- und optional auch Sprachdateien. Dadurch bleibt alles übersichtlich an einem Ort. Optional kann Faultnotify um zusätzliche Sprachdateien erweitert werden. In diesem Fall ist das Script in der Lage, Benachrichtigungen und Ausgaben in der jeweiligen Sprache bereitzustellen. Faultnotify eignet sich sowohl für einzelne Systeme als auch für größere, verteilte Umgebungen. Es kommt bewusst ohne zusätzliche Software oder Datenbanken aus und bleibt dadurch einfach, robust und wartungsarm. In verteilten Umgebungen können Geräte und Dienste zu Gruppen zusammengefasst werden. So wird sichergestellt, dass im Störungsfall nur gezielte und sinnvolle Benachrichtigungen ausgelöst werden. Für den Dauerbetrieb empfiehlt sich die Einrichtung als Systemdienst. Dadurch läuft Faultnotify permanent im Hintergrund und bleibt auch nach Neustarts zuverlässig aktiv. ### **💡 Allgemein und Installation** ##### **Allgemein** Faultnotify arbeitet in einem zentralen Arbeitsverzeichnis unter: /home/$USER/script-data/faultnotify/ In diesem Verzeichnis werden alle relevanten Dateien abgelegt, darunter die Konfiguration, Status- und Steuerdateien sowie Protokolle. Dadurch bleiben alle Informationen übersichtlich an einem Ort. Optional kann Faultnotify um Sprachdateien erweitert werden. Diese werden im folgenden Verzeichnis abgelegt: /home/$USER/script-data/faultnotify/lang/faultnotify-xxx.txt Deutsch ist die im Script integrierte Standardsprache. Weitere Sprachen können über entsprechende Sprachdateien ergänzt werden. Sprachen können im [Downloadbereich](#bkmrk-script-download) heruntergeladen werden. ##### **Installation und Ersteinrichtung** Faultnotify wird über den Befehl **install** eingerichtet. Das Script führt dabei interaktiv durch die Ersteinrichtung und legt alle grundlegenden Einstellungen an. Während der Installation prüft Faultnotify, ob alle benötigten Programme auf dem System vorhanden sind. Fehlende Abhängigkeiten werden klar angezeigt und müssen anschließend manuell nachinstalliert werden. Im nächsten Schritt wird der gewünschte Benachrichtigungsweg festgelegt. Zur Auswahl stehen **E-Mail** oder **Telegram**. Je nach Auswahl werden die erforderlichen Angaben abgefragt und in der Konfiguration gespeichert. Zum Abschluss der Einrichtung wird ein Verifizierungscode an die angegebene E-Mail-Adresse oder an den ausgewählten Telegram-Account gesendet. Dieser Code muss eingegeben werden, um sicherzustellen, dass Benachrichtigungen im Störungsfall korrekt zugestellt werden. Wird die Verifizierung übersprungen oder schlägt sie fehl, wird die Installation dennoch fortgesetzt. Die Benachrichtigungseinstellungen können später manuell angepasst werden, jedoch ohne erneute automatische Verifizierung. In diesem Fall liegt die vollständige Verantwortung für eine funktionierende Zustellung beim Nutzer. Ein entsprechender Workaround ist separat beschrieben. ##### **Gruppenlogik und Abhängigkeiten** Die Gruppenlogik wurde eingeführt, um Benachrichtigungsfluten gezielt zu vermeiden. Ein typisches Anwendungsbeispiel ist die Überwachung einer VPN-Verbindung mit mehreren dahinterliegenden Geräten oder Diensten. Fällt in einem solchen Szenario die VPN-Verbindung aus, sind alle nachgelagerten Geräte ebenfalls nicht erreichbar. Ohne Gruppenlogik würde dies zu einer Vielzahl gleichzeitiger Störungsmeldungen führen, obwohl die eigentliche Ursache lediglich der VPN-Ausfall ist. Durch die Gruppenbildung prüft Faultnotify zuerst den übergeordneten Eintrag. Ist dieser nicht erreichbar, werden die Prüfungen der abhängigen Geräte ausgesetzt und es erfolgen keine weiteren Benachrichtigungen für diese Einträge. Erst wenn der übergeordnete Dienst wieder verfügbar ist, werden die abhängigen Geräte erneut geprüft. Dadurch bleiben Benachrichtigungen übersichtlich, aussagekräftig und auf die tatsächliche Ursache beschränkt. ### **📋 Geräteprüfung (TEST)** Das Modul test ist die zentrale Prüffunktion von Faultnotify. Es prüft alle in der Konfiguration hinterlegten Geräte und Dienste und erkennt Störungen sowie Wiederherstellungen. Bei direktem Aufruf führt test genau einen vollständigen Durchlauf aus. Das bedeutet: - Alle Geräte und Dienste werden einmal geprüft. - Im Fehlerfall werden Benachrichtigungen ausgelöst. - Danach endet der Durchlauf automatisch. ### **🏭 Automation (RUN)** Dies ist der Dauerschleifen-Modus. Hier werden permanent mit einem Versatz von 5 Sekunden die in der Konfiguration eingerichteten Geräte und Dienste geprüft. **Hinweis:** Wird `run` direkt im Terminal gestartet, läuft Faultnotify im Vordergrund und blockiert das Terminal. Für den Dauerbetrieb wird die Einrichtung als Systemdienst empfohlen. Dadurch läuft Faultnotify dauerhaft im Hintergrund und der Status ist jederzeit über `systemctl status faultnotify` sichtbar. ### **➕ Geräte/Dienste hinzufügen (ADD)** Mit dem Modul **add** können neue Geräte und Dienste interaktiv zur Überwachung hinzugefügt werden. Der Vorgang ist dialoggeführt aufgebaut und kann mehrfach hintereinander ausgeführt werden, um mehrere Einträge nacheinander anzulegen. Zu Beginn ermittelt Faultnotify automatisch die nächste freie Geräte-ID. Diese wird fortlaufend vergeben. Im Anschluss werden Schritt für Schritt folgende Angaben abgefragt: - **Name des Geräts oder Dienstes** Der Anzeigename dient ausschließlich der Übersicht. Kritische Zeichen werden automatisch bereinigt, um die Konfigurationsdatei konsistent zu halten. - **IP-Adresse oder Domain** Es kann entweder eine IPv4-Adresse oder ein gültiger Domainname angegeben werden. - **Dienstüberwachung (optional)** Falls ein Dienst überwacht werden soll, wird der zu prüfende Port abgefragt. - **Abhängigkeit von einem Master-Gerät (optional)** Geräte und Dienste können einem bestehenden Eintrag untergeordnet werden. Dadurch lassen sich Abhängigkeiten abbilden, zum Beispiel: - Dienste hängen von einem Server ab - Untergeräte hängen von einem Hauptgerät ab Ist kein Master angegeben, wird der Eintrag automatisch der Root-Gruppe (G000) zugeordnet. Nach Abschluss der Eingaben wird der neue Eintrag: - in die Konfigurationsdatei geschrieben - im internen Log protokolliert - sofort für künftige Prüfungen berücksichtigt Der Hinzufügen-Modus kann jederzeit durch eine leere Eingabe beim Namen beendet werden. Nach dem ersten erfolgreichen Hinzufügen wird Faultnotify als „eingerichtet“ markiert, sodass die Überwachung genutzt werden kann.
**Hinweis zur Gruppenlogik:** Die Gruppenlogik entstand aus der praktischen Anforderung heraus, Benachrichtigungsfluten zu vermeiden. Ein typisches Beispiel ist die Überwachung einer VPN-Verbindung mit mehreren dahinterliegenden Geräten oder Diensten. Fällt in einem solchen Szenario die VPN-Verbindung aus, wären die nachgelagerten Geräte zwangsläufig ebenfalls nicht erreichbar. Ohne Gruppierung würde dies zu einer Vielzahl gleichzeitiger Störungsmeldungen führen, obwohl die eigentliche Ursache nur der VPN-Ausfall ist. Durch die Gruppenbildung wird dieses Problem gezielt verhindert. Wird ein Gerät oder Dienst als abhängig von der VPN-Überwachung angelegt, prüft Faultnotify zuerst den übergeordneten Eintrag. Ist dieser nicht erreichbar, werden die untergeordneten Prüfungen ausgesetzt und es erfolgt keine weitere Benachrichtigung für die abhängigen Geräte. Erst wenn die VPN-Verbindung wieder verfügbar ist, werden die nachgelagerten Geräte erneut geprüft. Auf diese Weise bleibt die Benachrichtigung aussagekräftig, übersichtlich und auf die tatsächliche Ursache beschränkt.
### **✏️ Modifizierung/Bearbeitung (MOD)** Das Modul **mod** dient zur nachträglichen Pflege und Anpassung von Faultnotify. Es ermöglicht sowohl die Verwaltung einzelner Geräte und Dienste als auch die Änderung zentraler Konfigurationseinstellungen. Nach dem Start von mod wird zunächst abgefragt, **welcher Bereich geändert werden soll**: - **Geräte und Dienste** - **Zentrale Konfiguration** **Geräte und Dienste bearbeiten** Wird der Geräte-/Service-Bereich gewählt, zeigt Faultnotify zunächst **alle aktuell eingerichteten Einträge** in einer übersichtlichen Liste an. Jeder Eintrag enthält unter anderem: - Geräte- bzw. Service-ID - Gruppenzugehörigkeit - Name - IP-Adresse - optional Port und Protokoll Anschließend wird abgefragt, **welcher Eintrag geändert werden soll**. Die Auswahl kann flexibel erfolgen: - über die Geräte-ID (z. B. `D006` oder `006`) - über einen Teil des Namens - über die vollständige IP-Adresse Nach eindeutiger Zuordnung des Eintrags stehen zwei Optionen zur Verfügung: 1. **Eintrag löschen und neu definieren** Der bestehende Eintrag wird entfernt, zugehörige Status- und Jail-Informationen werden bereinigt und anschließend wird automatisch der add-Dialog gestartet, um das Gerät oder den Dienst neu anzulegen. 2. **Eintrag ersatzlos löschen** Der Eintrag wird vollständig aus der Konfiguration entfernt. Auch hier werden zugehörige Status- und Jail-Dateien bereinigt. Damit lassen sich Geräte und Dienste sauber korrigieren, ersetzen oder dauerhaft entfernen. **Konfiguration bearbeiten** Wird die Konfiguration gewählt, zeigt Faultnotify zunächst **alle relevanten aktuellen Einstellungen** an, inklusive erklärender Hinweise. Dazu gehören unter anderem: - Online-Ping-Prüfung (Referenz für Internet-Erreichbarkeit) - Art der Benachrichtigung (E-Mail oder Telegram) - E-Mail-Empfänger - Telegram-Bot-Token - Telegram-Chat-ID - Nächste zu vergebende Geräte-ID Anschließend kann gezielt ein einzelner Parameter geändert werden. Jede Änderung erfolgt interaktiv: - Neuer Wert eingeben - Übersicht anzeigen - explizite Bestätigung vor dem Übernehmen Eingaben werden dabei geprüft (z. B. Format von IP-Adressen, Domains, E-Mail-Adressen oder IDs), um fehlerhafte Konfigurationen zu vermeiden. Kommentare in der Konfigurationsdatei bleiben erhalten. **Ziel des MOD-Moduls** Das mod-Modul stellt sicher, dass Faultnotify auch im laufenden Betrieb **einfach, kontrolliert und konsistent gepflegt** werden kann - ohne manuelle Eingriffe in die Konfigurationsdatei und ohne das Risiko inkonsistenter Zustände. ### **📜 Übersicht (DRAW)** Mit dem Modul draw kann die komplette Geräte- und Dienststruktur übersichtlich als Baum angezeigt werden. Dabei werden alle Abhängigkeiten berücksichtigt, sodass auf einen Blick sichtbar ist, welche Geräte oder Dienste untergeordnet sind und welche als übergeordnete „Master“-Ebene dienen. Die Darstellung beginnt bei ROOT (G000) und zeigt darunter alle Einträge aus der Konfiguration in einer klaren Hierarchie. Zusätzlich werden die wichtigsten Informationen direkt in der Ausgabe mitgeführt: - ID des Eintrags - Name bzw. Beschreibung - IP-Adresse - optional Port Fehlerhinweis bei ungültigen Abhängigkeiten Falls ein Eintrag auf ein nicht vorhandenes Master-Gerät verweist, gibt draw einen Hinweis aus und listet die betroffenen Einträge auf. Dadurch lassen sich fehlerhafte Abhängigkeiten schnell erkennen und anschließend über mod korrigieren. [![Screenshot 2026-01-24 220734.jpg](https://wiki.mariobeh.de/uploads/images/gallery/2026-01/scaled-1680-/mRwscreenshot-2026-01-24-220734.jpg)](https://wiki.mariobeh.de/uploads/images/gallery/2026-01/mRwscreenshot-2026-01-24-220734.jpg) Hier zu sehen: DRAW-Auflistung mit Beispielwerten. ### **🆘 Fehler / Troubleshooting** Wird während der Installation eine Eingabe wie die Benachrichtigung falsch getägigt oder die Verifizierung der Benachrichtigung übersprungen oder schlägt fehl, wird die Installation trotzdem weitergeführt. Die Verifizierung dient dazu, dass sichergestellt werden kann, dass im Störungsfall auch Benachrichtigungen ankommen können. In diesem Fall kann im Verzeichnis `script-data/faultnotify` die Datei `.installed` gelöscht werden, um die Installation erneut zu starten und die Erstkonfiguration nochmals vollständig durchzuführen. ### **🗣️ Sprachdateien** Faultnotify ist in der Lage, in verschiedenen Sprachen zu arbeiten und Benachrichtigungen entsprechend auszugeben. Grundlage dafür sind externe Sprachdateien. Im Script wird die **I18N-Übersetzungstechnologie** eingesetzt. Diese ermöglicht eine klare Trennung zwischen Programmlogik und Textausgaben und bildet die Grundlage für die mehrsprachige Ausgabe von Meldungen und Benachrichtigungen. Deutsch ist die im Script fest integrierte Standardsprache. Zusätzlich steht eine englische Sprachdatei zum [Download ](https://wiki.mariobeh.de/link/59#bkmrk-script-download)bereit. Weitere Sprachen können jederzeit ergänzt werden. Die Sprachdateien sind bewusst einfach aufgebaut, sodass sie von jedermann erstellt oder erweitert werden können. Dadurch ist Faultnotify nicht auf eine feste Anzahl von Sprachen beschränkt und lässt sich flexibel an unterschiedliche Umgebungen anpassen. Die Sprachdatei muss dann im zentralen Pfad im Ordner *lang/* eingepflegt werden. Liegen mehrere Sprachdateien im Ordner, wird die erste vom Script automatisch ausgewählt. Es ist daher ratsam, nur die benötigte Sprache herunterzuladen. Faultnotify verwendet zur Einbindung von Sprachdateien einen SHA-256-Referenzcode, der direkt aus dem Script abgeleitet wird. Dieser Referenzcode stellt sicher, dass eine Sprachdatei eindeutig zu genau dieser Script-Version gehört. Diese Referenz ist in der ersten Zeile zu finden. Wenn eine neue Sprache integriert wird, ist dieser Referenzcode einzusetzen. Dadurch wird verhindert, dass versehentlich eine unpassende oder fremde Sprachdatei verwendet wird, zum Beispiel aus einem anderen Script oder einer älteren Version. Stimmen Script und Sprachdatei nicht überein, wird die Sprachdatei nicht geladen. Der zugehörige Referenzcode lautet: ```bash 9b0cdcd7cf19ab12afe54cafdbe0afaad8999c3b45d9c6024823864091cdd205 ``` Bitte beachten, dass sich dieser Referenzcode mit einer neuen Version ändern kann. Hintergrund ist die Integrität zur neuen Version, falls neue Textabschnitte hinzukommen oder welche abgeändert werden. Im Falle eines Updates wird darauf hingewiesen mit Link in der Script-Standardsprache (Deutsch) und Englisch. [![Screenshot 2026-01-25 032123.png](https://wiki.mariobeh.de/uploads/images/gallery/2026-01/scaled-1680-/screenshot-2026-01-25-032123.png)](https://wiki.mariobeh.de/uploads/images/gallery/2026-01/screenshot-2026-01-25-032123.png)Hier zu sehen: erste Zeilen der englischen Sprachdatei. ### **💾 Download** Das **Programm** kann hier in immer der neuesten Version heruntergeladen werden: ##### **[Faultnotify Script](https://public.mariobeh.de/scripts/faultnotify.sh)** (via mariobeh.de) ```bash curl -s https://public.mariobeh.de/scripts/faultnotify.sh | bash ``` **Sprachdateien:** **[Englisch](https://public.mariobeh.de/scripts/faultnotify-eng.txt)** (via mariobeh.de) ```bash USER=$(whoami) && mkdir -p /home/$USER/script-data/faultnotify/lang/ && curl -o /home/$USER/script-data/faultnotify/lang/faultnotify-eng.txt https://public.mariobeh.de/scripts/faultnotify-eng.txt && curl -s https://public.mariobeh.de/scripts/faultnotify.sh | bash ``` *(um gleich in Englisch zu starten, ist dieser Befehl erfoderlich. Er erstellt die Verzeichnisstruktur und legt die Sprachdatei an passender Stelle ab. Dieser Befehl lädt nicht nur die Sprachdatei, sondern startet direkt das Script.)* **Hinweis:** Deutsch ist die im Script fest integrierte Standardsprache und benötigt keine separate Sprachdatei. Daher wird Deutsch hier nicht separat angeboten. Weitere Sprachen werden folgen. ### **💾 Update** Über ein externes Updater-Script kann Faultnotify immer geupdated werden. Link hier: Updater-Script (COMING SOON!) Für die Sprachdatei gilt ein direktes Verfahren, einfach den Link einfügen, Sprachdatei wird automatisch an Ort und Stelle geladen. Alternativ kann oben die Datei manuell ins System eingepflegt werden. ```bash USER=$(whoami) && mkdir -p /home/$USER/script-data/faultnotify/lang/ && curl -o /home/$USER/script-data/faultnotify/lang/faultnotify-eng.txt https://public.mariobeh.de/scripts/faultnotify-eng.txt ```
# IPlogger 🐧 mit MySQL/MariaDB-Unterstützung (iplogger-db.sh)

**IPlogger, Debian (+Derivate) *Wiki-Stand: 12.05.2026* *Script-Stand: 12.05.2026*** [***Download***](https://wiki.mariobeh.de/link/61#bkmrk-script-download)

# IPLogger DB – IP- und Verfügbarkeitsüberwachung ## Überblick Der `iplogger-db.sh` ist ein datenbankgestützter IP-Logger zur dauerhaften Überwachung der eigenen Internetverbindung und der öffentlichen WAN-IP-Adresse. Das Script wurde dafür entwickelt, langfristig und nachvollziehbar festzuhalten: - welche öffentliche IP-Adresse zu welchem Zeitpunkt aktiv war - ob eine Internetverbindung vorhanden war - ob lediglich die IP-Ermittlung fehlgeschlagen ist - welche Prüfdienste funktioniert oder versagt haben - wie lange einzelne IPs aktiv waren - wann Provider oder Verbindungen ausgefallen sind Der Fokus liegt nicht auf einer simplen „Wie ist meine IP“-Abfrage, sondern auf einer historisch nachvollziehbaren Langzeitaufzeichnung mit Auswertung und Zeiträumen. Das System arbeitet vollständig datenbankbasiert und speichert jede einzelne Messung dauerhaft ab. --- # Ziel des Systems Der Logger beantwortet unter anderem folgende Fragen: - Welche öffentliche IP war am 12.03.2024 um 14:00 Uhr aktiv? - Wie lange blieb eine bestimmte IP bestehen? - Wann erfolgte ein DSL-/WAN-Reconnect? - War die Leitung tatsächlich offline oder nur ein Prüfdienst gestört? - Welche Provider lieferten fehlerhafte Antworten? - Welche DNS-/Connectivity-Ziele waren erreichbar? - Wie oft kam es zu Unterbrechungen? - Wie stabil arbeitet die Internetanbindung? Gerade bei: - DSL-Zwangstrennungen - CGNAT-/Providerwechseln - VPN-/Tunnelproblemen - Routingfehlern - sporadischen Ausfällen - Providerstörungen liefert die Historie eine klare technische Nachvollziehbarkeit. --- # Architektur Das System besteht aus mehreren Komponenten:
KomponenteAufgabe
`providers`Öffentliche IP-Abfragedienste
`connectivity_checks`Prüft, ob Internet grundsätzlich erreichbar ist
`state`Speichert Rotationszustände
`iplog`Historische Hauptdatenbank
`summary_*`Auswertung und Zusammenfassung
PDF-/CSV-ExportArchivierung und Dokumentation
--- # Grundlogik Der Ablauf einer Messung sieht vereinfacht so aus: ``` 1. Connectivity prüfen 2. Wenn Internet vorhanden: 3. Öffentliche IP ermitteln 4. Ergebnis speichern 5. Statistiken aktualisieren ```
Wichtig dabei: Das Script unterscheidet sauber zwischen:
ZustandBedeutung
`OFFLINE`Keine Internetverbindung
`CHECK_FAILED`Internet vorhanden, aber IP nicht ermittelbar
`OK`IP erfolgreich ermittelt
`INVALID_RESPONSE`Provider lieferte ungültige Antwort
`NO_RUN`Reservierter Status
Dadurch wird verhindert, dass ein einfacher Fehler eines einzelnen IP-Dienstes fälschlich als Internetausfall interpretiert wird. --- # Initialisierung ## Einstiegspunkt: `init` ``` ./iplogger-db.sh init ```
Dieser Befehl erstellt die komplette Datenbankstruktur. Dabei werden automatisch angelegt: - Tabellen - Standardprovider - Connectivity-Ziele - Rotationsstatus --- # Datenbanktabellen Es muss vorab ein Benutzer und eine Datenbank erstellt sein. Die init-Datenbankinitialisierung erstellt dann die Tabellen. ## providers Enthält alle IP-Ermittlungsdienste. Standardmäßig: - icanhazip.com - ifconfig.me - api.ipify.org - checkip.amazonaws.com Gespeichert werden zusätzlich: - Erfolgszähler - Fehlerzähler - letzter Erfolg - letzter Fehler - Timeoutwerte Beispiel:
NameURL
icanhazip.com[https://icanhazip.com](https://icanhazip.com)
api.ipify.org[https://api.ipify.org](https://api.ipify.org)
--- ## connectivity\_checks Prüft die generelle Internetverfügbarkeit. Standardmäßig: - Google DNS (`8.8.8.8`) - Quad9 (`9.9.9.9`) - Cloudflare (`1.1.1.1`) Die Prüfung erfolgt per Ping. --- ## state Speichert interne Rotationsinformationen. Dadurch wird nicht immer derselbe Provider zuerst verwendet. Beispiele:
NameWert
next\_provider\_index2
next\_connectivity\_index1
--- ## iplog Die zentrale Historientabelle. Hier wird jede Messung dauerhaft gespeichert. Gespeichert werden unter anderem: - Messzeitpunkt - öffentliche IP - Status - verwendeter Provider - Anzahl Versuche - Fehlermeldungen - Rohantworten - Connectivity-Status --- # Rotationssystem ## Warum Rotation? Würde immer derselbe Provider zuerst verwendet werden: - wäre dieser stärker belastet - Fehler würden schwerer auffallen - andere Provider würden kaum genutzt Deshalb arbeitet das System rotierend. --- ## Beispiel ### Durchlauf 1 ``` 1. icanhazip.com 2. ifconfig.me 3. ipify ```
### Durchlauf 2 ``` 1. ifconfig.me 2. ipify 3. icanhazip.com ```
### Durchlauf 3 ``` 1. ipify 2. icanhazip.com 3. ifconfig.me ```
Dadurch verteilt sich die Last gleichmäßig. --- # Connectivity-Prüfung ## Einstiegspunkt: `check` oder `run` ``` ./iplogger-db.sh check ```
oder: ``` ./iplogger-db.sh run ```
Beides startet dieselbe Messlogik. --- ## Ablauf der Connectivity-Prüfung Vor der eigentlichen IP-Ermittlung wird geprüft: - besteht überhaupt Internet? - ist Routing vorhanden? - funktionieren externe Ziele? Dazu werden mehrere bekannte Ziele angepingt. Erst wenn mindestens eines erreichbar ist, wird die IP-Abfrage gestartet. --- # Provider-Prüfung Nach erfolgreicher Connectivity-Prüfung: ``` curl -> Provider -> Antwort validieren ```
Dabei wird geprüft: - ist die Antwort leer? - ist die Antwort eine gültige IPv4? - ist die Antwort eine gültige IPv6? Nur dann gilt der Durchlauf als erfolgreich. --- # Beispielabläufe ## Erfolgreicher Lauf ``` Connectivity OK Provider erreichbar IP gültig → Status OK ```
Gespeichert wird beispielsweise: ``` 2026-05-12 22:00:00 IP: 93.192.117.44 Status: OK ```
--- ## Internet vorhanden, aber Provider kaputt ``` Connectivity OK Provider liefert Müll → CHECK_FAILED ```
Beispiel: ``` Provider https://api.example liefert: ERROR 500 ```
Das Internet funktioniert trotzdem. --- ## Komplett offline ``` Google DNS nicht erreichbar Cloudflare nicht erreichbar Quad9 nicht erreichbar → OFFLINE ```
--- # Summary-System Das eigentliche Kernstück ist die Verlaufsanalyse. Einzelne Messungen werden zu Zeiträumen zusammengefasst. --- # Einstiegspunkt: `summary` ## Tabellenansicht ``` ./iplogger-db.sh summary tabelle ```
Beispiel: ``` BEGIN_AT END_AT IP SAMPLES OFFLINE FAILS 2026-05-01 10:00 2026-05-03 02:00 93.192.117.44 91 0 0 ```
--- ## Textansicht ``` ./iplogger-db.sh summary text ```
Beispiel: ``` 01.05.2026 10:00 Uhr - 03.05.2026 02:00 Uhr: IP 93.192.117.44 (91x online) ```
--- # Wie die Periodenerkennung funktioniert Die Funktion `summary_rows()` analysiert die komplette Historie. Sobald sich die IP ändert: ``` alte Periode schließen neue Periode beginnen ```
Zusätzlich werden innerhalb der Periode gezählt: - Offline-Ereignisse - Fehler - erfolgreiche Samples --- # Detailmodus ## Einstiegspunkt ``` ./iplogger-db.sh summary export pdf details ```
Der Detailmodus erzeugt eine vollständige Zeitauflistung aller erfolgreichen Messungen innerhalb einer Periode. --- ## Beispiel ``` 16.02.2020 05:00 Uhr - 16.02.2020 11:00 Uhr: IP 93.192.117.44 (24x online) - 16.02.2020 05:00 06:00 07:00 08:00 - 16.02.2020 09:00 10:00 11:00 ```
Oder bei Tageswechsel: ``` 07.02.2021 04:00 05:00 06:00 08.02.2021 00:00 01:00 02:00 ```
Dadurch werden lange Zeiträume kompakt lesbar dargestellt. --- # PDF-Export ## Einstiegspunkt ``` ./iplogger-db.sh summary export pdf ```
oder: ``` ./iplogger-db.sh summary export pdf details ```
Der Export erzeugt automatisch: - TXT-Zwischendatei - PDF-Datei - Überschrift - Datum - Seitenzahlen Verwendet werden bevorzugt: - `enscript` - `ps2pdf` Alternativ: - `pandoc` --- # CSV-Export ## Einstiegspunkt ``` ./iplogger-db.sh summary export csv ```
Exportiert die zusammengefassten Perioden in maschinenlesbarer Form. Beispiel: ``` begin_at;end_at;ip;samples;offline;fails 2026-05-01 10:00;2026-05-03 02:00;93.192.117.44;91;0;0 ```
--- # Historischer CSV-Import ## Einstiegspunkt ``` ./iplogger-db.sh import ipdb.csv ";" ```
Der CSV-Import dient primär zur Übernahme historischer Daten aus der ersten Generation des IPLoggers. Dabei werden ältere Aufzeichnungen in die neue Datenbankstruktur übernommen. Unterstützt werden: - erfolgreiche IPs - Offline-Einträge - Fehlerzustände --- # Typische Einsatzszenarien ## WAN-Reconnects nachvollziehen ``` IP 1: 01:00 - 12:00 IP 2: 12:05 - aktuell ```
→ DSL-Zwangstrennung klar sichtbar. --- ## Providerprobleme erkennen ``` 15x CHECK_FAILED aber keine OFFLINE-Zustände ```
→ Internet vorhanden, aber IP-Dienst gestört. --- ## VPN-/Tunnelprobleme analysieren Wenn: - Connectivity vorhanden - aber bestimmte Ziele nicht erreichbar kann nachvollzogen werden: - wann Routingprobleme begannen - wie lange sie bestanden - ob WAN-Wechsel beteiligt waren --- # Besonderheiten ## IPv4 und IPv6 Das System akzeptiert beide Varianten automatisch. --- ## Zeitbasierte Rotation Provider und Connectivity-Checks werden nicht statisch verwendet. Das verhindert: - Single-Point-Abhängigkeiten - einseitige Last - verfälschte Statistiken --- ## Dauerhafte Historie Die Datenbank arbeitet append-only. Neue Einträge werden ausschließlich ergänzt. Dadurch bleibt die komplette Historie nachvollziehbar erhalten. --- # Beispiel für Cronjob ```bash 0 * * * * /srv/scripte/iplogger-db.sh check >/dev/null 2>&1 ```
Dadurch erfolgt stündlich eine neue Messung. --- # Fazit `iplogger-db.sh` ist kein einfacher „Wie ist meine IP“-Checker, sondern ein vollständiges Langzeit-Überwachungs- und Auswertungssystem für: - öffentliche WAN-IPs - Internetverfügbarkeit - Providerstabilität - Fehleranalysen - historische Zeiträume - dokumentierbare Verbindungsverläufe Besonders wertvoll wird das System durch: - die periodische Zusammenfassung - die saubere Statusunterscheidung - die rotierenden Prüfmechanismen - die nachvollziehbare Langzeithistorie - die Exportfunktionen für Archivierung und Dokumentation ### **💾 Download** Das **Programm** kann hier in immer der neuesten Version heruntergeladen werden: ##### **[IPlogger Script](https://public.mariobeh.de/scripts/iplogger-db.sh)** (via mariobeh.de) # Telegram Benachrichtigungsdienst mit einer einzigen PHP Ein Benachrichtigungsansatz, der schnell und einfach umzusetzen ist - in nur einer Datei, mit Ausnahme einer Konfiguration, wäre ein Träumchen. Das habe ich mir gedacht und habe das telegram.php ins Leben gerufen. Die Einstellungen zum Bot und zum Chat, sowie die Nachricht selbst, werden der PHP alle übergeben, sodass es eine Konfigurationsdatei überflüssig macht. Diese Datei ist universell ausgelegt, betriebssystemunabhängig, also rein PHP - logisch, wie der Dateiname verrät. Alles, was benötigt wird, ist PHP selbst. Falls die PHP scripttechnisch aufgerufen wird, nicht nur im Browser, dann wird auch z. B. curl benötigt. Der PHP müssen sämtliche Daten mit GET mitübergeben werden, damit das PHP diese intern verarbeiten kann. Die zu übergebenden Parameter **bot**, **chatid** und **msg** werden hier erklärt: • bot=... ist der BOT:TOKEN des Botfathers von Telegram, • chatid=... ist der Chat, an dem die Nachricht gehen soll, • msg=... ist die Nachricht, die übergeben wird. Beispielaufruf: ```bash http(s)://sub.domain.tld/telegram.php?bot=123456789:ABCdefGhIjKlMnOpQrStUvWxYz&chatid=987654321&msg=Hallo ich bins curl "http(s)://sub.domain.tld/telegram.php?bot=123456789:ABCdefGhIjKlMnOpQrStUvWxYz&chatid=987654321&msg=Hallo ich bins" php -f /srv/scripts/telegram.php "?bot=123456789:ABCdefGhIjKlMnOpQrStUvWxYz&chatid=987654321&msg=Hallo ich bins" ``` Zeile 1 zeigt einen Aufruf direkt im Browser. Macht an sich keinen Sinn, nur zur Veranschaulichung und eventuell zum Testen. Zeile 2 zeigt einen CLI-Aufruf via curl. Ideal für Scripte. Zeile 3 zeigt einen direkten Aufruf via php -f - hier wird die Leier danach übergeben. Technisch okay, aber irgendwie unsauber. Ich empfehle ganz klar Zeile 2 zur Automation, Zeile 1 und 3 sind eher zum Testen da. Hier das Script: ```php = 2) { parse_str(ltrim($argv[1], "?"), $params); return $params; } // Keine Parameter return []; } $params = getParams(); // Parameter prüfen if (empty($params['bot']) || empty($params['chatid']) || empty($params['msg'])) { echo "[FEHLER] Bot, ChatID oder Nachricht fehlt.\n"; exit(1); } $bot = $params['bot']; $chatid = $params['chatid']; $msg = urldecode($params['msg']); // Telegram API URL $url = "https://api.telegram.org/bot$bot/sendMessage"; // POST-Daten $data = array( 'chat_id' => $chatid, 'text' => $msg ); // cURL-Request ausführen $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $data); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); $result = curl_exec($ch); curl_close($ch); echo $result . "\n"; ?> ``` # Telegram Benachrichtigungsdienst mit einer einzigen Bash Das Pendant zur [telegram.php](https://wiki.mariobeh.de/books/behwiki/page/telegram-benachrichtigungsdienst-mit-einer-einzigen-php) ist hier die telegram.sh - eine Bash, die genau das gleiche macht wie die PHP, ideal zum Scripten und zur Automation. Ein Benachrichtigungsansatz, der schnell und einfach umzusetzen ist - in nur einer Datei, mit Ausnahme einer Konfiguration, wäre ein Träumchen. Das habe ich mir gedacht und habe das telegram.sh ins Leben gerufen. Die Einstellungen zum Bot und zum Chat, sowie die Nachricht selbst, werden der Bash alle mit Argumenten/Schaltern übergeben, sodass es eine Konfigurationsdatei überflüssig macht. Bash-typisch wird hier ein Linux vorausgesetzt. Ich persönlich verwende Debian. Zusätzlich wird curl benötigt. Die zu übergebenden Parameter werden hier erklärt: • *-b oder --bot* ist der BOT:TOKEN des Botfathers von Telegram, • *-c oder --chat* ist der Chat, an dem die Nachricht gehen soll, • *-m oder --msg* ist die Nachricht, die übergeben wird. Beispielaufruf: ```bash ./telegram.sh -b 123456789:ABCdefGhIjKlMnOpQrStUvWxYz -c 987654321 -m "Hallo ich bins" ``` Hier das Script: ```bash #!/bin/bash # Telegram Send Script - CLI mit Parameterübergabe # Usage info usage() { echo "Nutzung: $0 -b BOT -c CHATID -m MESSAGE" exit 1 } # Parameter parsen while [[ $# -gt 0 ]]; do key="$1" case $key in -b|--bot) BOT="$2" shift; shift ;; -c|--chat) CHATID="$2" shift; shift ;; -m|--msg) MSG="$2" shift; shift ;; *) usage ;; esac done # Prüfung if [ -z "$BOT" ] || [ -z "$CHATID" ] || [ -z "$MSG" ]; then usage fi # Telegram API URL URL="https://api.telegram.org/bot${BOT}/sendMessage" # Senden curl -s -X POST "$URL" -d chat_id="$CHATID" -d text="$MSG" # Ausgabe-Status echo ``` # Proxmox - Virtuelle Festplatte vergrößern und in der VM nutzbar machen (LVM + ext4) **Kurzablauf:** Virtuelle Platte in Proxmox vergrößern → Partition erweitern → LVM erweitern → Dateisystem erweitern. --- ## Schritte 1. **Partition vergrößern (nach Proxmox-Resize):**
`growpart /dev/sda 3`
2. **LVM-Physical Volume anpassen:**
`pvresize /dev/sda3`
3. **LVM-Volume vergrößern (gesamten freien Platz nutzen):**
`lvextend -l +100%FREE /dev/pbs/root`
4. **Dateisystem ext4 erweitern:**
`resize2fs /dev/pbs/root`
5. **Erfolg prüfen:**
`df -h`
--- ## Voraussetzungen - Festplatte wurde vorher in Proxmox über „Disk Resize“ vergrößert. - Tools installiert:
`apt install cloud-guest-utils parted`
--- ## Ergebnis Das Root-Dateisystem wächst ohne Neustart und der zusätzliche Speicher steht sofort zur Verfügung. # webcamloader-timezones Die Webcamloader-Timezones sind hier zur Eingabe mit `-T`:
Script-ErwartungIANA-Norm-Timezone zum Vergleich / Muster
adelaideAustralia/Adelaide
aeAsia/Dubai
aegyptenAfrica/Cairo
alabamaAmerica/Chicago
alaskaAmerica/Anchorage
albertaAmerica/Edmonton
aleutianAmerica/Adak
american-samoaPacific/Pago\_Pago
amsamoaPacific/Pago\_Pago
anchorageAmerica/Anchorage
arAmerica/Argentina/Buenos\_Aires
argentinaAmerica/Argentina/Buenos\_Aires
argentinienAmerica/Argentina/Buenos\_Aires
arizonaAmerica/Phoenix
arkansasAmerica/Chicago
atEurope/Vienna
au-actAustralia/Sydney
au-euclaAustralia/Eucla
au-lord-howeAustralia/Lord\_Howe
au-nswAustralia/Sydney
au-ntAustralia/Darwin
au-qldAustralia/Brisbane
au-saAustralia/Adelaide
au-tasAustralia/Hobart
au-vicAustralia/Melbourne
au-waAustralia/Perth
australian-capital-territoryAustralia/Sydney
austriaEurope/Vienna
beEurope/Brussels
belgienEurope/Brussels
belgiumEurope/Brussels
boiseAmerica/Boise
brisbaneAustralia/Brisbane
british-columbiaAmerica/Vancouver
ca-abAmerica/Edmonton
ca-atikokanAmerica/Atikokan
ca-bcAmerica/Vancouver
ca-crestonAmerica/Creston
ca-dawson-creekAmerica/Dawson\_Creek
ca-fort-nelsonAmerica/Fort\_Nelson
ca-mbAmerica/Winnipeg
ca-nbAmerica/Moncton
ca-nlAmerica/St\_Johns
ca-nsAmerica/Halifax
ca-ntAmerica/Yellowknife
ca-nuAmerica/Iqaluit
ca-onAmerica/Toronto
ca-peAmerica/Halifax
ca-qcAmerica/Toronto
ca-skAmerica/Regina
ca-swift-currentAmerica/Swift\_Current
ca-ytAmerica/Whitehorse
californiaAmerica/Los\_Angeles
canberraAustralia/Sydney
chEurope/Zurich
chicagoAmerica/Chicago
chileAmerica/Santiago
chileAmerica/Santiago
chinaAsia/Shanghai
clAmerica/Santiago
cnAsia/Shanghai
coeur-daleneAmerica/Los\_Angeles
coloradoAmerica/Denver
connecticutAmerica/New\_York
czEurope/Prague
czechEurope/Prague
daenemarkEurope/Copenhagen
darwinAustralia/Darwin
dcAmerica/New\_York
deEurope/Berlin
delawareAmerica/New\_York
denmarkEurope/Copenhagen
denverAmerica/Denver
detroitAmerica/Detroit
deutschlandEurope/Berlin
district-of-columbiaAmerica/New\_York
dkEurope/Copenhagen
edmontonAmerica/Edmonton
egAfrica/Cairo
egyptAfrica/Cairo
el-pasoAmerica/Denver
elpasoAmerica/Denver
emiratesAsia/Dubai
englandEurope/London
esEurope/Madrid
euclaAustralia/Eucla
fiEurope/Helsinki
finlandEurope/Helsinki
finnlandEurope/Helsinki
fl-panhandleAmerica/Chicago
floridaAmerica/New\_York
frEurope/Paris
franceEurope/Paris
frankreichEurope/Paris
gbEurope/London
georgiaAmerica/New\_York
germanyEurope/Berlin
gmtUTC
gmt0UTC
grEurope/Athens
greeceEurope/Athens
griechenlandEurope/Athens
grossbritannienEurope/London
guamPacific/Guam
halifaxAmerica/Halifax
hawaiiPacific/Honolulu
hkAsia/Hong\_Kong
hobartAustralia/Hobart
hollandEurope/Amsterdam
hongkongAsia/Hong\_Kong
honoluluPacific/Honolulu
huEurope/Budapest
hungaryEurope/Budapest
idahoAmerica/Boise
idaho-pacificAmerica/Los\_Angeles
ieEurope/Dublin
ilAsia/Jerusalem
illinoisAmerica/Chicago
inAsia/Kolkata
indiaAsia/Kolkata
indianaAmerica/Indiana/Indianapolis
indiana-centralAmerica/Chicago
indianapolisAmerica/Indiana/Indianapolis
indienAsia/Kolkata
iowaAmerica/Chicago
iqaluitAmerica/Iqaluit
irAsia/Tehran
iranAsia/Tehran
iranAsia/Tehran
irelandEurope/Dublin
irkutskAsia/Irkutsk
irlandEurope/Dublin
israelAsia/Jerusalem
israelAsia/Jerusalem
itEurope/Rome
italienEurope/Rome
italyEurope/Rome
japanAsia/Tokyo
jekaterinburgAsia/Yekaterinburg
jpAsia/Tokyo
kamchatkaAsia/Kamchatka
kamtschatkaAsia/Kamchatka
kansasAmerica/Chicago
kansas-mountainAmerica/Denver
kentuckyAmerica/New\_York
kentucky-centralAmerica/Chicago
koreaAsia/Seoul
krAsia/Seoul
krasnoyarskAsia/Krasnoyarsk
lord-howeAustralia/Lord\_Howe
los-angelesAmerica/Los\_Angeles
losangelesAmerica/Los\_Angeles
louisianaAmerica/Chicago
maAfrica/Casablanca
maineAmerica/New\_York
malheurAmerica/Boise
manitobaAmerica/Winnipeg
marokkoAfrica/Casablanca
marylandAmerica/New\_York
massachusettsAmerica/New\_York
melbourneAustralia/Melbourne
mexicoAmerica/Mexico\_City
mexikoAmerica/Mexico\_City
michiganAmerica/Detroit
michigan-centralAmerica/Chicago
minnesotaAmerica/Chicago
mississippiAmerica/Chicago
missouriAmerica/Chicag
montanaAmerica/Denver
montrealAmerica/Toronto
moroccoAfrica/Casablanca
moscowEurope/Moscow
moskauEurope/Moscow
mxAmerica/Mexico\_City
nebraskaAmerica/Chicago
nebraska-mountainAmerica/Denver
netherlandsEurope/Amsterdam
neuseelandPacific/Auckland
nevadaAmerica/Los\_Angeles
nevada-mountainAmerica/Denver
new-brunswickAmerica/Moncton
new-hampshireAmerica/New\_York
new-jerseyAmerica/New\_York
new-mexicoAmerica/Denver
new-south-walesAustralia/Sydney
new-yorkAmerica/New\_York
newfoundlandAmerica/St\_Johns
newmexicoAmerica/Denver
newyorkAmerica/New\_York
newzealandPacific/Auckland
ngAfrica/Lagos
niederlandeEurope/Amsterdam
nigeriaAfrica/Lagos
nlEurope/Amsterdam
nmiPacific/Saipan
noEurope/Oslo
north-carolinaAmerica/New\_York
north-dakotaAmerica/Chicago
north-dakota-mountainAmerica/Denver
northcarolinaAmerica/New\_York
northdakotaAmerica/Chicago
northern-mariana-islandsPacific/Saipan
northern-territoryAustralia/Darwin
northwest-territoriesAmerica/Yellowknife
norwayEurope/Oslo
norwegenEurope/Oslo
nova-scotiaAmerica/Halifax
nunavutAmerica/Iqaluit
nwtAmerica/Yellowknife
nyAmerica/New\_York
nzPacific/Auckland
ohioAmerica/New\_York
oklahomaAmerica/Chicago
ontarioAmerica/Toronto
oregonAmerica/Los\_Angeles
oregon-mountainAmerica/Boise
oesterreichEurope/Vienna
pago-pagoPacific/Pago\_Pago
pagopagoPacific/Pago\_Pago
peiAmerica/Halifax
pennsylvaniaAmerica/New\_York
pensacolaAmerica/Chicago
perthAustralia/Perth
phoenixAmerica/Phoenix
plEurope/Warsaw
polandEurope/Warsaw
polenEurope/Warsaw
polskaEurope/Warsaw
portlandAmerica/Los\_Angeles
portugalEurope/Lisbon
prince-edward-islandAmerica/Halifax
ptEurope/Lisbon
puerto-ricoAmerica/Puerto\_Rico
puertoricoAmerica/Puerto\_Rico
quebecAmerica/Toronto
québecAmerica/Toronto
queenslandAustralia/Brisbane
reginaAmerica/Regina
rhode-islandAmerica/New\_York
rhodeislandAmerica/New\_York
ru-irkAsia/Irkutsk
ru-kamAsia/Kamchatka
ru-krasAsia/Krasnoyarsk
ru-magadanAsia/Magadan
ru-mskEurope/Moscow
ru-novosibirskAsia/Novosibirsk
ru-omskAsia/Omsk
ru-samaraEurope/Samara
ru-vladAsia/Vladivostok
ru-yakutskAsia/Yakutsk
ru-yeAsia/Yekaterinburg
saAsia/Riyadh
saipanPacific/Saipan
saskatchewanAmerica/Regina
saudiAsia/Riyadh
saudi-arabienAsia/Riyadh
schwedenEurope/Stockholm
schweizEurope/Zurich
seEurope/Stockholm
seattleAmerica/Los\_Angeles
sgAsia/Singapore
singaporeAsia/Singapore
singapurAsia/Singapore
skEurope/Bratislava
slovakiaEurope/Bratislava
slowakeiEurope/Bratislava
south-australiaAustralia/Adelaide
south-carolinaAmerica/New\_York
south-dakotaAmerica/Chicago
south-dakota-mountainAmerica/Denver
southafricaAfrica/Johannesburg
southcarolinaAmerica/New\_York
southdakotaAmerica/Chicago
spainEurope/Madrid
spanienEurope/Madrid
st-johnsAmerica/St\_Johns
st-thomasAmerica/St\_Thomas
stjohnsAmerica/St\_Johns
stthomasAmerica/St\_Thomas
südafrikaAfrica/Johannesburg
südkoreaAsia/Seoul
swedenEurope/Stockholm
switzerlandEurope/Zurich
sydneyAustralia/Sydney
taiwanAsia/Taipei
tasmaniaAustralia/Hobart
tennesseeAmerica/Chicago
tennessee-easternAmerica/New\_York
texasAmerica/Chicago
texas-mountainAmerica/Denver
thAsia/Bangkok
thailandAsia/Bangkok
thailandAsia/Bangkok
torontoAmerica/Toronto
trEurope/Istanbul
tschechienEurope/Prague
tuerkeiEurope/Istanbul
turkeyEurope/Istanbul
twAsia/Taipei
uaEurope/Kyiv
uaeAsia/Dubai
ukEurope/London
ukraineEurope/Kyiv
ungarnEurope/Budapest
up-ctAmerica/Chicago
upper-peninsula-ctAmerica/Chicago
us-virgin-islandsAmerica/St\_Thomas
usa-adakAmerica/Adak
usa-akAmerica/Anchorage
usa-alAmerica/Chicago
usa-arAmerica/Chicago
usa-asPacific/Pago\_Pago
usa-azAmerica/Phoenix
usa-caAmerica/Los\_Angeles
usa-coAmerica/Denver
usa-ctAmerica/New\_York
usa-dcAmerica/New\_York
usa-deAmerica/New\_York
usa-flAmerica/New\_York
usa-fl-ctAmerica/Chicago
usa-gaAmerica/New\_York
usa-guPacific/Guam
usa-hiPacific/Honolulu
usa-iaAmerica/Chicago
usa-idAmerica/Boise
usa-id-ptAmerica/Los\_Angeles
usa-ilAmerica/Chicago
usa-inAmerica/Indiana/Indianapolis
usa-in-ctAmerica/Chicago
usa-in-knoxAmerica/Indiana/Knox
usa-in-tell-cityAmerica/Indiana/Tell\_City
usa-ksAmerica/Chicago
usa-ks-mtAmerica/Denver
usa-kyAmerica/New\_York
usa-ky-ctAmerica/Chicago
usa-ky-louisvilleAmerica/Kentucky/Louisville
usa-ky-monticelloAmerica/Kentucky/Monticello
usa-laAmerica/Chicago
usa-maAmerica/New\_York
usa-mdAmerica/New\_York
usa-meAmerica/New\_York
usa-metlakatlaAmerica/Metlakatla
usa-miAmerica/Detroit
usa-mi-ctAmerica/Chicago
usa-mi-menomineeAmerica/Menominee
usa-mnAmerica/Chicago
usa-moAmerica/Chicag
usa-mpPacific/Saipan
usa-msAmerica/Chicago
usa-mtAmerica/Denver
usa-ncAmerica/New\_York
usa-ndAmerica/Chicago
usa-nd-beulahAmerica/North\_Dakota/Beulah
usa-nd-centerAmerica/North\_Dakota/Center
usa-nd-mtAmerica/Denver
usa-nd-new-salemAmerica/North\_Dakota/New\_Salem
usa-neAmerica/Chicago
usa-ne-mtAmerica/Denver
usa-nhAmerica/New\_York
usa-njAmerica/New\_York
usa-nmAmerica/Denver
usa-nvAmerica/Los\_Angeles
usa-nv-mtAmerica/Denver
usa-nyAmerica/New\_York
usa-ohAmerica/New\_York
usa-okAmerica/Chicago
usa-orAmerica/Los\_Angeles
usa-or-mtAmerica/Boise
usa-paAmerica/New\_York
usa-prAmerica/Puerto\_Rico
usa-riAmerica/New\_York
usa-scAmerica/New\_York
usa-sdAmerica/Chicago
usa-sd-mtAmerica/Denver
usa-tnAmerica/Chicago
usa-tn-etAmerica/New\_York
usa-txAmerica/Chicago
usa-tx-mtAmerica/Denver
usa-utAmerica/Denver
usa-vaAmerica/New\_York
usa-viAmerica/St\_Thomas
usa-vtAmerica/New\_York
usa-waAmerica/Los\_Angeles
usa-wiAmerica/Chicago
usa-wvAmerica/New\_York
usa-wyAmerica/Denver
usviAmerica/St\_Thomas
utahAmerica/Denver
utcUTC
utc-0UTC
utc-1Etc/GMT+1
utc-10Etc/GMT+10
utc-11Etc/GMT+11
utc-12Etc/GMT+12
utc-2Etc/GMT+2
utc-3Etc/GMT+3
utc-4Etc/GMT+4
utc-5Etc/GMT+5
utc-6Etc/GMT+6
utc-7Etc/GMT+7
utc-8Etc/GMT+8
utc-9Etc/GMT+9
utc+0UTC
utc+1Etc/GMT-1
utc+10Etc/GMT-10
utc+11Etc/GMT-11
utc+12Etc/GMT-12
utc+2Etc/GMT-2
utc+3Etc/GMT-3
utc+4Etc/GMT-4
utc+5Etc/GMT-5
utc+6Etc/GMT-6
utc+7Etc/GMT-7
utc+8Etc/GMT-8
utc+9Etc/GMT-9
vancouverAmerica/Vancouver
vereinigte-arabische-emirateAsia/Dubai
vermontAmerica/New\_York
victoriaAustralia/Melbourne
vietnamAsia/Ho\_Chi\_Minh
vietnamAsia/Ho\_Chi\_Minh
virginiaAmerica/New\_York
vladivostokAsia/Vladivostok
vnAsia/Ho\_Chi\_Minh
washingtonAmerica/Los\_Angeles
washington-dcAmerica/New\_York
west-virginiaAmerica/New\_York
west-wendoverAmerica/Denver
western-australiaAustralia/Perth
westvirginiaAmerica/New\_York
westwendoverAmerica/Denver
whitehorseAmerica/Whitehorse
winnipegAmerica/Winnipeg
wisconsinAmerica/Chicago
wyomingAmerica/Denver
yekaterinburgAsia/Yekaterinburg
yukonAmerica/Whitehorse
zaAfrica/Johannesburg
# Webcamloader (🐧Debian / 08.25) Das Projekt ist nun unter [Webcamloader](https://wiki.mariobeh.de/books/behwiki/page/webcamloader "Webcamloader 🐧") direkt zu finden.