# 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