SBBS SysOp-Hack: Full-Uptime für Webinterface und ANSI-Terminal nachrüsten

Letztes Update am Mo., 21 Sep. 2026 14:50:46 +0200 von Andreas Potthoff

Warum Full-Uptime?

Wer eine Synchronet BBS unter Linux betreibt, kennt das Problem: Die standardmäßige Uptime-Anzeige ist extrem flüchtig. Sobald man ein System-Update fährt, ein neues Door-Game installiert oder den systemd-Dienst neu startet, fällt der Zeitzähler gnadenlos zurück auf Null. Für ein prestigeträchtiges Projekt wie die Helix Sector BBS will man als SysOp aber natürlich die kumulierte Lebenszeit (Gesamt-Uptime) stolz präsentieren – unbeeindruckt von Reboots und Wartungsfenstern!

In diesem knackigen SysOp-Hack zeige ich dir, wie du einen unzerstörbaren „Kilometerzähler“ baust, der im Hintergrund jede Minute mitschreibt, und wie wir diesen Wert elegant sowohl in deine ANSI-Einstiegsbildschirme als auch live in das moderne Webinterface (ecWebv4) einstanzen.

Wichtiger Versions-Hinweis

Dieser SysOp-Hack basiert exklusiv auf der aktuellen Synchronet BBS Version 3.22a (unter Linux). In dieser Version wurden die alten, nativen C-Binärdateien wie addfiles oder fileutil für den Import komplett gestrichen und das Event-Management grundlegend modernisiert. Wenn du noch ein älteres System betreibst, solltest du zuerst das Update auf die 3.22a durchführen, damit die hier gezeigten Pfade und Shell-Skripte im Scheduler fehlerfrei greifen!

Der Plan: Ein bombensicheres Linux-Hintergrundevent

Da Synchronet-eigene JavaScript-Schleifen im Event-Planer unter Linux gerne mal einfrieren, nutzen wir die pure Kraft des Betriebssystems. Wir legen eine extrem schlanke .ini-Datei als Speicher an und lassen jede Minute ein winziges Bash-Skript über den Stream-Editor sed den Zähler atomar nach oben drehen. Das ist absolut stabil, verbraucht null CPU-Leistung und kann die Datei niemals beschädigen.

Schritt 1: Die Datenbank anlegen

Zuerst erstellen wir unsere Speicherdatei im Steuerverzeichnis (ctrl/) der BBS und füttern sie mit einem Startwert (in Sekunden). Wenn deine BBS brandneu ist, nimmst du einfach eine 0. Da meine Mailbox zum Zeitpunkt des Skript-Einbaus schon ein paar Tage lief, war ich mathematisch absolut ehrlich: Ich habe das exakte Datum der Erstinstallation herangezogen, die kurzen Wartungsfenster abgezogen und bin so auf einen echten, präzisen Startwert von 350000 Sekunden (naja, so ca.) gekommen:

echo -e "[Global]\nTotalSeconds = 350000" > /sbbs/ctrl/total_uptime.ini

chown sbbs:sbbs /sbbs/ctrl/total_uptime.ini

chmod 664 /sbbs/ctrl/total_uptime.ini

Schritt 2: Das Linux-Bash-Skript erstellen

Nun schreiben wir das Skript, das den alten Wert ausliest, mathematisch 60 Sekunden dazu addiert und den Wert in der Datei austauscht.

nano /sbbs/exec/local/total_uptime.sh

Füge dort folgenden Code ein:

#!/bin/bash
INI_FILE="/sbbs/ctrl/total_uptime.ini"

# 1. Aktuelle Sekundenzahl auslesen
OLD_SEC=$(grep -oP 'TotalSeconds = \K\d+' "$INI_FILE")

# 2. Falls leer oder Fehler, auf Startwert setzen
if [ -z "$OLD_SEC" ]; then
    OLD_SEC=350000
fi

# 3. Mathematisch 60 Sekunden addieren
NEW_SEC=$((OLD_SEC + 60))

# 4. Den Wert sicher in der Datei ersetzen
sed -i "s/TotalSeconds = .*/TotalSeconds = $NEW_SEC/g" "$INI_FILE"

Speichern, schließen und das Skript mit Ausführungsrechten versehen:

chmod +x /sbbs/exec/local/total_uptime.sh

Schritt 3: Das Event in der scfg einplanen

Damit Synchronet das Skript jede Minute anwirft, tragen wir es als Timed Event ein. Achtung, kleiner Fallstrick: Man muss der BBS explizit sagen, dass es sich um ein Linux-Skript handelt, sonst versucht sie fälschlicherweise, einen 16-Bit-DOS-Emulator (DOSEMU) zu starten!

1. Starte die Konfiguration mit /sbbs/exec/scfg.
2. Navigiere zu External Programs -> Timed Events…
3. Drücke INS (Einfügen) für ein neues Event:
   • Internal Code: UPTIME
   • Command Line: bash /sbbs/exec/local/total_uptime.sh
   • Execution Frequency: 1440 Seconds (Sodass dort steht: 1440 times a day).
4. Mit ESC speichern und die BBS einmal mit sudo systemctl restart sbbs neu starten.

Hack 1: Die formatierte „Full-Uptime“ im Webinterface

Im Webinterface haben wir serverseitig alle Freiheiten. Hier wollen wir richtig klotzen: Das System soll die Sekunden vollautomatisch in Jahre, Tage, Stunden und Minuten umrechnen und als saubere, neue Zeile direkt unter der normalen Uptime anzeigen!

Das Geniale: Das Skript arbeitet dynamisch. Läuft das System erst kurz, zeigt es Stunden an. Nach Tagen schaltet es um, und wenn irgendwann das erste Betriebsjahr geknackt wird, blendet es die Minuten aus und zeigt kompakt Jahre und Tage an.

Öffne die zuständige JavaScript-Laufzeitdatei deines Web-Templates auf dem NUC:

nano /sbbs/webv4/sidebar/003-sysinfo.xjs.ssjs

Suche die Tabellenzeile der Standard-Uptime und füge direkt darunter diesen Kaskaden-Code ein:

// Fulluptime aus der INI auslesen und in Jahre/Tage/Stunden zerlegen
var uptime_file = new File(system.ctrl_dir + "total_uptime.ini");
var fulluptime_str = "0 Tage, 0 Std.";

if(uptime_file.open("r")) {
    var total_sec = uptime_file.iniGetValue("Global", "TotalSeconds", 0);
    uptime_file.close();

    // Mathematische Kaskade für Jahre, Tage, Stunden und Minuten
    var years = Math.floor(total_sec / (365 * 24 * 3600));
    total_sec %= (365 * 24 * 3600);
    
    var days = Math.floor(total_sec / (24 * 3600));
    total_sec %= (24 * 3600);
    
    var hours = Math.floor(total_sec / 3600);
    total_sec %= 3600;
    
    var minutes = Math.floor(total_sec / 60);

    // Intelligenter Zusammenbau der Anzeige
    if (years > 0) {
        fulluptime_str = years + "j " + days + "d " + hours + "h";
    } else if (days > 0) {
        fulluptime_str = days + "d " + hours + "h " + minutes + "m";
    } else {
        fulluptime_str = hours + "h " + minutes + "m";
    }
}

// Stanz die neue Zeile im Webinterface direkt unter die Standard-Uptime:
write('<tr><td class="sysinfo-label">Full-Uptime:</td>');
write('<td class="sysinfo-value">' + fulluptime_str + '</td></tr>');

Das Beste daran: Du musst die BBS nicht einmal neu starten! Speicher die Datei einfach ab. Die Web-Engine kompiliert das Skript bei jedem Browser-Refresh live im RAM. Wenn du jetzt deine BBS-Seite aktualisierst, prangt dort deine unzerstörbare, stolze Full-Uptime!

Hack 2: Die Gesamt-Uptime im ANSI-Pre-Logon-Screen

Du möchtest die gesammelten Sekunden direkt auf deinem Aushängeschild, dem allerersten ANSI-Willkommensbildschirm (answer.asc oder matrix.asc), anzeigen? Da vor dem Login aus Sicherheitsgründen keine Skripte ausgeführt werden dürfen, nutzen wir den genialen eingebauten Native-Reader von Synchronet.

Öffne deine ANSI-Datei einfach in PabloDraw und platziere an der gewünschten Stelle dieses Steuerzeichen:

  Kumulierte Gesamtzeit: @ini:total_uptime.ini:Global:TotalSeconds@ Sekunden

Synchronet liest den Wert beim Verbinden blitzschnell auf Byte-Ebene aus und stanzt die nackten Sekunden live auf den Monitor des Besuchers, noch bevor er seinen Usernamen eingetippt hat!

Wie sieht es bei euch aus? Habt ihr Fragen zum Pfad-Mapping oder wollt euren eigenen Zähler modifizieren? Schreibt es mir gerne unten in die Kommentare, ich helfe euch beim Tüfteln!