data/

netcheck.log

netcheck.conf

# netcheck — Langzeit-Monitoring der IPv4-/IPv6-Erreichbarkeit

Kleines, abhängigkeitsarmes Shell-Script, das über Tage oder Wochen protokolliert,

**wann** Verbindungsprobleme auftreten und **welcher Art** sie sind. Gedacht für

Fälle, in denen ein Kunde "immer mal wieder" Störungen meldet, sich aber niemand

zum Zeitpunkt des Fehlers am Rechner befindet.

Pro Durchlauf wird für jedes Ziel und jede Protokollfamilie gemessen:

- **curl-Timing** — DNS-Auflösung, TCP-Connect, TLS-Handshake, Time-to-first-byte,

  Gesamtdauer, HTTP-Status und die tatsächlich kontaktierte IP

- **mtr-Pfadmessung** — Paketverlust und Latenz pro Hop, im TCP-Modus auf Port 443

Ergebnis ist eine CSV-Datei mit einer Zeile je Ziel und Protokoll sowie —

ausschließlich bei auffälligen Läufen — ein Rohlog mit der vollständigen

mtr-Ausgabe und einer längeren Nachmessung.

---

## Warum diese Kombination

Die beiden Messungen beantworten unterschiedliche Fragen, und erst zusammen

grenzen sie eine Störung ein:

| Beobachtung | Interpretation |

|---|---|

| curl schlägt fehl, mtr erreicht das Ziel sauber | Netzpfad in Ordnung, Problem liegt auf Anwendungsebene — Webserver, TLS, WAF, Rate-Limit |

| curl und mtr scheitern gemeinsam | Netzproblem, mtr zeigt im Rohlog den Hop, ab dem es abreißt |

| nur IPv6 betroffen, IPv4 läuft | Dual-Stack-Problem — fehlende Route, kaputte Router-Advertisements, PMTU |

| hohe `tls_ms` bei normalem `connect_ms` | TLS-Handshake ist langsam, nicht die Leitung |

| hohe `ttfb_ms` bei normalem `tls_ms` | Server denkt lange nach, Netz ist unschuldig |

| Verlust auf einem Zwischenhop, Ziel aber 0 % | Meist harmlos: der Router priorisiert nur seine eigenen ICMP-Antworten herunter |

Die letzte Zeile ist der häufigste Fehlschluss beim Lesen von mtr-Ausgaben.

Relevant ist Verlust nur, wenn er sich **ab einem Hop bis zum Ziel durchzieht**.

---

## Installation

### Voraussetzungen

- `bash`, `curl`, `awk`, `find` — auf macOS und jedem Linux vorhanden

- `mtr` — muss nachinstalliert werden:

  - macOS: `brew install mtr`

  - Debian/Ubuntu: `sudo apt install mtr-tiny`

  - RHEL/Rocky: `sudo dnf install mtr`

Ohne `mtr` läuft das Script weiter, zeichnet dann aber nur die curl-Messungen auf.

### Dateien ablegen

```bash

sudo mkdir -p /usr/local/netcheck

sudo cp netcheck.sh /usr/local/netcheck/

sudo chmod +x /usr/local/netcheck/netcheck.sh

sudo cp netcheck.conf.example /usr/local/netcheck/netcheck.conf

sudo vi /usr/local/netcheck/netcheck.conf

```

### Rechte

`mtr` benötigt Raw Sockets und damit Root-Rechte. Drei Varianten, absteigend

nach Sauberkeit:

1. **Als root per Scheduler starten** (empfohlen, siehe unten) — dann ist nichts

   weiter zu tun.

2. **Passwortloses sudo nur für mtr.** Das Script erkennt das automatisch und

   ruft `sudo -n mtr` auf. Regel anlegen mit `sudo visudo -f /etc/sudoers.d/netcheck`:

   ```

   deinbenutzer ALL=(root) NOPASSWD: /opt/homebrew/bin/mtr

   ```

   Pfad vorher mit `command -v mtr` prüfen — unter Linux meist `/usr/bin/mtr`.

3. **Ohne Root** — dann bleiben die mtr-Spalten leer und es werden nur

   curl-Messungen aufgezeichnet. Für eine erste Eingrenzung reicht das oft.

### Prüfen

```bash

/usr/local/netcheck/netcheck.sh selftest

```

Der Selbsttest meldet fehlende Werkzeuge, die Rechtelage und macht einen

Testabruf pro Ziel und Protokollfamilie.

---

## Betrieb

| Befehl | Wirkung |

|---|---|

| `netcheck.sh once` | einmaliger Lauf mit Ausgabe im Terminal |

| `netcheck.sh run` | einmaliger Lauf, still — für cron, launchd, systemd |

| `netcheck.sh daemon` | Endlosschleife im Abstand von `INTERVAL` |

| `netcheck.sh stop` | beendet einen laufenden `daemon` sauber |

| `netcheck.sh summary` | Auswertung der gesammelten Daten |

| `netcheck.sh selftest` | prüft Voraussetzungen, Rechte und Erreichbarkeit |

### Einzelner Lauf mit Ausgabe

```bash

sudo /usr/local/netcheck/netcheck.sh once

```

### Dauerbetrieb im Vordergrund

Praktisch, um über Nacht in einer Terminal-Session mitlaufen zu lassen:

```bash

sudo /usr/local/netcheck/netcheck.sh daemon

```

### Sauber beenden

**Ctrl+C** im Terminal, oder aus einer zweiten Shell:

```bash

sudo /usr/local/netcheck/netcheck.sh stop

```

Beides läuft über denselben Weg: das Script merkt sich den Stopp-Wunsch,

beendet die gerade laufende Messung und **verwirft sie ersatzlos** — eine

abgebrochene Messung landet nicht in der CSV. Das ist der entscheidende Punkt,

denn eine mitten im Lauf abgeschossene curl- oder mtr-Messung sieht in den Daten

exakt wie ein echter Ausfall aus und würde die Auswertung verfälschen. Im

Betriebslog steht stattdessen eine `SKIP`-Zeile.

Ein zweites Ctrl+C erzwingt den sofortigen Abbruch. Dann kann eine unvollständige

Messung in den Rohlogs zurückbleiben — die CSV bleibt aber auch in diesem Fall

sauber, weil die Zeile erst nach vollständiger Messung geschrieben wird.

`netcheck.sh stop` findet die laufende Instanz über die Sperrdatei, wartet bis

zu 60 Sekunden auf ein sauberes Ende und greift erst danach härter durch. Eine

verwaiste Sperre nach einem Absturz räumt es ebenfalls auf.

Falls doch einmal etwas hängt — etwa nach einem `kill -9` —, hilft:

```bash

sudo pkill -9 -f 'netcheck.sh daemon'

sudo pkill -9 mtr

sudo rm -rf /usr/local/netcheck/data/.lock

```

### Verfälschte Zeilen nachträglich entfernen

Wurden durch einen harten Abbruch doch Scheinausfälle aufgezeichnet, lassen sie

sich gezielt löschen. Von einem Signal abgeschossene Messungen haben einen

`curl_exit` ab 128 (meist 130 für SIGINT):

```bash

cd /usr/local/netcheck/data/csv

for f in netcheck-*.csv; do

  awk -F, 'NR==1 || $8+0 < 128' "$f" > "$f.tmp" && mv "$f.tmp" "$f"

done

```

Alternativ alle Zeilen eines bestimmten Laufs anhand der `runid` (Spalte 3, im

Format `JJJJMMTT-HHMMSS`) entfernen:

```bash

awk -F, '$3 != "20260902-143000"' netcheck-2026-09.csv > tmp && mv tmp netcheck-2026-09.csv

```

Vorher mit `grep` prüfen, was die Filter treffen würden — die CSV ist die

Beweislage, versehentlich gelöschte echte Ausfälle sind nicht rekonstruierbar.

### Dauerbetrieb per Scheduler

**macOS (launchd):**

```bash

sudo cp cloud.tytik.netcheck.plist /Library/LaunchDaemons/

sudo chown root:wheel /Library/LaunchDaemons/cloud.tytik.netcheck.plist

sudo chmod 644 /Library/LaunchDaemons/cloud.tytik.netcheck.plist

sudo launchctl load -w /Library/LaunchDaemons/cloud.tytik.netcheck.plist

```

Vorher den Pfad in `ProgramArguments` und das Intervall in `StartInterval`

kontrollieren. Beenden mit `launchctl unload -w …`.

**Linux (systemd):**

```bash

sudo cp netcheck.service netcheck.timer /etc/systemd/system/

sudo systemctl daemon-reload

sudo systemctl enable --now netcheck.timer

systemctl list-timers netcheck.timer

```

**Linux (cron), falls systemd nicht gewünscht ist:**

```

*/5 * * * * root /usr/local/netcheck/netcheck.sh run

```

Überlappende Läufe sind ausgeschlossen: das Script setzt eine Sperre und

überspringt einen Start, solange der vorherige Lauf noch läuft.

---

## Konfiguration

Alle Werte stehen in `netcheck.conf` neben dem Script (Vorlage:

`netcheck.conf.example`). Die wichtigsten:

| Variable | Default | Bedeutung |

|---|---|---|

| `TARGETS` | `kreuzfahrten.de` | Ziele, durch Leerzeichen getrennt, ohne `https://` |

| `FAMILIES` | `4 6` | zu prüfende Protokollfamilien |

| `OUTDIR` | `./data` | Ablage für CSV, Rohlogs und Logfile |

| `INTERVAL` | `300` | Abstand im `daemon`-Modus in Sekunden |

| `MTR_CYCLES` | `10` | Pings pro Hop im Normalfall |

| `MTR_ANOMALY_CYCLES` | `30` | Pings pro Hop bei der Nachmessung |

| `LOSS_WARN` | `5` | Paketverlust zum Ziel in %, ab dem ein Lauf auffällig ist |

| `RTT_WARN` | `150` | mittlere Latenz zum Ziel in ms |

| `TOTAL_WARN` | `3000` | curl-Gesamtzeit in ms |

| `SNAPSHOT_ON_ANOMALY` | `0` | bei Auffälligkeit zusätzlich den lokalen Netzzustand mitschreiben |

| `RAW_RETENTION_DAYS` | `30` | Rohlogs älter als N Tage löschen, `0` = nie |

**Empfehlung zur Zielauswahl:** neben dem eigentlichen Kundenziel ein bis zwei

stabile Referenzziele aufnehmen, etwa `one.one.one.one` und eine große deutsche

Site. Fällt nur das Kundenziel aus, liegt es am Ziel; fallen alle gleichzeitig

aus, liegt es an der Leitung des Kunden. Diese Unterscheidung erspart die

längsten Diskussionen.

**`SNAPSHOT_ON_ANOMALY=1`** lohnt sich, wenn ein Problem am Client oder am

Kundenrouter vermutet wird. Das Script schreibt dann bei jeder Auffälligkeit

Default-Routen, Router-Advertisements und Interface-Adressen mit — genau die

Angaben, an denen etwa eine verschwundene IPv6-Default-Route sofort sichtbar wird.

---

## Auswertung

```bash

/usr/local/netcheck/netcheck.sh summary          # alle vorhandenen Monate

/usr/local/netcheck/netcheck.sh summary 2026-09  # nur September 2026

```

Ausgabe: Messzeitraum, je Ziel und Protokoll die Zahl der Läufe, Fehler und

Auffälligkeiten samt Durchschnitts- und Maximalwerten, die häufigsten Ursachen

sowie eine Verteilung der Auffälligkeiten nach Tag und nach Tageszeit. Die

Tageszeit-Verteilung ist der schnellste Weg zu einem Muster — Häufungen zur

vollen Stunde deuten auf Backups oder Cronjobs, abendliche Häufungen auf

Überlast im Zugangsnetz, gleichmäßige Verteilung eher auf ein Hardware- oder

Routingproblem.

### Rohdaten

`data/csv/netcheck-YYYY-MM.csv` — eine Zeile je Ziel und Protokoll, direkt in

Excel, LibreOffice oder Grafana einlesbar. Spalten:

| Spalte | Bedeutung |

|---|---|

| `ts`, `epoch`, `runid` | Zeitstempel des Laufs |

| `target`, `family` | Ziel und Protokollfamilie (4 oder 6) |

| `resolved_ip` | tatsächlich kontaktierte IP — verrät CDN-Wechsel |

| `curl_ok`, `curl_exit`, `http_code` | Erfolg, curl-Exitcode, HTTP-Status |

| `dns_ms`, `connect_ms`, `tls_ms`, `ttfb_ms`, `total_ms` | curl-Timing, kumulativ |

| `mtr_ok`, `mtr_loss_pct`, `mtr_avg_ms`, `mtr_worst_ms` | Messwerte am Ziel-Hop |

| `mtr_max_hop_loss` | höchster Verlust auf irgendeinem Hop |

| `mtr_hops`, `dest_reached` | Hop-Anzahl, ob das Ziel geantwortet hat |

| `anomaly`, `reason` | Bewertung des Laufs und Klartextbegründung |

| `rawfile` | Pfad zum Rohlog, relativ zu `data/raw/` |

Die curl-Zeiten sind **kumulativ**: `tls_ms` enthält `connect_ms`, dieses enthält

`dns_ms`. Die Dauer des TLS-Handshakes allein ist also `tls_ms − connect_ms`.

`data/raw/YYYY-MM-DD/…` — Rohlogs auffälliger Läufe mit vollständiger

mtr-Ausgabe, Kurzlauf und Nachmessung.

`data/netcheck.log` — Betriebsprotokoll mit einer Zeile je Auffälligkeit.

### Schnelle Handgriffe

```bash

# Alle Ausfälle chronologisch

awk -F, '$7==0 {print $1, $4, "IPv"$5, $23}' data/csv/*.csv

# Nur IPv6-Probleme

awk -F, '$5==6 && $22==1 {print $1, $23}' data/csv/*.csv

# Latenzverlauf eines Ziels für ein Diagramm

awk -F, '$4=="kreuzfahrten.de" && $5==4 && $15==1 {print $1","$17}' data/csv/*.csv

```

---

## Wartung

Rohlogs werden nach `RAW_RETENTION_DAYS` automatisch gelöscht, CSV-Dateien

bleiben liegen — sie sind klein (rund 200 Byte pro Messung, bei zwei Zielen im

Dual-Stack und 5-Minuten-Takt etwa 6 MB im Monat) und bilden die eigentliche

Beweislage gegenüber dem Provider.

Belastung: ein Lauf erzeugt pro Ziel und Familie einen HTTPS-HEAD-Request und

`MTR_CYCLES` Pakete je Hop. Bei den Defaults sind das wenige Kilobyte alle fünf

Minuten — unbedenklich auch auf einer schwachen Leitung.

---

## Grenzen

Das Script misst vom Standort aus, an dem es läuft. Meldet der Kunde Probleme,

die hier nicht auftauchen, liegt das Problem entweder beim Kunden selbst oder

tritt nur unter Last auf. In dem Fall gehört eine zweite Instanz auf einen

Rechner im Netz des Kunden — die CSV-Dateien beider Instanzen lassen sich über

die Zeitstempel direkt nebeneinanderlegen.

Ebenfalls nicht abgedeckt: Durchsatzmessungen, DNS-Vergleich zwischen mehreren

Resolvern und die Analyse einzelner TCP-Verbindungen. Lässt sich alles ergänzen,

war für diesen Zweck aber bewusst nicht Teil des Umfangs.

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

<!--

  launchd-Job fuer netcheck.sh auf macOS.

  Installation (als root, damit mtr Raw Sockets oeffnen darf):

    sudo cp cloud.tytik.netcheck.plist /Library/LaunchDaemons/

    sudo chown root:wheel /Library/LaunchDaemons/cloud.tytik.netcheck.plist

    sudo chmod 644 /Library/LaunchDaemons/cloud.tytik.netcheck.plist

    sudo launchctl load -w /Library/LaunchDaemons/cloud.tytik.netcheck.plist

  Deinstallation:

    sudo launchctl unload -w /Library/LaunchDaemons/cloud.tytik.netcheck.plist

  Pfad in ProgramArguments an den tatsaechlichen Ablageort anpassen.

-->

<plist version="1.0">

<dict>

    <key>Label</key>

    <string>cloud.tytik.netcheck</string>

    <key>ProgramArguments</key>

    <array>

        <string>/usr/local/netcheck/netcheck.sh</string>

        <string>run</string>

    </array>

    <!-- alle 300 Sekunden -->

    <key>StartInterval</key>

    <integer>300</integer>

    <key>RunAtLoad</key>

    <true/>

    <key>StandardOutPath</key>

    <string>/var/log/netcheck-launchd.log</string>

    <key>StandardErrorPath</key>

    <string>/var/log/netcheck-launchd.log</string>

    <key>EnvironmentVariables</key>

    <dict>

        <key>PATH</key>

        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>

    </dict>

    <!-- Verhindert, dass der Job bei Ressourcenknappheit gedrosselt wird -->

    <key>LowPriorityIO</key>

    <false/>

    <key>Nice</key>

    <integer>0</integer>

</dict>

</plist>

# netcheck.conf - Konfiguration fuer netcheck.sh

#

# Diese Datei nach "netcheck.conf" kopieren und anpassen. Sie wird vom Script

# eingelesen (sourced) und ueberschreibt die eingebauten Defaults.

# Environment-Variablen beim Aufruf haben Vorrang vor dieser Datei nicht -

# die Datei gewinnt, weil sie zuletzt gelesen wird. Wer einzelne Werte

# temporaer uebersteuern will, kommentiert sie hier aus.

# --- Was gemessen wird ------------------------------------------------------

# Zu pruefende Ziele, durch Leerzeichen getrennt, ohne https://

# Sinnvoll ist eine Mischung: das eigentliche Kundenziel plus ein bis zwei

# stabile Referenzziele. Faellt nur das Kundenziel aus, liegt es am Ziel.

# Fallen alle gleichzeitig aus, liegt es an der Leitung des Kunden.

TARGETS="tytik.cloud www.heise.de one.one.one.one"

# Protokollfamilien

FAMILIES="4 6"

# Pfad, der per HTTPS abgerufen wird

CURL_PATH="/"

# HEAD spart Traffic, GET misst realistischer. Manche WAFs mogen HEAD nicht -

# wenn dauerhaft 405 oder 403 kommt, auf GET wechseln.

CURL_METHOD="HEAD"

# --- Zeitverhalten ----------------------------------------------------------

# Abstand zwischen den Laeufen im daemon-Modus (Sekunden).

# Bei cron/launchd steuert das Intervall dort, nicht hier.

INTERVAL=300

# mtr-Zyklen im Normalfall und bei einer Auffaelligkeit

MTR_CYCLES=10

MTR_ANOMALY_CYCLES=30

CURL_CONNECT_TIMEOUT=10

CURL_MAX_TIME=20

# --- Schwellwerte -----------------------------------------------------------

# Ab diesen Werten gilt ein Lauf als auffaellig, wird im Log vermerkt und

# erzeugt ein Rohlog mit ausfuehrlicher mtr-Nachmessung.

LOSS_WARN=5          # Paketverlust zum Ziel in Prozent

RTT_WARN=150         # mittlere Latenz zum Ziel in ms

TOTAL_WARN=3000      # curl-Gesamtzeit in ms

# --- Ablage -----------------------------------------------------------------

# Standard ist ein Unterverzeichnis "data" neben dem Script.

# Fuer den Dauerbetrieb besser ein fester Pfad:

# OUTDIR="/var/log/netcheck"

# Rohlogs aelter als N Tage werden geloescht. 0 = nie loeschen.

RAW_RETENTION_DAYS=30

# Bei Auffaelligkeit zusaetzlich den lokalen Netzzustand mitschreiben

# (Default-Routen, Router-Advertisements, Interface-Adressen).

# Sehr hilfreich, wenn der Verdacht auf ein Problem am Client oder am

# Kundenrouter besteht - etwa eine verschwundene IPv6-Default-Route.

SNAPSHOT_ON_ANOMALY=1

# --- Feinheiten -------------------------------------------------------------

# mtr-Messmodus. TCP/443 kommt durch die meisten Filter. Alternativen:

#   "-T -P 443"   TCP SYN auf 443 (Default, empfohlen)

#   "-u"          UDP

#   ""            ICMP

MTR_MODE="-T -P 443"

# "-b" zeigt Hostname und IP je Hop. "-n" verzichtet auf Reverse-DNS und

# macht die Messung schneller, kostet aber Lesbarkeit.

MTR_EXTRA="-b"

# systemd-Service fuer netcheck.sh (Linux)

#

# Installation:

#   sudo cp netcheck.service netcheck.timer /etc/systemd/system/

#   sudo systemctl daemon-reload

#   sudo systemctl enable --now netcheck.timer

#

# Status und Logs:

#   systemctl list-timers netcheck.timer

#   journalctl -u netcheck.service -f

[Unit]

Description=netcheck - IPv4/IPv6 Verbindungsmonitoring

Wants=network-online.target

After=network-online.target

[Service]

Type=oneshot

# Als root, damit mtr Raw Sockets oeffnen darf

User=root

ExecStart=/usr/local/netcheck/netcheck.sh run

# Ein Lauf darf nie laenger dauern als das Timer-Intervall

TimeoutStartSec=240

Nice=5

#!/usr/bin/env bash

#

# netcheck.sh - Langzeit-Monitoring der IPv4-/IPv6-Erreichbarkeit

#

# Misst pro Durchlauf und pro Ziel jeweils fuer IPv4 und IPv6:

#   - curl-Timing (DNS, TCP-Connect, TLS-Handshake, TTFB, gesamt, HTTP-Status)

#   - mtr-Pfadmessung (Loss und Latenz pro Hop, TCP-Modus auf Port 443)

#

# Schreibt eine CSV-Zeile pro Ziel/Protokoll und legt die vollstaendige

# mtr-Ausgabe als Rohlog ab, wenn eine Messung auffaellig war.

#

# Laeuft auf macOS und Linux. Bewusst bash-3.2-kompatibel (macOS-Bordmittel).

#

# Aufruf:

#   ./netcheck.sh once              einmaliger Lauf mit Ausgabe auf stdout

#   ./netcheck.sh run               einmaliger Lauf, still (fuer cron/launchd)

#   ./netcheck.sh daemon            Endlosschleife im Abstand von INTERVAL

#   ./netcheck.sh stop              beendet einen laufenden daemon sauber

#   ./netcheck.sh summary [YYYY-MM] Auswertung der gesammelten Daten

#   ./netcheck.sh selftest          prueft Voraussetzungen und Konfiguration

#

# Version 1.2

#

set -u

# PATH explizit setzen: cron und launchd starten mit minimalem Environment,

# Homebrew-Tools (mtr) liegen dort sonst ausserhalb des Suchpfads.

PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$PATH"

export PATH

export LC_ALL=C

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"

# ---------------------------------------------------------------------------

# Konfiguration (per netcheck.conf neben dem Script oder per Environment)

# ---------------------------------------------------------------------------

# Zu pruefende Ziele, durch Leerzeichen getrennt. Hostnamen ohne Schema.

TARGETS="${TARGETS:-kreuzfahrten.de}"

# Protokollfamilien: "4 6", "4" oder "6"

FAMILIES="${FAMILIES:-4 6}"

# Ablageort fuer CSV, Rohlogs und Logfile

OUTDIR="${OUTDIR:-$SCRIPT_DIR/data}"

# Wartezeit zwischen den Laeufen im daemon-Modus (Sekunden)

INTERVAL="${INTERVAL:-300}"

# mtr: Anzahl Pings pro Hop im Normalfall bzw. bei Auffaelligkeit

MTR_CYCLES="${MTR_CYCLES:-10}"

MTR_ANOMALY_CYCLES="${MTR_ANOMALY_CYCLES:-30}"

# mtr-Modus. TCP auf 443 ist am aussagekraeftigsten, weil viele CDNs

# UDP-/ICMP-Traceroute verwerfen. "-b" zeigt Hostname und IP.

MTR_MODE="${MTR_MODE:--T -P 443}"

MTR_EXTRA="${MTR_EXTRA:--b}"

# curl

CURL_METHOD="${CURL_METHOD:-HEAD}"       # HEAD oder GET

CURL_PATH="${CURL_PATH:-/}"

CURL_CONNECT_TIMEOUT="${CURL_CONNECT_TIMEOUT:-10}"

CURL_MAX_TIME="${CURL_MAX_TIME:-20}"

CURL_UA="${CURL_UA:-netcheck/1.0 (Verbindungsmonitoring)}"

# Schwellwerte, ab denen ein Lauf als auffaellig gilt und ein Rohlog entsteht

LOSS_WARN="${LOSS_WARN:-5}"              # Paketverlust zum Ziel in Prozent

RTT_WARN="${RTT_WARN:-150}"              # mittlere Latenz zum Ziel in ms

TOTAL_WARN="${TOTAL_WARN:-3000}"         # curl-Gesamtzeit in ms

# Lokalen Netz-Snapshot (Routen, Router-Advertisements, Interface-Adressen)

# bei Auffaelligkeit mitschreiben. 1 = an, 0 = aus.

SNAPSHOT_ON_ANOMALY="${SNAPSHOT_ON_ANOMALY:-0}"

# Rohlogs aelter als N Tage loeschen. 0 = nie loeschen.

RAW_RETENTION_DAYS="${RAW_RETENTION_DAYS:-30}"

# Konfigurationsdatei ueberschreibt die Defaults oben

CONF="${NETCHECK_CONF:-$SCRIPT_DIR/netcheck.conf}"

if [ -f "$CONF" ]; then

    # shellcheck disable=SC1090

    . "$CONF"

fi

# Original-stderr auf FD 9 sichern. Waehrend einer mtr-Messung ist stderr in

# die Rohdatei umgeleitet; Meldungen aus dem Signalhandler wuerden dort landen

# statt im Terminal. Ueber FD 9 erreichen sie immer den Benutzer.

exec 9>&2

CSV_DIR="$OUTDIR/csv"

RAW_DIR="$OUTDIR/raw"

LOGFILE="$OUTDIR/netcheck.log"

LOCKDIR="$OUTDIR/.lock"

CSV_HEADER="ts,epoch,runid,target,family,resolved_ip,curl_ok,curl_exit,http_code,dns_ms,connect_ms,tls_ms,ttfb_ms,total_ms,mtr_ok,mtr_loss_pct,mtr_avg_ms,mtr_worst_ms,mtr_max_hop_loss,mtr_hops,dest_reached,anomaly,reason,rawfile"

VERBOSE=0

# Laufzeitzustand fuer die Signalbehandlung

STOP=0            # 1 = Abbruch angefordert, laufende Messung verwerfen

SIGCOUNT=0        # Anzahl empfangener Abbruchsignale

CHILD_PID=""      # PID des gerade laufenden Messprozesses

SLEEP_PID=""      # PID des laufenden sleep im daemon-Modus

LOCK_HELD=0

# ---------------------------------------------------------------------------

# Hilfsfunktionen

# ---------------------------------------------------------------------------

log() {

    printf '%s %s\n' "$(date '+%Y-%m-%dT%H:%M:%S%z')" "$*" >>"$LOGFILE"

    [ "$VERBOSE" -eq 1 ] && printf '%s\n' "$*" >&9

    return 0

}

die() {

    printf 'netcheck: %s\n' "$*" >&2

    exit 1

}

# Portabler Timeout-Wrapper: macOS hat kein timeout(1).

# Aufruf: run_timeout SEKUNDEN BEFEHL [ARGS...]

run_timeout() {

    _to_secs="$1"

    shift

    "$@" &

    _to_cmd=$!

    CHILD_PID="$_to_cmd"

    ( sleep "$_to_secs"; kill -TERM "$_to_cmd" 2>/dev/null ) &

    _to_watch=$!

    wait "$_to_cmd" 2>/dev/null

    _to_rc=$?

    CHILD_PID=""

    kill -TERM "$_to_watch" 2>/dev/null

    wait "$_to_watch" 2>/dev/null

    return "$_to_rc"

}

# Sekunden (curl-Format, z.B. 0,123456 oder 0.123456) in Millisekunden

to_ms() {

    printf '%s' "$1" | awk '{ gsub(",", ".", $0); printf "%.1f", $0 * 1000 }'

}

csv_escape() {

    # Kommas und Anfuehrungszeichen aus Freitextfeldern entfernen

    printf '%s' "$1" | tr ',"' '; '

}

have() { command -v "$1" >/dev/null 2>&1; }

# ---------------------------------------------------------------------------

# Messungen

# ---------------------------------------------------------------------------

# curl-Timing. Setzt die globalen Variablen c_ok c_exit c_code c_dns c_con

# c_tls c_ttfb c_total c_ip

measure_curl() {

    _target="$1"

    _fam="$2"

    _method_opt="-I -o /dev/null"

    [ "$CURL_METHOD" = "GET" ] && _method_opt="-o /dev/null"

    _fmt='%{http_code} %{time_namelookup} %{time_connect} %{time_appconnect} %{time_starttransfer} %{time_total} %{remote_ip}'

    _out=""

    # shellcheck disable=SC2086

    _out="$(curl "-$_fam" $_method_opt -sS \

        --connect-timeout "$CURL_CONNECT_TIMEOUT" \

        --max-time "$CURL_MAX_TIME" \

        -A "$CURL_UA" \

        -w "$_fmt" \

        "https://${_target}${CURL_PATH}" 2>/dev/null)"

    c_exit=$?

    if [ -n "$_out" ]; then

        set -- $_out

        c_code="${1:-000}"

        c_dns="$(to_ms "${2:-0}")"

        c_con="$(to_ms "${3:-0}")"

        c_tls="$(to_ms "${4:-0}")"

        c_ttfb="$(to_ms "${5:-0}")"

        c_total="$(to_ms "${6:-0}")"

        c_ip="${7:-}"

    else

        c_code="000"; c_dns=""; c_con=""; c_tls=""; c_ttfb=""; c_total=""; c_ip=""

    fi

    if [ "$c_exit" -eq 0 ] && [ "$c_code" != "000" ]; then

        c_ok=1

    else

        c_ok=0

    fi

}

# mtr-Pfadmessung. Setzt m_ok m_loss m_avg m_worst m_maxhoploss m_hops

# m_dest_reached und schreibt die Rohausgabe nach "$1"

measure_mtr() {

    _target="$1"

    _fam="$2"

    _cycles="$3"

    _rawfile="$4"

    m_ok=0; m_loss=""; m_avg=""; m_worst=""; m_maxhoploss=""; m_hops=""

    m_dest_reached=0

    have mtr || { log "WARN mtr nicht gefunden - Pfadmessung uebersprungen"; return 1; }

    # mtr braucht Raw Sockets. Als root direkt, sonst passwortloses sudo.

    _mtr="mtr"

    if [ "$(id -u)" -ne 0 ]; then

        if sudo -n true 2>/dev/null; then

            _mtr="sudo -n mtr"

        fi

    fi

    # Grosszuegiger Timeout: ein Zyklus pro Sekunde plus Puffer

    _timeout=$(( _cycles + 30 ))

    # shellcheck disable=SC2086

    run_timeout "$_timeout" $_mtr "-$_fam" $MTR_MODE $MTR_EXTRA -r -w \

        -c "$_cycles" "$_target" >"$_rawfile" 2>&1

    _rc=$?

    if [ "$_rc" -ne 0 ] && [ ! -s "$_rawfile" ]; then

        log "WARN mtr -$_fam $_target fehlgeschlagen (exit $_rc)"

        return 1

    fi

    # Aus dem Report die Hop-Zeilen auswerten. Die letzten sieben Spalten sind

    # immer Loss% Snt Last Avg Best Wrst StDev - unabhaengig davon, wie breit

    # die Hostspalte ist. Deshalb wird von hinten indiziert.

    _parsed="$(awk '

        BEGIN { maxloss = 0; hops = 0; last_loss = 0; last_avg = 0; last_wrst = 0; last_host = "???" }

        /\|--/ {

            loss = $(NF-6); sub("%", "", loss);

            avg  = $(NF-3);

            wrst = $(NF-1);

            host = $2;

            hops++;

            if (loss+0 > maxloss+0) maxloss = loss;

            last_loss = loss; last_avg = avg; last_wrst = wrst; last_host = host;

        }

        END {

            if (hops == 0) { print "NA"; exit }

            reached = (last_host == "???" || last_loss+0 >= 100) ? 0 : 1;

            printf "%s %s %s %s %d %d\n", last_loss, last_avg, last_wrst, maxloss, hops, reached;

        }' "$_rawfile")"

    [ "$_parsed" = "NA" ] && { log "WARN mtr -$_fam $_target lieferte keine Hops"; return 1; }

    set -- $_parsed

    m_loss="${1:-}"; m_avg="${2:-}"; m_worst="${3:-}"; m_maxhoploss="${4:-0}"

    m_hops="${5:-0}"; m_dest_reached="${6:-0}"

    m_ok=1

    return 0

}

# Lokaler Netz-Snapshot bei Auffaelligkeit

snapshot() {

    _file="$1"

    {

        echo "=== $(date '+%Y-%m-%dT%H:%M:%S%z') lokaler Netz-Snapshot ==="

        if [ "$(uname -s)" = "Darwin" ]; then

            echo "--- scutil --nwi"; scutil --nwi 2>&1

            echo "--- netstat -rn -f inet6 | grep default"

            netstat -rn -f inet6 2>/dev/null | grep default

            echo "--- netstat -rn -f inet | grep default"

            netstat -rn -f inet 2>/dev/null | grep default

            echo "--- ndp -rn"; ndp -rn 2>&1

            echo "--- ifconfig (global)"; ifconfig 2>/dev/null | grep -E '^[a-z]|inet '

        elif have ip; then

            echo "--- ip -6 route"; ip -6 route 2>&1

            echo "--- ip -4 route"; ip -4 route 2>&1

            echo "--- ip -brief addr"; ip -brief addr 2>&1

            echo "--- ip -6 neigh"; ip -6 neigh 2>&1

        else

            echo "--- netstat -rn (iproute2 nicht vorhanden)"

            netstat -rn 2>&1

            echo "--- ifconfig"; ifconfig 2>&1 | grep -E '^[a-z]|inet'

        fi

    } >>"$_file" 2>&1

}

# ---------------------------------------------------------------------------

# Ein Durchlauf

# ---------------------------------------------------------------------------

do_run() {

    _ts="$(date '+%Y-%m-%dT%H:%M:%S%z')"

    _epoch="$(date '+%s')"

    _runid="$(date '+%Y%m%d-%H%M%S')"

    _day="$(date '+%Y-%m-%d')"

    _month="$(date '+%Y-%m')"

    _csv="$CSV_DIR/netcheck-$_month.csv"

    [ -f "$_csv" ] || printf '%s\n' "$CSV_HEADER" >"$_csv"

    mkdir -p "$RAW_DIR/$_day"

    for _target in $TARGETS; do

        for _fam in $FAMILIES; do

            [ "$STOP" -eq 1 ] && break

            measure_curl "$_target" "$_fam"

            # Wurde die Messung durch ein Abbruchsignal zerrissen, waere das

            # Ergebnis ein Scheinausfall. Solche Werte gehoeren nicht in die

            # Auswertung, deshalb wird die Messung ersatzlos verworfen.

            if [ "$STOP" -eq 1 ]; then

                log "SKIP $_target IPv$_fam waehrend Abbruch verworfen (nicht gewertet)"

                break

            fi

            _tmpraw="$RAW_DIR/$_day/.tmp-$_runid-$_target-v$_fam.txt"

            measure_mtr "$_target" "$_fam" "$MTR_CYCLES" "$_tmpraw"

            if [ "$STOP" -eq 1 ]; then

                rm -f "$_tmpraw"

                log "SKIP $_target IPv$_fam waehrend Abbruch verworfen (nicht gewertet)"

                break

            fi

            # Auffaelligkeit bewerten

            _anomaly=0

            _reason=""

            if [ "$c_ok" -ne 1 ]; then

                _anomaly=1

                _reason="curl fehlgeschlagen (exit $c_exit, http $c_code)"

            elif [ -n "$c_total" ] && [ "$(awk -v a="$c_total" -v b="$TOTAL_WARN" 'BEGIN{print (a>b)?1:0}')" = "1" ]; then

                _anomaly=1

                _reason="curl langsam (${c_total} ms)"

            fi

            case "$c_code" in

                ""|000|5*) _anomaly=1; [ -z "$_reason" ] && _reason="HTTP-Status $c_code" ;;

            esac

            if [ "$m_ok" -eq 1 ]; then

                if [ "$m_dest_reached" -ne 1 ]; then

                    _anomaly=1

                    _reason="${_reason:+$_reason; }Ziel im mtr nicht erreicht"

                fi

                if [ "$(awk -v a="$m_loss" -v b="$LOSS_WARN" 'BEGIN{print (a+0>b+0)?1:0}')" = "1" ]; then

                    _anomaly=1

                    _reason="${_reason:+$_reason; }Paketverlust ${m_loss}%"

                fi

                if [ "$(awk -v a="$m_avg" -v b="$RTT_WARN" 'BEGIN{print (a+0>b+0)?1:0}')" = "1" ]; then

                    _anomaly=1

                    _reason="${_reason:+$_reason; }Latenz ${m_avg} ms"

                fi

            elif have mtr; then

                _anomaly=1

                _reason="${_reason:+$_reason; }mtr ohne Ergebnis"

            fi

            # Rohlog nur bei Auffaelligkeit behalten, dann aber mit mehr Zyklen

            _rawname=""

            if [ "$_anomaly" -eq 1 ]; then

                _rawname="$_day/$_runid-$_target-v$_fam.txt"

                _rawpath="$RAW_DIR/$_rawname"

                {

                    echo "=== $_ts $_target IPv$_fam ==="

                    echo "Grund: $_reason"

                    echo "curl: exit=$c_exit http=$c_code ip=$c_ip dns=${c_dns}ms connect=${c_con}ms tls=${c_tls}ms ttfb=${c_ttfb}ms total=${c_total}ms"

                    echo

                    echo "--- mtr Kurzlauf ($MTR_CYCLES Zyklen) ---"

                } >"$_rawpath"

                [ -f "$_tmpraw" ] && cat "$_tmpraw" >>"$_rawpath"

                if have mtr && [ "$MTR_ANOMALY_CYCLES" -gt "$MTR_CYCLES" ]; then

                    {

                        echo

                        echo "--- mtr Nachmessung ($MTR_ANOMALY_CYCLES Zyklen) ---"

                    } >>"$_rawpath"

                    _tmpraw2="$_tmpraw.2"

                    measure_mtr "$_target" "$_fam" "$MTR_ANOMALY_CYCLES" "$_tmpraw2" || true

                    [ -f "$_tmpraw2" ] && cat "$_tmpraw2" >>"$_rawpath" && rm -f "$_tmpraw2"

                    if [ "$STOP" -eq 1 ]; then

                        echo "(Nachmessung durch Abbruchsignal beendet - unvollstaendig)" >>"$_rawpath"

                    fi

                fi

                [ "$SNAPSHOT_ON_ANOMALY" = "1" ] && snapshot "$_rawpath"

                log "ANOMALY $_target IPv$_fam: $_reason -> raw/$_rawname"

            fi

            rm -f "$_tmpraw"

            printf '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\n' \

                "$_ts" "$_epoch" "$_runid" "$_target" "$_fam" "$(csv_escape "$c_ip")" \

                "$c_ok" "$c_exit" "$c_code" \

                "$c_dns" "$c_con" "$c_tls" "$c_ttfb" "$c_total" \

                "$m_ok" "$m_loss" "$m_avg" "$m_worst" "$m_maxhoploss" "$m_hops" \

                "$m_dest_reached" "$_anomaly" "$(csv_escape "$_reason")" "$_rawname" \

                >>"$_csv" 2>/dev/null

            # Schreibfehler nicht verschlucken - eine stumm verlorene Messung

            # ist schlimmer als eine laute Fehlermeldung.

            if [ ! -w "$_csv" ]; then

                log "FEHLER CSV nicht beschreibbar: $_csv"

                printf 'netcheck: FEHLER - kann nicht nach %s schreiben.\n' "$_csv" >&9

            fi

            if [ "$VERBOSE" -eq 1 ]; then

                if [ "$_anomaly" -eq 1 ]; then

                    printf '  %-24s IPv%s  AUFFAELLIG  %s\n' "$_target" "$_fam" "$_reason"

                else

                    printf '  %-24s IPv%s  ok  http=%s ttfb=%sms loss=%s%% avg=%sms hops=%s\n' \

                        "$_target" "$_fam" "$c_code" "$c_ttfb" "${m_loss:-n/a}" "${m_avg:-n/a}" "${m_hops:-n/a}"

                fi

            fi

        done

        [ "$STOP" -eq 1 ] && break

    done

    if [ "$VERBOSE" -eq 1 ]; then

        _rows=$(( $(wc -l <"$_csv" 2>/dev/null || echo 1) - 1 ))

        printf '  -> %s Zeilen in %s\n' "$_rows" "$_csv"

    fi

    # Alte Rohlogs aufraeumen

    if [ "$RAW_RETENTION_DAYS" -gt 0 ] && [ -d "$RAW_DIR" ]; then

        find "$RAW_DIR" -type f -name '*.txt' -mtime "+$RAW_RETENTION_DAYS" -delete 2>/dev/null

        find "$RAW_DIR" -mindepth 1 -type d -empty -delete 2>/dev/null

    fi

}

# ---------------------------------------------------------------------------

# Auswertung

# ---------------------------------------------------------------------------

do_summary() {

    _month="${1:-}"

    if [ -n "$_month" ]; then

        _files="$CSV_DIR/netcheck-$_month.csv"

    else

        _files="$CSV_DIR"/netcheck-*.csv

    fi

    # shellcheck disable=SC2086

    ls $_files >/dev/null 2>&1 || die "keine CSV-Daten in $CSV_DIR gefunden"

    # shellcheck disable=SC2086

    awk -F, '

        FNR == 1 { next }

        NF < 20 { next }

        {

            ts = $1; target = $4; fam = $5;

            curl_ok = $7; total = $14;

            mtr_ok = $15; loss = $16; avg = $17;

            anomaly = $22; reason = $23;

            key = target " IPv" fam;

            if (!(key in seen)) { seen[key] = 1; order[++n] = key }

            runs[key]++;

            if (curl_ok != 1) fails[key]++;

            if (anomaly == 1) anos[key]++;

            if (curl_ok == 1 && total != "") {

                sum_total[key] += total; cnt_total[key]++;

                if (total + 0 > max_total[key] + 0) max_total[key] = total;

            }

            if (mtr_ok == 1 && avg != "") {

                sum_avg[key] += avg; cnt_avg[key]++;

                if (avg + 0 > max_avg[key] + 0) max_avg[key] = avg;

                sum_loss[key] += loss; cnt_loss[key]++;

            }

            if (anomaly == 1) {

                hour = substr(ts, 1, 13);

                hits[hour]++;

                day = substr(ts, 1, 10);

                dayhits[day]++;

                if (!(reason in rcount)) rorder[++rn] = reason;

                rcount[reason]++;

                if (first[key] == "") first[key] = ts;

                last[key] = ts;

            }

            if (window_first == "") window_first = ts;

            window_last = ts;

            total_runs++;

        }

        END {

            if (total_runs == 0) { print "Keine Datenzeilen gefunden."; exit }

            printf "Messzeitraum : %s bis %s\n", window_first, window_last;

            printf "Messungen    : %d\n\n", total_runs;

            printf "%-28s %7s %7s %8s %10s %10s %9s %9s\n", \

                "Ziel", "Laeufe", "Fehler", "Auffaell", "Ø total ms", "max total", "Ø loss %", "Ø rtt ms";

            for (i = 1; i <= n; i++) {

                k = order[i];

                at = (cnt_total[k] ? sum_total[k] / cnt_total[k] : 0);

                al = (cnt_loss[k]  ? sum_loss[k]  / cnt_loss[k]  : 0);

                ar = (cnt_avg[k]   ? sum_avg[k]   / cnt_avg[k]   : 0);

                printf "%-28s %7d %7d %8d %10.1f %10.1f %9.2f %9.1f\n", \

                    k, runs[k], fails[k]+0, anos[k]+0, at, max_total[k]+0, al, ar;

            }

            if (rn > 0) {

                printf "\nHaeufigste Ursachen\n";

                for (i = 1; i <= rn; i++)

                    printf "  %5d x  %s\n", rcount[rorder[i]], rorder[i];

                printf "\nAuffaellige Laeufe pro Tag\n";

                for (d in dayhits) daylist[++dn] = d;

                for (i = 1; i < dn; i++) for (j = i+1; j <= dn; j++)

                    if (daylist[i] > daylist[j]) { t = daylist[i]; daylist[i] = daylist[j]; daylist[j] = t }

                for (i = 1; i <= dn; i++) {

                    bar = ""; c = dayhits[daylist[i]];

                    for (b = 0; b < c && b < 60; b++) bar = bar "#";

                    printf "  %s  %4d  %s\n", daylist[i], c, bar;

                }

                printf "\nAuffaellige Laeufe pro Stunde (Tagesverteilung)\n";

                for (h in hits) { hh = substr(h, 12, 2); hourly[hh] += hits[h] }

                for (i = 0; i < 24; i++) {

                    hh = sprintf("%02d", i);

                    c = hourly[hh] + 0;

                    bar = ""; for (b = 0; b < c && b < 60; b++) bar = bar "#";

                    printf "  %s Uhr  %4d  %s\n", hh, c, bar;

                }

            } else {

                printf "\nKeine Auffaelligkeiten im Zeitraum.\n";

            }

        }' $_files

}

# ---------------------------------------------------------------------------

# Selbsttest

# ---------------------------------------------------------------------------

do_selftest() {

    echo "netcheck Selbsttest"

    echo "  System        : $(uname -s) $(uname -r)"

    echo "  Konfiguration : $([ -f "$CONF" ] && echo "$CONF" || echo "(keine, Defaults aktiv)")"

    echo "  Ziele         : $TARGETS"

    echo "  Familien      : IPv$(echo "$FAMILIES" | sed 's/ /, IPv/')"

    echo "  Datenablage   : $OUTDIR"

    echo

    _fail=0

    for _t in curl awk date find; do

        if have "$_t"; then

            echo "  ok      $_t ($(command -v "$_t"))"

        else

            echo "  FEHLT   $_t"

            _fail=1

        fi

    done

    if have mtr; then

        echo "  ok      mtr ($(command -v mtr))"

        if [ "$(id -u)" -eq 0 ]; then

            echo "  ok      laeuft als root, mtr kann Raw Sockets oeffnen"

        elif sudo -n true 2>/dev/null; then

            echo "  ok      passwortloses sudo verfuegbar, mtr wird darueber gestartet"

        else

            echo "  WARNUNG weder root noch passwortloses sudo - mtr wird scheitern."

            echo "          Entweder per root/sudo starten oder eine sudoers-Regel anlegen"

            echo "          (siehe README, Abschnitt Rechte)."

            _fail=1

        fi

    else

        echo "  FEHLT   mtr - es werden nur curl-Messungen aufgezeichnet."

        echo "          macOS: brew install mtr | Debian/Ubuntu: apt install mtr-tiny"

    fi

    echo

    for _fam in $FAMILIES; do

        for _t in $TARGETS; do

            if curl "-$_fam" -sS -I --connect-timeout 5 --max-time 10 \

                -o /dev/null "https://$_t$CURL_PATH" 2>/dev/null; then

                echo "  ok      IPv$_fam Testabruf $_t erfolgreich"

            else

                echo "  WARNUNG IPv$_fam Testabruf $_t fehlgeschlagen (genau das wuerde das Monitoring aufzeichnen)"

            fi

        done

    done

    echo

    if [ "$_fail" -eq 0 ]; then

        echo "Selbsttest ohne Blocker abgeschlossen."

    else

        echo "Selbsttest mit Problemen abgeschlossen - siehe Meldungen oben."

    fi

    return "$_fail"

}

# ---------------------------------------------------------------------------

# Signalbehandlung und Aufraeumen

# ---------------------------------------------------------------------------

# Ctrl+C bzw. SIGTERM beenden das Script nicht mitten in einer Messung, weil

# eine abgebrochene Messung als Ausfall in der CSV landen und die Auswertung

# verfaelschen wuerde. Stattdessen wird ein Stopp-Wunsch vermerkt, die

# angefangene Messung verworfen und danach sauber beendet.

# Ein zweites Signal erzwingt den sofortigen Abbruch.

on_signal() {

    SIGCOUNT=$(( SIGCOUNT + 1 ))

    STOP=1

    # Laufende Messprozesse beenden, damit der Abbruch sofort greift

    [ -n "$SLEEP_PID" ] && kill -TERM "$SLEEP_PID" 2>/dev/null

    [ -n "$CHILD_PID" ] && kill -TERM "$CHILD_PID" 2>/dev/null

    if [ "$SIGCOUNT" -ge 2 ]; then

        printf '\nnetcheck: Abbruch erzwungen.\n' >&9

        log "STOP zweites Signal - sofortiger Abbruch"

        cleanup

        exit 130

    fi

    printf '\nnetcheck: Stopp angefordert. Laufende Messung wird verworfen (nicht in die CSV geschrieben).\n' >&9

    printf 'netcheck: nochmal Ctrl+C erzwingt den sofortigen Abbruch.\n' >&9

    log "STOP Signal empfangen - laufende Messung wird verworfen"

}

cleanup() {

    [ -n "$CHILD_PID" ] && kill -TERM "$CHILD_PID" 2>/dev/null

    [ -n "$SLEEP_PID" ] && kill -TERM "$SLEEP_PID" 2>/dev/null

    # angefangene Rohlogs der abgebrochenen Messung entfernen

    rm -f "$RAW_DIR"/*/.tmp-* 2>/dev/null

    [ "$LOCK_HELD" -eq 1 ] && rm -rf "$LOCKDIR"

    return 0

}

install_traps() {

    trap 'on_signal' INT TERM

    trap 'cleanup' EXIT

}

# ---------------------------------------------------------------------------

# Sperre gegen ueberlappende Laeufe

# ---------------------------------------------------------------------------

acquire_lock() {

    if mkdir "$LOCKDIR" 2>/dev/null; then

        echo $$ >"$LOCKDIR/pid"

        LOCK_HELD=1

        install_traps

        return 0

    fi

    _pid="$(cat "$LOCKDIR/pid" 2>/dev/null)"

    if [ -n "$_pid" ] && kill -0 "$_pid" 2>/dev/null; then

        log "SKIP vorheriger Lauf (PID $_pid) laeuft noch"

        return 1

    fi

    log "WARN verwaiste Sperre von PID ${_pid:-unbekannt} entfernt"

    rm -rf "$LOCKDIR"

    mkdir "$LOCKDIR" 2>/dev/null || return 1

    echo $$ >"$LOCKDIR/pid"

    LOCK_HELD=1

    install_traps

    return 0

}

# ---------------------------------------------------------------------------

# Einstiegspunkt

# ---------------------------------------------------------------------------

mkdir -p "$CSV_DIR" "$RAW_DIR" || die "kann $OUTDIR nicht anlegen"

case "${1:-run}" in

    once)

        VERBOSE=1

        acquire_lock || exit 0

        echo "netcheck $(date '+%Y-%m-%dT%H:%M:%S%z')"

        echo "CSV:  $CSV_DIR/netcheck-$(date '+%Y-%m').csv"

        do_run

        echo "CSV: $CSV_DIR/netcheck-$(date '+%Y-%m').csv"

        ;;

    run)

        acquire_lock || exit 0

        do_run

        ;;

    daemon)

        VERBOSE=1

        acquire_lock || die "es laeuft bereits eine Instanz"

        log "START daemon, Intervall ${INTERVAL}s, Ziele: $TARGETS"

        echo "netcheck laeuft. Beenden mit Ctrl+C oder: $0 stop"

        echo "CSV:  $CSV_DIR/netcheck-$(date '+%Y-%m').csv"

        echo "Roh:  $RAW_DIR  (nur bei Auffaelligkeiten)"

        while [ "$STOP" -eq 0 ]; do

            _start="$(date '+%s')"

            do_run

            [ "$STOP" -eq 1 ] && break

            _elapsed=$(( $(date '+%s') - _start ))

            _sleep=$(( INTERVAL - _elapsed ))

            [ "$_sleep" -lt 5 ] && _sleep=5

            # Schlafen im Hintergrund, damit ein Signal sofort greift und

            # nicht bis zum Ende des Intervalls warten muss.

            sleep "$_sleep" &

            SLEEP_PID=$!

            wait "$SLEEP_PID" 2>/dev/null

            SLEEP_PID=""

        done

        log "STOP daemon beendet"

        echo "netcheck beendet."

        ;;

    stop)

        _pid="$(cat "$LOCKDIR/pid" 2>/dev/null)"

        if [ -z "$_pid" ]; then

            echo "netcheck: keine laufende Instanz gefunden (keine Sperre in $LOCKDIR)."

            exit 0

        fi

        if ! kill -0 "$_pid" 2>/dev/null; then

            echo "netcheck: verwaiste Sperre von PID $_pid entfernt."

            rm -rf "$LOCKDIR"

            exit 0

        fi

        echo "netcheck: sende Stoppsignal an PID $_pid ..."

        kill -TERM "$_pid" 2>/dev/null

        _n=0

        while [ "$_n" -lt 60 ] && kill -0 "$_pid" 2>/dev/null; do

            sleep 1

            _n=$(( _n + 1 ))

        done

        if kill -0 "$_pid" 2>/dev/null; then

            echo "netcheck: reagiert nicht, erzwinge Abbruch."

            kill -KILL "$_pid" 2>/dev/null

            sleep 1

            rm -rf "$LOCKDIR"

        else

            echo "netcheck: sauber beendet."

        fi

        ;;

    summary)

        do_summary "${2:-}"

        ;;

    selftest)

        do_selftest

        ;;

    -h|--help|help)

        sed -n '2,30p' "$0" | sed 's/^# \{0,1\}//'

        ;;

    *)

        die "unbekannter Befehl '${1}'. Bekannt: once, run, daemon, stop, summary, selftest"

        ;;

esac

[Unit]

Description=netcheck alle 5 Minuten

[Timer]

OnBootSec=2min

OnUnitActiveSec=5min

AccuracySec=10s

Persistent=true

Unit=netcheck.service

[Install]

WantedBy=timers.target