Der Raspberry Pi für ABS-B ✈ und als Webserver

Einführung

Bis jetzt hatte ich mit Linux gar keinen Kontakt. SDR betreibe ich schon länger als Hobby. Durch den Raspberry Pi durfte ich sehr viel Erfahrung mit den Betriebssystem Linux im Zusammenhang mit SDR sammeln. Irgendwann habe ich zum testen des Webserver eine Internetseite gebraucht. Die Standart Seite fand ich zu langweilig. Was lag also näher, als die Sammlung der Erfahrungen zu den Themen Raspberry, Linux, Webserver und ADS-B herzunehmen, optisch aufzubereiten und hier anzubieten? Seit dem arbeite ich an dieser Seite und gehe davon aus, dass diese nie komplett sein wird. Vielleicht hilft dieser Arbeitsstand den einen oder anderen ja weiter. Für mich ist es auf jeden Fall ein Erfahrungsschatz den ich gerne teile.

Der Raspberry Pi, das Zubehör und das Einrichten

Ich benutze folgende Hardware:

Den Raspberry umbenennen

Dafür muss der Inhalt der folgenden beiden Dateien angepasst werden. Den "alten" Namen raspberrypi ersetzen durch den neuen Namen.

sudo nano /etc/hostname
sudo nano /etc/hosts
sudo reboot

WLAN

Derzeit verwende ich kein WLAN, somit hier auch nichts neues.

Konfigurieren

Beispiel anhand des EDIMAX EW-7811UN Wireless USB Adapter

.
.
.
.
.
.
.

Automatisch wieder verbinden

Um das WLAN nach einen Verbindungsabbruch automatisch neu zu verbinden, folgendes Script anlegen.

/usr/local/bin/wifi_restarter.sh
#!/bin/bash

# The IP for the server you wish to ping (192.168.0.1 is my fritz.box)
SERVER=192.168.0.1

# Only send two pings, sending output to /dev/null
ping -c2 ${SERVER} > /dev/null

# If the return code from ping ($?) is not 0 (meaning there was an error)
if [ $? != 0 ]
then
		# Restart the wireless interface
		ifdown --force wlan0
		ifup wlan0
fi

Das Script muss regelmäßig ausgeführt werden. In diesen Beispiel alle 5 Minuten mit cron. Um die reglmäßige Ausführung zu planen mit

sudo nano /etc/crontab

die Datei öffnen und die Zeile

*/5 *   * * *   root    /usr/local/bin/wifi_rebooter.sh

einfügen.

Testen

Das WLAN mit wavecon testen:

sudo apt-get install wavemon
wavemon

Firmware Version prüfen und erneuern

Die installierte Version anzeigen lassen.

uname -a

Die Software für das Firmware Update installieren und die Rechte vergeben.

sudo wget https://raw.github.com/Hexxeh/rpi-update/master/rpi-update -O /usr/bin/rpi-update
sudo chmod +x /usr/bin/rpi-update

Und schon kann das Firmware Update gestartet werden mit

sudo rpi-update

Man kann die Firmware beliebig hochrüsten oder rückrüsten. Wenn man z.B. die Version 3.10.25+ aufspielen will, ist das wie folgt zu lösen.

sudo rpi-update 2ef601a50b68eebeeb4dc3c6c525855961891be6

Die lange Zeichenfolge stellt den Git hash für eine Firmware Version dar. Die Zuordnung Git hash zu Firmware Version kann man hier finden.

Arbeiten mit Diensten (service)

Es gibt verschiedene Möglichkeiten einen Service beim Systemstart auszuführen. Es gibt den Weg Shell- Skrits im Ordner /etc/init.d/ zu benutzen oder den Weg über die Dateien im Ordner /.../systemd/... Die zweite Möglichkeit ist scheinbar die neuere Lösung, welche auch von nginx genutzt wird. Genaueres dazu habe ich im Artikel zu nginx hinterlegt, da es auch dabei Stolpersteine gab. Neu erstellte Dateien müssen erstens die notwendigen Rechte bekommen, damit diese ausführbar werden und zweitens zum automatischen start ertüchtigt werden. Das kann mit dem Befehlen

cd /etc/init.d/
sudo chmod 755 <Service Name>
sudo update-rc.d <Service Name> defaults

gemacht werden. Für die Start- Konfiguration kann man auch ein Programm installien. Ich nutze rcconf, damit kann man nicht nur den automatischen Start ein- und ausschalten, sondern bekommt auch eine Übersicht, welche Services es gibt und welche davon automatisch gestartet werden oder nicht.

sudo apt-get install rcconf
sudo rcconf

Einen Service kann man verschiedene parameter übergeben. Diese kann man herausfinden, wenn man den Service ohne parameter ausführen will.

sudo service <Service Name>

SD- Karte Lebensdauer

Bekanntlich hängt die Lebensdauer von der Anzahl der Schreibvorgänge ab. Aus diesem Grund versuche auch ich so einiges die Schreibvorgänge zu reduzieren.

Bei Lesezugriffen den Zeitstempel belassen

Das Root Filesystem wird mit den Optionen “defaults,noatime” gemounted. Durch noadirtime wird verhindert, dass bei einem Lesezugriff auf einen Ordner bereits das Attribut “Accesstime” verändert und zugleich wieder auf die SD Karte geschrieben wird. Ich bin nicht sicher, ob nodiratime in noatime enthalten ist. So habe ich nodiratime eingefügt.

sudo nano /etc/fstab
/dev/mmcblk0p2	/	ext4	defaults,noatime,nodiratime	0	1

Ordner ins RAM auslagern

Vorschläge aus den Web:

tmpfs    /tmp			tmpfs	defaults,noatime,nosuid,size=100m			00
tmpfs    /var/tmp		tmpfs	defaults,noatime,nosuid,size=30m			00
tmpfs    /var/log		tmpfs	defaults,noatime,nosuid,mode=0755,size=100m		00
tmpfs    /var/run    		tmpfs	defaults,noatime,nosuid,mode=0755,size=2m		00
tmpfs    /var/spool/mqueue	tmpfs	defaults,noatime,nosuid,mode=0700,gid=12,size=30m	00

Editieren der Einträge:

sudo nano /etc/fstab

Tatsächlich habe ich erst einmal nur folgendes umgesetzt:

none	/tmp		tmpfs   size=100M,noatime	0	0
none	/var/log	tmpfs	size=100M,noatime	0	0

Nach einen Neustart des Raspberry Pi kann man mit den folgenden Befehl das Ergebnis sehen.

df -h

Schon das auslagern der beiden genannten Ordner hat zu Problemen geführt.

  • Nginx: Gelöst - Die Beschreibung folgt im dazugehörigen Artikel.
  • Plane Finder: Gelöst - Die Beschreibung folgt im dazugehörigen Artikel.
  • MySQL/PHPAdmin: Scheinbar gibt es hier auch Probleme, was ich aber nicht weiter untersuche, da ich PHPAdmin nicht mehr nutze.

Automatisches TRIM

Dazu wird die Datei fstrim im Ordner /etc/cron.weekly erstellt, die wiederum das Script fstrim-all ausführt. Dieses durchläuft alle aktiven Dateisysteme auf der Suche nach einer SD- Karte / SSD. Stellt es fest, dass sich ein oder mehrere Dateisysteme auf einer SD- Karte/ SSD befinden, wird fstrim automatisch gestartet.

sudo nano /etc/cron.weekly/fstrim
#!/bin/sh
# trim all mounted file systems which support it
# /sbin/fstrim --all || true
LOG=/var/log/cron_weekly_trim.log
echo "*** $(date -R) ***" >> $LOG
/sbin/fstrim -v / >> $LOG
/sbin/fstrim -v /home >> $LOG

watchdog

Zuerst installieren

sudo apt-get install watchdog

Danach die Konfigurations- Datei öffnen

nano /etc/watchdog.conf

und die folgenden Zeilen einfügen

watchdog-device = /dev/watchdog
watchdog-timeout = 10
interval = 2
max-load-1 = 24
temperature-device = /sys/class/thermal/thermal_zone0/temp
max-temperature = 85

Jetzt muss noch das Kernel Modul bei jeden Neustart verfügbar gemacht werden

sudo echo "bcm2835_wdt" >> /etc/modules

Den service neu starten

sudo service watchdog restart

Nun sollte alles einwandfrei funktionieren. Im beschriebenen Fall wird der Raspberry Pi ausgeschaltet, wenn die CPU Temeratur 85°C überschreitet. Die weiteren Funktionen kann man z.B. mit der folgenden fork-bomb testen

:(){ :|:& };:

oder man lässt das System mit einer null pointer refernz abstürzen

echo c > /proc/sysrq-trigger

Sollte man den automatischen start des watchdog einmal mittels rcconf deaktivieren, kann man diesen eventuell nicht einfach durch rcconf wieder aktivieren. Es muss der folgende Befehl ausgeführt werden:

sudo systemctl enable watchdog

Falls dies fehlerhaft beendet wird, muss ein Anpassung vorgenommen werden.

sudo nano /lib/systemd/system/watchdog.service
[Install]
WantedBy=multi-user.target

Software aus Quellcode erstellen

So manche Software muss man sich selbst aus den Quellcode erstellen, damit man diese installieren kann.

GitHub

Einrichten

Für GitHub werden die folgenden Pakete benötigt

sudo apt-get install git-core
sudo apt-get install git
sudo apt-get install cmake
sudo apt-get install build-essential

Ich klone alle Standard Git Repositories in den Ordner /home/pi/src, welchen man so erstellen kann

mkdir -p /home/pi/src

Nützliche Befehle

Status anzeigen

git status

Lokalen Stand mit Repo aktuallisieren

git pull

Das Thema Sicherheit

iptables

Beim Raspberry sind die iptables grundsätzlich nicht persistent. Es gibt die Möglichkeit beim Systemstart ein Shell- Skript auszuführen, welches die Einträge immer wieder neu erstellt. Des weiteren kann man spezielle Software installieren, wie z.B iptables-persistent, welche im Prinzip nichts anderes macht.

Nginx installieren und konfigurieren

Erst einmal installieren.

sudo apt-get install nginx

Nach jeder Änderung in einer Kofigurationsdatei, muss der Service nginx mit

sudo service nginx restart

neu gestartet werden, damit die Änderungen aktiviert werden!

Die Konfiguartion kann man vorher mit dem folgenden Befehl prüfen.

sudo service nginx configtest

Hinweise:
Da ich /var/log im RAM halte, gibt es nach den Neustart des Raspberry ein Problem. Nginx versucht im Ordner /var/log/nginx seine Log- Dateien anzulegen. Wenn der Ordner nicht vorhanden ist, wird der Service nginx nicht gestartet. Obwohl man das Logging in der Konfiguration deaktivieren kann, will nginx ein error.log beim starten anlegen. Scheinbar befindet sich dieses Verhalten hart kodiert im Programm hinterlegt. Bei der Installation von nginx werden die Dateien /etc/int.d/nginx und /lib/systemd/system/nginx.service angelegt. Wie es aussieht wird durch

sudo service nginx <parameter>

die Datei /lib/systemd/system/nginx.service getriggert. Den Grund dafür kenne ich noch nicht. Der Eintrag ExecStartPre=mkdir -p /var/log/pfclient ist in dieser Datei nicht Zielführend. Nach langer Suche in Foren, habe ich das Problem durch tmpfiles.d gelöst. Eine neue Datei anlegen mit

sudo nano /etc/tmpfiles.d/nginx.conf

und den Folgenden Inhalt einfügen.

d /var/log/nginx/ 755 www-data adm

Nach einen weiteren Neustart des Raspberry hat alles fehlerfrei funktioniert.

Kostenloses Zertifikat (SSL)

Let's Encrypt

Ein Weg um ein gültiges, kostenloses Zertifikat zu erhalten, führt über die Seite SSL For Free.

Man kann sich auch das Git Repository auf seinen Raspberry holen und das Zertifikat erstellen lassen. Des weiteren kann mittels Cronjob alle 90 Tage ein das erstellte Zertifikat erneuern lassen.
Dazu in den Ordner der source wechseln

cd /home/pi/src

und die Quellen klonen

git clone https://github.com/letsencrypt/letsencrypt

Für mich habe ich eine ini mit den Parametern erstellt.

sudo nano /var/www/html/<eigene Internet- Adresse>.letsencrypt.ini
domains = <eigene Internet- Adresse>, www.<eigene Internet- Adresse>, <eventuell eigene Intranet- Adresse>
rsa-key-size = 4096
#server = https://acme-v01.api.letsencrypt.org/directory
text = True
authenticator = webroot
webroot-path = /var/www/html/
#agree-dev-preview = True
agree-tos = True
email = webmaster@<eigene Internet- Adresse>

Das Zertifikat kann nun erstellt werden.

cd letsencrypt
./letsencrypt-auto certonly --config /var/www/html/<eigene Internet- Adresse>.letsencrypt.ini --redirect

Nach Abschluß des Vorgangs sind im Ordner /etc/letsencrypt/live/<eigene Internet- Adresse>/ die folgenden Dateien enthalten:

Nun muss noch die Konfiguration von nginx angepasst werden.

sudo nano /etc/nginx/sites-enabled/default
ssl_certificate	/etc/letsencrypt/live/<eigene Internet- Adresse>/fullchain.pem
ssl_certificate_key	/etc/letsencrypt/live/<eigene Internet- Adresse>/privkey.pem
ssl_trusted_certificate	/etc/letsencrypt/live/<eigene Internet- Adresse>/chain.pem

Erneuert werden kann das Zertifikat auf den folgenden Weg.

/home/pi/src/letsencrypt/letsencrypt-auto certonly --config /var/www/html/<eigene Internet- Adresse>.letsencrypt.ini --redirect

Das kann auch automatisiert stattfinden. Dazu habe ich die Datei letsencrypt im Ordner /etc/cron.monthly erstellt.

sudo nano /etc/cron.monthly/letsencrypt

und folgenden Inhalt eingefügt

#!/bin/sh
# renew letsencrypt ssl certificates
LOG=/var/log/cron_monthly_letsencrypt.log
echo "*** $(date -R) ***" >> $LOG
/home/pi/src/letsencrypt/letsencrypt-auto certonly --config /var/www/html/<eigene Internet- Adresse>.letsencrypt.ini --redirect >> $LOG

Die Datei noch ausführbar machen

sudo chmod 755 /etc/cron.monthly/letsencrypt

HTTP Strict Transport Security (SSL)

HTTP Strict Transport Security (RFC 6797) ist eine Antwort des Servers (HTTP Header) an den Browser, wenn dieser eine verschlüsselte Verbindung herstellt. Der Server sagt dem Browser damit, dass der Browser in der nächsten Zeit (Länge wird in der Antwort angegeben, und bei jedem neuen Aufruf wieder auf das Maximum gesetzt), nur noch verschlüsselt mit dem Server kommunizieren soll. Jede unverschlüsselte Verbindung und jede Verbindung mit einem selbst unterschriebenen Zertifikat wird abgebrochen. Dies ist ein Schutz gegen MITM Angriffe, da diese jetzt ein gültiges Zertifikat brauchen um dem Benutzer eine falsche Seite unterzuschieben. Zusäzlich werden alle http:// Links die auf die eigene Domain zeigen in https:// Links umgewandelt, noch bevor der Server kontaktiert wird. Das Maximalalter max-age=31536000 wird in Sekunden angegeben und entpricht hier einem Jahr. Außerdem sollte man mit dem Parameter includeSubDomains angeben, dass alle Subdomains ebenfalls nur mit HTTPS aufzurufen sind.

Wie am Anfang erwähnt ist ein Besucher beim ersten Aufrufen der Website nicht durch HSTS geschützt, da er den Header noch nie empfangen hat. Um dieses Problem zu beheben kann man sich bei Google in eine Liste eintragen lassen, in der Websiten aufgeführt werden für die der HSTS Header schon bei Installation des Browsers enthalten ist. Die HSTS Preload Liste wird im Moment von Chrome, Firefox und Internet Explorer genutzt. Unter https://hstspreload.appspot.com kann man sich in die Liste eintragen lassen wenn man alle dort aufgeführten Vorraussetzungen erfüllt, wie zum Beispiel den preload Parameter.

add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload";

ACHTUNG: Wenn man seine Seite wieder unverschlüsselt anbieten möchte, sollte man einige Zeit vorher das Maximalalter auf eine Sekunde stellen. Ansonsten können Nutzer die diesen Header im letzten Jahr erhalten haben, erst wieder nach Ablauf dieser Zeit, auf die Website zugreifen. Möchte man seine Website aus der preload Liste löschen, muss man den HSTS Header entfernen und Adam Langley eine Email schreiben.

OCSP Stapling aktivieren (SSL)

StartSSL

Zuerst muss man sich eine Datei erzeugen, die das Root Zertifikat und alle Zwischenzertifikate der CA beinhaltet. Wenn man ein SSL Zertifikat von StartCom nutzt, muss man die richtigen Links heraussuchen.

StartCom SSL Zertifikate

Hat man die Adressen gefunden, kann man unter Verwendung der Links den Zertifikatsstapel erzeugen.

wget -O - https://www.startssl.com/certs/ca.crt https://www.startssl.com/certs/sca.server1.crt | sudo tee -a /etc/nginx/ssl/ca-bundle.crt> /dev/null

Im Anschluss noch die Konfiguration von nginx öffnen

sudo nano /etc/nginx/sites-available/default

und folgenden Eintrag hinzufügen

ssl_trusted_certificate /etc/nginx/ssl/ca-bundle.crt;

Let's Encrypt

Die Konfiguration von nginx öffnen

sudo nano /etc/nginx/sites-available/default

und folgenden Eintrag hinzufügen

ssl_trusted_certificate /etc/letsencrypt/live/<eigene Internet- Adresse>/chain.pem;

Fertig stellen

Falls die Konfiguration von nginx nicht noch geöffnet ist, dann noch einmal öffnen

sudo nano /etc/nginx/sites-available/default

diese erweitert um

ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.8.8 valid=300s;
resolver_timeout 10s;

und OCSP Stapling sollte aktiv sein.

Testen - zwischendurch und zum Schluss (SSL)

mit den SSL Server Test von SSL Labs:

SSL Test Result

Die Kriterien für die Bewertung findet man im SSL Server Rating Guid.

Overall Rating:
Wenn da kein A steht (besser noch A+), kann man seine Konfiguration vergessen.
Certificate:
Wenn mit dem Zertifikat alles in Ordnung ist, bekommt man hier 100%.
Protocol Support:
Die 95% ergeben sich aus dem Mittelwert von: 90% für TLSv1 Unterstützung, 95% für TLSv1.1 Unterstützung, 100% für TLSv1.2 Unterstützung.
Key Exchange:
Der Wert ergibt sich aus der kürzesten, benutzten Schlüssellänge. 90% gibt es ab 2048 bit, 100% gibt es ab 4096 bit.
Cipher Strength:
Ergibt sich alleine aus der Schlüssellänge von AES. Die 90% sind wieder ein Mittelwert aus 80% (128 bit AES) und 100% (256 bit AES).

Auf mobile Browser prüfen

Wenn man eine Seiten auf eine mobile Seite umleiten will, muss man erst einmal prüfen, ob die Anfrage von einen mobilen Browser kommt. Diese Prüfung muss in die Konfiguration aufgenommen werden.

sudo nano /etc/nginx/sites-available/default
###### beginn mobile request #########
#
set $mobile_request false;
set $mobile_request false;
if ($http_user_agent ~* '(Mobile|WebOS)') {
	set $mobile_request true;
}
#
###### ende mobile request #########

Gzip einschalten

zuerst aktivieren.

sudo nano /etc/nginx/nginx.conf
##
# Gzip Settings
##

gzip on;
gzip_disable "msie6";

gzip_vary on;
gzip_proxied any;
gzip_comp_level 6;
gzip_buffers 16 8k;
gzip_http_version 1.1;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

Danach die html/css/js/etc Dateien packen. Das kann mit folgenden script geschehen:

sudo nano /var/www/gzipfornginx.sh
#!/bin/bash

LOCATION="/var/www/html"
FILES="htm|css|html|js|jpg|png|ttf|eot|svg|woff|woff2"

process() {

DEBUG=1
SLEEP_DELAY=0.1

        FILE="$1"

        if [ -f "$FILE".gz ]
        then
                FILE_ORIG=$(stat -c %Y "$FILE")
                FILE_GZIP=$(stat -c %Y "$FILE".gz)
                if [ $FILE_ORIG -gt $FILE_GZIP ]
                then
                        rm "$FILE".gz
                        gzip -k -9 "$FILE"
                        if [ "$DEBUG" == 1 ]
                        then
                                echo "Deleted old .gz and created new one at: $FILE.gz"
                                sleep $SLEEP_DELAY
                        fi
                else
                        if [ "$DEBUG" == 1 ]
                        then
                                echo "Skipping - Already up to date: $FILE.gz"
                        fi
                fi
        else
                gzip -k -9 "$FILE"
                if [ "$DEBUG" == 1 ]
                then
                        echo "Created new: $FILE.gz"
                        sleep $SLEEP_DELAY
                fi
        fi
}
export -f process
find $LOCATION -type f -regextype posix-extended -regex '.*\.('$FILES')' -exec /bin/bash -c 'process "{}"' \;

Nur noch speichern und ausführen.

Das ganze mit Gzip Compression Test oder Check GZIP compression getestet:

Gzip Test Result

Auf die eigene Internetseite über eine Domain zugreifen

Luxus wäre es, den cname der Domain ändern zu dürfen, damit man den Wert auf eine Dynamische DNS einstellen kann. Hat man Sub- Domains in seinen Paket ist das meist möglich. Wenn man diese Möglichkeit aber nicht hat, braucht man als Alternative eine feste öffentliche IP- Adresse und eine Domain bei einen Anbieter, der es zulässt den A-Record zu ändern. Wenn nginx richtig konfiguriert ist und läuft, gibt nur noch zwei Dinge zu erledigen:

A-Record der Domain einrichten

Man muss sich bei seinen Domain- Hoster einloggen und den A-record der Domain auf die eigene öffentliche IP- Adresse einstellen.

Den Router einrichten

Bei mir ist es eine Fritzbox. Bei dieser kann man die Portfreigaben leicht einrichten. In der Benutzeroberfläche auf "Internet" klicken. Im Menü "Internet" auf "Freigaben" klicken und rechts die Registerkarte "Portfreigaben" auswählen. Jetzt auf "Neue Portfreigabe" klicken. Wenn man Port 80 von aussen auf Port 80 des Raspberry weiterleiten will, kann man direkt HTTPS- Server wählen und noch den Raspberry als Netzwerkgerät auswählen. Wenn man Port 443 von aussen auf Port 443 des Raspberry weiterleiten will, kann man direkt HTTPS- Server wählen und noch den Raspberry als Netzwerkgerät auswählen. Bei komplexeren Konfigurationen einfach einen Blick in eine Suchmaschine werfen: portfreigaben fritzbox.

Remote Zugriff herstellen

mit Xrdp

Xrdp ist ein Server für das Remote Desktop Protocol (RDP) und kann wie folgt installiert werden:

sudo apt-get install xrdp

Der Service xrdp startet bein Systemstart automatisch.

oder VNC

......

Shell in a box

Es gibt zwei Möglichkeiten, einmal über

sudo apt-get install shellinabox

Am 07.02.2016 gab es darüber aber nur die Version 2.10, welche bereits im July 2010 erstellt wurde. Wenn man eine neure Version haben möchte oder sogar braucht, darf sich diese selbst erstellen.

apt-get install git libssl-dev libpam0g-dev zlib1g-dev dh-autoreconf
cd /home/pi/src
git clone https://github.com/shellinabox/shellinabox.git && cd shellinabox
autoreconf -i
./configure && make
dpkg-buildpackage -b

Jetzt kann man die neu gebaute Version installieren.

sudo dpkg -i ../shellinabox_<ver>_armhf.deb

RPi-Monitor

Die Installation erfolgt in mehreren Schritten:

sudo apt-get install dpkg-dev librrds-perl libhttp-daemon-perl libjson-perl libipc-sharelite-perl libfile-which-perl
sudo apt-get install apt-transport-https ca-certificates
cd /home/pi/Downloads
sudo wget http://goo.gl/vewCLL -O /etc/apt/sources.list.d/rpimonitor.list
sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 2C0D3C0F
sudo apt-get update && sudo apt-get install rpimonitor
sudo /usr/share/rpimonitor/scripts/updatePackagesStatus.pl

Danach ist das Webinterface bereits über 127.0.0.1:8888 zu sehen.

Hinweis:
Ob der RPi- Montor Daten und wenn ja, wie viele, auf die SD- Karte schreibt, konnte ich noch nicht herausfinden. Doch die Daten für die Ansicht Statistics müssen meiner Meinung nach irgendwo hinterlegt werden. Nach einen Neustart sind die Informationen nicht verloren, somit kann sich der Speicherort nicht in einen der RAM- Ordner befinden...

Das Webinterface des RPi- Monitor kann man im Internet über einen nginx reverse_proxy bereitstellen. Dafür die Konfiguration von nginx öffnen,

sudo nano /etc/nginx/sites-available/default

folgende Zeilen hinzufügen

###### beginn RPI- Monitor #########
#
rewrite ^/rpimonitor/$ /rpimonitor/status.html permanent;
rewrite ^/rpimonitor$ /rpimonitor/status.html permanent;
#
location /rpimonitor {
	rewrite /rpimonitor/(.*) /$1 break;
	proxy_pass http://127.0.0.1:8888;
	proxy_redirect off;
	proxy_set_header Host $host;
	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
#
###### ende RPI- Monitor #########

und speichern. Nach einen neustart des Service nginx

sudo service nginx restart

ist das Webinterface über die Adresse <domain>/rpimonitor im Internet erreichbar.

Abschliessend habe ich den RPi-Monitor Port 8888 noch abgesichert, damit man nur noch von localhost (127.0.0.1) darauf zugreifen kann. Dazu gibt es zwei Möglichkeiten, welche ich noch gennauer prüfen muss. Derzeit nutze ich den ersten Eintrag.

iptables -A INPUT -p tcp -s localhost --dport 8888 -j ACCEPT
iptables -A INPUT -p tcp --dport 8888 -j DROP
iptables -A INPUT -i lo -p tcp --dport $APP_PORT -j ACCEPT
iptables -A INPUT -p tcp --dport $APP_PORT -j DROP

webmin

Erst einmal zur source List hinzufügen. Dazu die Datei

sudo nano /etc/apt/sources.list

öffnen, die folgenden beiden Zeilen einfügen

deb http://download.webmin.com/download/repository sarge contrib

und den Webmin GPG-Schlüssel holen und hinzufügen.

sudo su
cd /root
wget http://www.webmin.com/jcameron-key.asc
apt-key add jcameron-key.asc

Jetzt webmin herunterladen und installieren.

sudo apt-get update
sudo apt-get install webmin

Der webmin Server kann jetzt durch Eingabe der IP Addresse und den Port 10000 über den Browser erreicht werden.

Das Webinterface des RPi- Monitor kann man im Internet über einen nginx reverse_proxy bereitstellen. Dafür die Konfiguration von nginx öffnen,

sudo nano /etc/nginx/sites-available/default

folgende Zeilen hinzufügen

###### beginn webmin #########
#
location /webmin/ {
    proxy_pass https://127.0.0.1:10000/;
    proxy_redirect https://$host:10000/ /webmin/;
    proxy_set_header Host $host;
}
#
###### ende webmin #########

und speichern.

Nun noch webmin für reverse proxy ertüchtigen. Die Konfiguration

sudo nano /etc/webmin/config

öffnen und die folgenden beiden Zeilen einfügen.

webprefix=/webmin
webprefixnoredir=1

Nach einen neustart des Service nginx und webmin

sudo service nginx restart
sudo service webmin restart

ist das Webinterface über die Adresse <domain>/webmin im Internet erreichbar.

Datei Explorer Midnight Commander

Unter DOS und Windows 3.11 war ich ein begeisterter Nutzer des Norton Commander. Dieser wurde später durch den Total Commander erstetzt. Nun brauche ich auch auf den Raspberry etwas ähnliches. Wie es aussieht ist der Midnight Commander (MC) ein Klon des Norton Commander. Der MC kann Dateien kopieren, verschieben, umbenennen und löschen. Weiterhin kann man mit dem MC auf Archive und Netzwerkpfade, wie zum Beispiel FTP und Samba zugreifen. Mit

sudo apt-get install mc -y

kann der MC installiert werden. Nach erfolgreicher Installation kann man den Midnight Commander über den Befehl

mc

starten. Den MC kann man auch über Shell in a box nutzen!

RTL-SDR Treiber installieren und einrichten

RTL-SDR Wiki | Versions- Übersicht

Diesen muss man selbst bauen. Das wird wie folgt erledigt:

sudo apt-get install libusb-1.0-0-dev
cd /home/pi/src
git  clone  git://git.osmocom.org/rtl-sdr.git
cd  rtl-sdr
mkdir  build
cd  build
cmake  ../ -DINSTALL_UDEV_RULES=ON
make
sudo  make  install
sudo  ldconfig
cd ~
sudo  cp  ./rtl-sdr/rtl-sdr.rules  /etc/udev/rules.d/

Die benutzten USB- Sticks noch in der rtl-sdr-blacklist.conf bekannt machen:

sudo nano /etc/modprobe.d/rtl-sdr-blacklist.conf
blacklist rtl2832
blacklist r820t
blacklist rtl2830
blacklist dvb_usb_rtl28xxu
blacklist E4000
blacklist RTL2838UHIDIR

Danach neu starten, damit alles ordentlich funktioniert:

sudo reboot

Mit angeschlossenen USB- Stick kann man die installation testen:

rtl_test

War der Test erfolgreich, ist es bereits möglich an ADS-B Daten zu kommen:

rtl_adsb | netcat -g 42 -lp 10003

ADS-B Daten dekodieren, anzeigen und teilen

Nun beschreibe ich wie man die Daten dekodieren, anzeigen und mit Flightradar 24, Plane Finder, FlightAware und ADSB Exchange teilen kann.

Da ich auch den watchdog des Raspberry nutze, kann es sein, das dieser ab und zu neu gestartet wird. Aus diesem Grund nutze ich für alle ABS-B Sachen ein Autostart Skript. Die Feeder bringen schon ein Skript dafür mit. Für modesmixer2 und Virtual Radar Server habe ich ein eigenes geschrieben und hier hinterlegt.

dump1090-mutability

installieren (mutability-repo_0.1.4_armhf.deb durch die aktuelle Versionsnummer ersetzen. Die aktuelle Versionsnummer kann man hier finden.)

cd /home/pi/Downloads
wget https://github.com/mutability/mutability-repo/releases/download/v0.1.0/mutability-repo_0.1.4_armhf.deb
sudo dpkg -i mutability-repo_*_armhf.deb
sudo apt-get update && sudo apt-get install dump1090-mutability

und konfigurieren.

sudo dpkg-reconfigure dump1090-mutability

Nach einen Neustart des Service dump1090-mutability sollte die Software betriebsbereit sein.

sudo service dump1090-mutability restart

Das Webinterface ist nun über 127.0.0.1:<Port> erreichbar und sollte so ähnlich aussehen.

dump1090-mutability Webinterface

Das Webinterface von dump1090-mutability kann man im Internet über einen nginx reverse_proxy bereitstellen. Dafür die Konfiguration von nginx öffnen,

sudo nano /etc/nginx/sites-available/default

folgende Zeilen hinzufügen

###### beginn dump1090 #########
#
rewrite ^/dump1090/$ /dump1090/gmap.html permanent;
rewrite ^/dump1090$ /dump1090/gmap.html permanent;
#
location /dump1090 {
	rewrite /dump1090/(.*) /$1 break;
	proxy_pass http://127.0.0.1:<Port>;
	proxy_redirect off;
	proxy_set_header Host $host;
	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
#
### replace dump1090 internal web server
#location /dump1090/ {
# 	alias /usr/share/dump1090-mutability/html/;
#}
#location /dump1090/data/ {
#	alias /run/dump1090-mutability/;
#}
#location /dump1090/db/ {
#	alias /var/cache/dump1090-mutability/db/;
#}
### replace dump1090 internal web server
#
###### ende dump1090 #########

und speichern. Nach einen neustart des Service nginx

sudo service nginx restart

ist das Webinterface über die Adresse <domain>/dump1090 im Internet erreichbar.

Hinweise:
Die Konfiguration von dump1090-mutability wird in der Datei /etc/default/dump1090-mutability gespeichert. Die Einträge daraus werden in der Datei /etc/init.d/dump1090-mutability ausgelesen und umgewandelt in die Parameter, welche an dump1090-mutability übergeben werden können. Ein Übersicht über die möglichen Parameter kann man über die Hilfe erhalten.

dump1090-mutability --help

Im Header der Ausgabe findet man auch die aktuelle Versionsnummer.

modesmixer2

Das Programm muss manuell über die Downloadseite Anbieter geladen werden. Nach den herunterladen die *.tgz entpacken. Die so gewonnene Datei modesmixer2 nach /usr/bin kopieren.
Die Konfiguration und der automatische Start erfolgen bei mir durch ein selbst erstelltes Service Script. Dieses mit

sudo nano /etc/init.d/modesmixer2

erstellen und den folgenden Ihnalt einfügen. Dabei die Einträge DAEMON_ARGS= mit eigenen Werten anpassen

#! /bin/sh
### BEGIN INIT INFO
# Provides:          modesmixer2
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: web page for ADSB
# Description:       my own ADS-B data with modesmixer2
#                    inServer port 30006
### END INIT INFO

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="mixer for ADSB"
NAME=modesmixer2
DAEMON=/usr/bin/$NAME
DAEMON_ARGS="--inConnect 127.0.0.1:30003 --inConnect 127.0.0.1:30005 --inServer 30006 --location <Receiver Latitude:Longitude> --metric --web <Port> --log-noconsole --outServer beast:30007"
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
# and status_of_proc is working.
. /lib/lsb/init-functions

#
# Function that starts the daemon/service
#
do_start()
{
        # Return
        #   0 if daemon has been started
        #   1 if daemon was already running
        #   2 if daemon could not be started
        start-stop-daemon --start --background --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
                || return 1
        start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --exec $DAEMON -- $DAEMON_ARGS \
                || return 2
        # Add code here, if necessary, that waits for the process to be ready
        # to handle requests from services started subsequently which depend
        # on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
        # Return
        #   0 if daemon has been stopped
        #   1 if daemon was already stopped
        #   2 if daemon could not be stopped
        #   other if a failure occurred
        start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
        RETVAL="$?"
        [ "$RETVAL" = 2 ] && return 2
        # Wait for children to finish too if this is a daemon that forks
        # and if the daemon is only ever run from this initscript.
        # If the above conditions are not satisfied then add some other code
        # that waits for the process to drop all resources that could be
        # needed by services started subsequently.  A last resort is to
        # sleep for some time.
        start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
        [ "$?" = 2 ] && return 2
        # Many daemons don't delete their pidfiles when they exit.
        rm -f $PIDFILE
        return "$RETVAL"
}

#
# main
#
case "$1" in
  start)
        [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
        do_start
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  stop)
        [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
        do_stop
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  #status)
        #status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
        #;;
  #reload|force-reload)
        #
        # If do_reload() is not implemented then leave this commented out
        # and leave 'force-reload' as an alias for 'restart'.
        #
        #log_daemon_msg "Reloading $DESC" "$NAME"
        #do_reload
        #log_end_msg $?
        #;;
  restart|force-reload)
        #
        # If the "reload" option is implemented then remove the
        # 'force-reload' alias
        #
        log_daemon_msg "Restarting $DESC" "$NAME"
        do_stop
        case "$?" in
          0|1)
                do_start
                case "$?" in
                        0) log_end_msg 0 ;;
                        1) log_end_msg 1 ;; # Old process is still running
                        *) log_end_msg 1 ;; # Failed to start
                esac
                ;;
          *)
                # Failed to stop
                log_end_msg 1
                ;;
        esac
        ;;
  *)
        #echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
        echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
        exit 3
        ;;
esac
:

Die möglichen Parameter für DAEMON_ARGS= kann man über die Hilfe erhalten.

modesmixer2 --help

Den Service modesmixer2 nun starten mit

sudo service modesmixer2 restart

Jetzt kann man das Webinterface über 127.0.0.1:<Port> erreichen.

Daten mit Flightradar 24 teilen

Feeder installieren

sudo bash -c "$(wget -O - http://repo.feed.flightradar24.com/install_fr24_rpi.sh)"
sudo apt-get install fr24feed

und konfigurieren.

fr24feed --signup
Step 1.1 - Enter your email address (username@domain.tld)
$:<Email Adresse> eintragen

Step 1.2 - If you used to feed FR24 with ADS-B data before enter your sharing key.
If you don't remember your sharing key, pelase use the retrival form:
http://feed.flightradar24.com/forgotten_key.php
$:<Flightradar 24 sharing key> eintragen oder leer lassen, wenn man keinen hat

Step 1.3 - Would you like to participate in MLAT calculations? (yes/no)
$:no

Would you like to use autoconfig (*yes*/no)
$:no

Step 4.1 - Receiver selection:

1 - DVBT Stick (USB)
-----------------------------------------------------
2 - SBS1, SBS1er or SBS3 (USB/Network)
3 - ModeS Beast (USB/Network)
4 - AVR Compatible (DVBT over network, etc)
5 - microADSB (USB/Network)


Enter your receiver type (1-5)
$:3

Step 4.2 - Please select connection type:

1 - Network connection
2 - USB directly to this computer

Enter your connection type (1-2)
$:1

Step 4.3A - Please enter your receiver's IP address/hostname
$:127.0.0.1

Step 4.3B - Please enter your receiver's data port number
$:30005

Step 5.1 - Would you like to enable RAW data feed on port 30334 (yes/no)
$:no

Step 5.2 - Would you like to enable Basestation data feed on port 30003 (yes/no)
$:no

Step 6A - Please select desired logfile mode:
0 - Disabled
1 - 48 hour, 24h rotation
2 - 72 hour, 24h rotation
Select logfile mode (0-2)
$:0

Step 6B - Please enter desired logfile path (/var/log):
$:Eingabetaste drücken

Den Service fr24feed neu starten, damit die Einstellungen aktiv werden.

sudo service fr24feed restart

Die ADS-B Daten sollten jetzt mit Flightradar 24 geteilt werden. Der Feeder hat ein Webinterface, in welchen man sehen kann, ob alles funktioniert. Die Adresse lautet 127.0.0.1:8754

Hinweise:
Den Ordner /var/log halte ich im RAM. Das ist der Grund warum ich das Logging bei der Konfiguration deaktiviert habe. Das kann jederzeit über das Webinterface unter folgender Adresse geändert werden: 127.0.0.1:8754/settings.html.

Daten mit Plane Finder teilen

Feeder installieren (pfclient_3.0.2080_armhf.deb durch die aktuelle Versionsnummer ersetzen. Die aktuelle Versionsnummer kann man hier finden.)

cd /home/pi/Downloads
wget http://client.planefinder.net/pfclient_3.0.2080_armhf.deb
sudo dpkg -i pfclient_*_armhf.deb

Feeder konfigurieren.

Nun die Seite 127.0.0.1:30053/map.html des Webinterface öffnen. Wenn alles gut gelaufen ist, kann man Flugzeuge sehen und die ADS-B Daten sollten jetzt mit Plane Finder geteilt werden.

Hinweise:
Da ich /var/log im RAM halte, gibt es nach den Neustart des Raspberry ein Problem. Der Planefinder Client versucht im Ordner /var/log/pfclient seine Log- Dateien anzulegen. Wenn der Ordner nicht vorhanden ist, wird der Service pfclient nicht gestartet. Für mich scheint die folgende Lösung am besten.

sudo nano /etc/int.d/pfclient

Den Eintrag

LOGFILE=/var/log/pfclient

zu

LOGFILE=/dev/nul

ändern. Dadurch ist das Standard- Logging deaktiviert, aber auch im Webinterface 127.0.0.1:30053/logs.html nicht mehr zu sehen.

Den Eintrag

start-stop-daemon --start --exec $DAEMON -- -d -i $PIDFILE -z $CONFIGFILE -y $LOGFILE $ 2>/var/log/pfclient/error.log

habe ich so gelassen, um im Fehlerfall Informationen zu haben. Damit das aber funktioniert, muss man folgende Zeile nach der Variablen Deklaration hinzufügen.

mkdir -p /var/log/pfclient

So wird beim starten des Service pfclient den Ordner /var/log/pfclient angelegt.

Daten mit FlightAware teilen

Feeder installieren (piaware_2.1-2_armhf.deb durch die aktuelle Versionsnummer ersetzen. Die aktuelle Versionsnummer kann man hier finden.)

cd /home/pi/Downloads
wget http://flightaware.com/adsb/piaware/files/piaware_2.1-2_armhf.deb
sudo dpkg -i piaware_*_armhf.deb
sudo apt-get install -fy

und konfigurieren.

sudo piaware-config -autoUpdate 1 -manualUpdate 1
sudo piaware-config -user <FlightAware Benutzername> -password
> das <FlightAware Passwort> eingeben

Danach den Service piaware neu starten.

sudo service piaware restart

Die ADS-B Daten sollten jetzt mit FlightAware geteilt werden.

Hinweis:
Die Konfiguaration von piaware wird in der Datei /root/.piaware abgelegt.

Daten mit ADS-B Exchange teilen

Installieren und konfigurieren, damit die Datenbasis von piaware (FlightAware) genommen wird.

cd /home/pi/src
git clone https://github.com/jprochazka/adsb-exchange.git
cd adsb-exchange
chmod 755 piaware_setup.sh
./piaware_setup.sh

Jetzt sollten die ADS-B Daten auch mit ADS-B Exchange geteilt werden.

Hinweis:
Die Konfiguaration für ADS-B Exchange wird in der FlightAware- Konfiguarationsdatei /root/.piaware abgelegt.

MLAT von piaware selbst nutzen

Auf Basis dieser Beschreibung habe ich mein Konfiguarition wie folgt erstellt.

Die MLAT Berechnungen soll piaware auf Port 30104 ausgeben.

sudo nano /root/.piaware
mlatResultsFormat {beast,connect,127.0.0.1:30104 beast,connect,feed.adsbexchange.com:30005}
sudo service piaware restart

Die MLAT Berechnungen sollen von dump1090-mutability auf Port 30104 empfangen werden.

sudo nano /etc/default/dump1090-mutability
# Port to listen on for Beast-format input connections. 0 disables.
BEAST_INPUT_PORT="30104"
sudo service dump1090-mutability restart

Durch diese Einstellungen bekommt dump1090-mutability die MLAT Berechnungen von piaware. Diese werden über den Port 30005 weitergegeben und dadurch allen anderen Programmen zur Verfügung gestellt.

Virtual Radar Server

Installationsvoraussetung ist mono, da die Software in .net erstellt ist.

sudo apt-get install mono-complete

Installieren.

cd /home/pi/Downloads
wget http://www.virtualradarserver.co.uk/Files/VirtualRadar.tar.gz

Der automatische Start erfolgt bei mir durch ein selbst erstelltes Service Script. Dieses kann mit den Befehl

sudo nano /etc/init.d/vrs

erstellt werden. Den folgenden Ihnalt einfügen.

#! /bin/sh
### BEGIN INIT INFO
# Provides:          VirtualRadarServer
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: web page for ADSB
# Description:       my own ADS-B data with Virtual Radar Server
### END INIT INFO

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="Virtual Radar Sever for ADSB"
NAME=VirtualRadar
DAEMON="/usr/bin/mono /SDR/VRS/$NAME.exe"
DAEMON_ARGS="-workingFolder:/mnt/usbhdd/SDR/Resources/VRS -nogui"
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/vrs

# Exit if the package is not installed
#[ -x "$DAEMON" ] || exit 0

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
# and status_of_proc is working.
. /lib/lsb/init-functions

#
# Function that starts the daemon/service
#
do_start()
{
        # Return
        #   0 if daemon has been started
        #   1 if daemon was already running
        #   2 if daemon could not be started
        start-stop-daemon --start --background --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
                || return 1
        start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --exec $DAEMON -- $DAEMON_ARGS \
                || return 2
               
        # Add code here, if necessary, that waits for the process to be ready
        # to handle requests from services started subsequently which depend
        # on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
        # Return
        #   0 if daemon has been stopped
        #   1 if daemon was already stopped
        #   2 if daemon could not be stopped
        #   other if a failure occurred
        start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --exec $DAEMON
        RETVAL="$?"
        [ "$RETVAL" = 2 ] && return 2
        # Wait for children to finish too if this is a daemon that forks
        # and if the daemon is only ever run from this initscript.
        # If the above conditions are not satisfied then add some other code
        # that waits for the process to drop all resources that could be
        # needed by services started subsequently.  A last resort is to
        # sleep for some time.
        start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
        [ "$?" = 2 ] && return 2
        # Many daemons don't delete their pidfiles when they exit.
        rm -f $PIDFILE
        return "$RETVAL"
}

#
# main
#
case "$1" in
  start)
        [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
        do_start
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  stop)
        [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
        do_stop
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  #status)
        #status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
        #;;
  #reload|force-reload)
        #
        # If do_reload() is not implemented then leave this commented out
        # and leave 'force-reload' as an alias for 'restart'.
        #
        #log_daemon_msg "Reloading $DESC" "$NAME"
        #do_reload
        #log_end_msg $?
        #;;
  restart|force-reload)
        #
        # If the "reload" option is implemented then remove the
        # 'force-reload' alias
        #
        log_daemon_msg "Restarting $DESC" "$NAME"
        do_stop
        case "$?" in
          0|1)
                do_start
                case "$?" in
                        0) log_end_msg 0 ;;
                        1) log_end_msg 1 ;; # Old process is still running
                        *) log_end_msg 1 ;; # Failed to start
                esac
                ;;
          *)
                # Failed to stop
                log_end_msg 1
                ;;
        esac
        ;;
  *)
        #echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
        echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
        exit 3
        ;;
esac
:

Die Konfiguaration ist etwas umfangreicher. Doch auch diese will ich hier noch beschreiben
.
.
.
.
.
.

Nite-overlay mit dem Custom Content Plugin

In den Ordner /SDR/Resources/VRS/CustomContent wechseln.

cd /SDR/Resources/VRS/CustomContent

Eine neue html- Datei erstellen mit

sudo nano nite-overlay.html

und den folgenden Inhalt einfügen.

<script type="text/javascript">
    if(VRS && VRS.globalDispatch && VRS.serverConfig) {
        VRS.globalDispatch.hook(VRS.globalEvent.bootstrapCreated, function(bootStrap) {
            bootStrap.hookInitialised(function(pageSettings) {
                // Load the nite-overlay.js script from https://github.com/rossengeorgiev/nite-overlay
                // it gets loaded so we need to load it dynamically after Google Maps has been loaded.
                // We can't just have a <script	> tag for it.                
                if(pageSettings.mapPlugin && pageSettings.mapPlugin.getNativeType() === 'GoogleMaps') {
                    VRS.scriptManager.loadScript({
                        key: 'nite-overlay',
                        url: 'nite-overlay/nite-overlay.js',
                        success: function() {
                            var map = pageSettings.mapPlugin.getNative();
                            nite.init(map);
                            setInterval(function() { nite.refresh() }, 10000); // refresh every 10s
                        }
                    });
                }
            });
        });
    }
</script>

Nun das script von GitHub klonen.

git clone https://github.com/rossengeorgiev/nite-overlay

Der Ordnerinhalt sollte nun wie folgt aussehen.

nite-overlay nite-overlay

Im Custom Content Plugin muss folgender Eintrag hinzugefügt werden.

nite-overlay

Reverse Proxy

Das Webinterface von Virtual Radar Server kann man im Internet über einen nginx reverse_proxy bereitstellen. Dafür die Konfiguration von nginx öffnen,

sudo nano /etc/nginx/sites-available/default

folgende Zeilen hinzufügen

###### beginn Virtual Radar Server #########
#
if ($mobile_request = true) {
	rewrite ^/vr/$ /VirtualRadar\mobile.html permanent;
	rewrite ^/vr$ /VirtualRadar\mobile.html permanent;
}
if ($mobile_request = false) {
	rewrite ^/vr/$ /VirtualRadar\desktop.html permanent;
	rewrite ^/vr$ /VirtualRadar\desktop.html permanent;
}
#
location /vrs {
	rewrite /vrs/(.*) /$1 break;
	proxy_pass 127.0.0.1:8082;
	proxy_redirect off;
	proxy_set_header Host $host;
	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
#
###### ende Virtual Radar Server #########

und speichern. Nach einen neustart des Service nginx

sudo service nginx restart

ist das Webinterface über die Adresse <domain>/vr im Internet erreichbar.

Alles prüfen (Endkontrolle)

#!/bin/bash
clear
service dump1090-mutability status
echo -e
ps ax | grep dump1090-mutability
echo -e
service modesmixer2 status
echo -e
ps ax | grep modesmixer2
echo -e
service fr24feed status
echo -e
ps ax | grep fr24feed
echo -e
service pfclient status
echo -e
ps ax | grep pfclient
echo -e
service piaware status
echo -e
ps ax | grep piaware
echo -e
service vrs status
echo -e
ps ax | grep vrs

Den RPi-Monitor erweitern

Damit ich stets über den Zustand der Services im Bilde bin, habe ich mein RPi- Monitor Webinterface um diese Informationen erweitert.

SSL Test Result

Hierzu eine neue Datei erstellen mit

sudo nano etc/rpimonitor/template/avionics.conf

und den folgenden Inhalt hinein kopieren.

#######################################################################
# ADSB information
#  Page: 1
#  Information               Status     Statistics
#  - dump1090_mutability     - yes      - no
#  - modesmixer2             - yes      - no
#  - fr24feed                - yes      - no
#  - pfclient                - yes      - no
#  - piaware                 - yes      - no
########################################################################

dynamic.21.name=du1,du2
dynamic.21.source=service dump1090-mutability status
dynamic.21.regexp=((?:active|inactive|failed|activating|deactivating).*)(\(.*)

static.21.name=duv
static.21.source=dump1090-mutability --help
static.21.regexp=dump1090-mutability v(.*) 

dynamic.22.name=mo1,mo2
dynamic.22.source=service modesmixer2 status
dynamic.22.regexp=((?:active|inactive|failed|activating|deactivating).*)(\(.*)

static.22.name=mov
static.22.source=/usr/bin/modesmixer2 --help
static.22.regexp=ModeSMixer2 v.(.*)

dynamic.23.name=vr1,vr2
dynamic.23.source=service vrs status
dynamic.23.regexp=((?:active|inactive|failed|activating|deactivating).*)(\(.*)

dynamic.24.name=fr1,fr2
dynamic.24.source=service fr24feed status
dynamic.24.regexp=((?:active|inactive|failed|activating|deactivating).*)(\(.*)

static.24.name=frv
static.24.source=fr24feed --version
static.24.regexp=^(\d+(.\d){0,2}(.*)?)$

dynamic.25.name=pf1,pf2
dynamic.25.source=service pfclient status
dynamic.25.regexp=((?:active|inactive|failed|activating|deactivating).*)(\(.*)

static.25.name=pfv
static.25.source=pfclient -v
static.25.regexp=version:(.*)

dynamic.26.name=pi1,pi2
dynamic.26.source=service piaware status
dynamic.26.regexp=((?:active|inactive|failed|activating|deactivating).*)(\(.*)

static.26.name=piv
static.26.source=piaware -v
static.26.regexp=(^.*)

dynamic.27.name=dump1090http
#dynamic.27.source=netstat -nlt
#dynamic.27.regexp=tcp .*:(6690).*LISTEN
#dynamic.27.source=curl -I https://127.0.0.1/dump1090 | head -1
#dynamic.27.regexp=curl: \((7)\)

dynamic.28.name=modesmixer2http
dynamic.28.source=netstat -nlt
dynamic.28.regexp=tcp .*:(6691).*LISTEN

dynamic.29.name=vrshttp
dynamic.29.source=netstat -nlt
dynamic.29.regexp=tcp .*:(8082).*LISTEN

dynamic.30.name=fr24feedhttp
dynamic.30.source=netstat -nlt
dynamic.30.regexp=tcp .*:(8754).*LISTEN

dynamic.31.name=pfclienthttp
dynamic.31.source=netstat -nlt
dynamic.31.regexp=tcp .*:(30053).*LISTEN

web.status.1.content.10.name=Avionics
web.status.1.content.10.icon=avionics.png
web.status.1.content.10.line.1="<font size='+0.5'>dump1090 </font>" + "<a href='https://github.com/mutability/dump1090/releases'>" + data.duv + "</a>"
web.status.1.content.10.line.2="service dump1090-mutability status: <b>" + data.du1 + data.du2 + "</b>"
#web.status.1.content.10.line.3=Label(data.dump1090http,"!=7","OK","label-success") + Label(data.dump1090http,"==7","KO","label-danger") + " <a href='https://mostlecapi.de/dump1090'>web interface</a>"
web.status.1.content.10.line.3=""
web.status.1.content.10.line.4="<hr>"
web.status.1.content.10.line.5="<font size='+0.5'>ModeSMixer2 </font>" + "<a href='http://xdeco.org/?page_id=30'>" + data.mov + "</a>"
web.status.1.content.10.line.6="service modesmixer2 status: <b>" + data.mo1 + data.mo2 + "</b>"
web.status.1.content.10.line.7=Label(data.modesmixer2http,"==6691","OK","label-success") + Label(data.modesmixer2http,"!=6691","KO","label-danger") + " web interface" + " <a href='http://rasts01:6691'>local</a>" + "|<a href='http://suttner.ddns.net:6691'>www</a>"
web.status.1.content.10.line.8="<hr>"
web.status.1.content.10.line.9="<font size='+0.5'>Virtual Radar Server</font>"
web.status.1.content.10.line.10="service vrs status: <b>" + data.vr1 + data.vr2 + "</b>"
web.status.1.content.10.line.11=Label(data.vrshttp,"==8082","OK","label-success") + Label(data.vrshttp,"!=8082","KO","label-danger") + " web interface" + " <a href='https://rasts01/vr'>local</a>" + "|<a href='https://mostlecapi.de/vr'>www</a>"
web.status.1.content.10.line.12="<hr>"
web.status.1.content.10.line.13="<font size='+0.5'>Flight Radar 24 </font>" + "<a href='http://feed.flightradar24.com'>" + data.frv + "</a>"
web.status.1.content.10.line.14="service fr24feed status: <b>" + data.fr1 + data.fr2 + "</b>"
web.status.1.content.10.line.15=Label(data.fr24feedhttp,"==8754","OK","label-success") + Label(data.fr24feedhttp,"!=8754","KO","label-danger") + " web interface" + " <a href='http://rasts01:8754'>local</a>"
web.status.1.content.10.line.16="<hr>"
web.status.1.content.10.line.17="<font size='+0.5'>Plane Finder </font>" + "<a href='https://planefinder.net/sharing/client'>" + data.pfv + "</a>"
web.status.1.content.10.line.18="service pfclient status: <b>" + data.pf1 + data.pf2 + "</b>"
web.status.1.content.10.line.19=Label(data.pfclienthttp,"==30053","OK","label-success") + Label(data.pfclienthttp,"!=30053","KO","label-danger") + " web interface" + " <a href='http://rasts01:30053'>local</a>" + "|<a href='http://suttner.ddns.net:6692'>www</a>"
web.status.1.content.10.line.20="<hr>"
web.status.1.content.10.line.21="<font size='+0.5'>FlightAware </font>" + "<a href='http://de.flightaware.com/adsb/piaware/install'>" + data.piv + "</a>"
web.status.1.content.10.line.22="service piaware status: <b>" + data.pi1 + data.pi2 + "</b>"

#web.status.1.content.10.line.6="value to compare for the label test: ---<b>" + data.mo2 + "</b>---"
#web.status.1.content.10.line.7="label test: " + Label(data.mo2,"!=running","Okay","success")

Die neue Datei an beliebiger Stelle in der Datei /etc/rpimonitor/data.conf einbinden

sudo nano /etc/rpimonitor/data.conf
include=/etc/rpimonitor/template/avionics.conf

und den Service rpimonitor neu starten.

sudo service rpimonitor restart

PHP

installieren:

sudo apt-get install php5-fpm

Nginx für PHP konfigurieren

Die benutzte nginx Konfiguaration öffnen:

sudo nano /etc/nginx/sites-available/default

Die Indexzeile wie folgt anpassen:

index index.html index.htm index.php index.nginx-debian.html

PHP Eintrag wie folgt anpassen: (und das auch noch checken!)

..........

mySQL

Wenn mySQL bereits installiert war und nicht sauber entfernt wurde, kann es zu Problemen bei einer erneuten installation kommen. Mit den folgenden Befehlen muss man dann erst einmal aufräumen.

sudo apt-get remove --purge mysql*
sudo apt-get autoremove
sudo apt-get autoclean
sudo rm -rf /var/lib/mysql
sudo rm -rf /etc/mysql

Server

Installieren

sudo apt-get install mysql-server

Jetzt kann man noch eine für den Raspberry PI ressourcen freundlichere Konfiguration wählen.

sudo mv /etc/mysql/my.cnf /etc/mysql/my.cnf.bak
sudo cp /usr/share/doc/mysql-server-5.5/examples/my-small.cnf /etc/mysql/my.cnf

Die neue Konfiguaration öffnen

sudo nano /etc/mysql/my.cnf

und im Bereich [mysqld] den folgenden Eintrag hinzufügen

query_cache_size = 8M

Anmeldeprobleme

Bei Anmeldeproblemen mit den Benutzer root (bei mir war das Passwort zu lange oder es hatte Sonderzeichen, die nicht zugelassen sind????)

mysql -u root -p

oder wenn man das Passwort für den Benutzer root vergessen hat, kann man mit folgenden workaround ein neues Passwort für den Benutzer root erstellen. Zuerst die Datei

sudo nano /etc/mysql/debian.cnf

öffnen. In dieser kann man das Passwort für den Benutzer debian-sys-maint finden. Man kann sich mit diesen Daten anmelden.

mysql -u debian-sys-maint -p
Enter password: das <mySQL debian-sys-maint Passwort> eingeben

Da der Benutzer debian-sys-maint alle Rechte hat, kann man jetzt das Passwort für den Benutzer root anpassen. Die Datenbank mysql auswählen

mysql> use mysql;

Passwort mit folgendem Befehl ändern

mysql> update user set password=PASSWORD('<neues mySQL root Passwort>') where User='root';

Anschließend ein Flush Privileges durchführen und die MySQL Konsole beenden.

mysql> flush privileges;
mysql> quit;

Client

installieren:

sudo apt-get install mysql-client

PHP

erweitern:

sudo apt-get install php5-mysql

PHPMyAdmin

installieren:

sudo apt-get install phpmyadmin

Wenn man ngnix verwendet, weder apache2 noch lighttpd auswählen.

Im zweiten Dialog die Datenbank anlegen lassen (Ja auswählen).

Nun muss noch eine Verknüpfung für phpMyAdmin von /usr/share/phpmyadmin nach /var/www/phpmyadmin erstellt werden:

sudo ln -s /usr/share/phpmyadmin /var/www/html/phpmyadmin

ownCloud / nextCloud

Hier der link zur Übersicht der Entwicklerseite.

Wie es aussieht muss man bei Raspberry Pi und ownCloud nichts mehr selbst konfigurieren. Es gibt scheinbar die Möglichkeit ein fertiges lauffähiges SD Karten Image zu erstellen. Das habe ich jedoch (noch) nicht getestet.

Darum geht es jetzt erst einmal zur manuellen Einrichtung. Da ich mich für mySQL als Datenbank entschieden habe, werde ich auch nur die mySQL Einrichtung beschreiben.

mySQL Datenbank erstellen

den cloud Benutzer anlegen und die Rechte vergeben.

mysql -u root -p
Enter password: das <mySQL root Passwort> eingeben
CREATE DATABASE cloud;
CREATE USER cloudRoot@localhost IDENTIFIED BY '<Passwort>';
GRANT ALL PRIVILEGES ON cloud.* TO cloudRoot@localhost;
FLUSH PRIVILEGES;
exit;

PHP erweitern

und zugehörige Bibliotheken vervollständigen.

sudo apt-get install php5-mysql ssl-cert php5-cli php5-common php5-cgi php-pear curl libapr1 libtool php5-curl libcurl4-openssl-dev php-xml-parser php5-dev php5-gd memcached php5-memcache

Danach PHP FastCGI Process Manager konfigurieren. Öffnen mit

sudo nano /etc/php5/fpm/php.ini

und prüfen, ob folgende Einträge identisch sind. Wenn nicht, dann anpassen.

default_charset = "UTF-8"
upload_max_filesize = 10G
post_max_size = 10G
upload_tmp_dir = /mnt/usbhdd/cloud/temp
max_input_time = 360000
#The maximum time in seconds a script is allowed to parse input data.
max_execution_time = 360000
memory_limit = 512M

Installieren

(owncloud-8.2.3.tar.bz2 durch die aktuelle Versionsnummer ersetzen. Die aktuelle Versionsnummer kann man hier finden.)

sudo mkdir -p /var/www/html/cloud
cd /var/www/html
sudo wget https://download.owncloud.org/community/owncloud-8.2.3.tar.bz2
sudo tar xvf owncloud-*.tar.bz2
sudo chown -R www-data:www-data /var/www/html/cloud
sudo rm -rf owncloud-*.tar.bz2

Nun muss man noch einmal folgende Einstellungen prüfen und eventuell anpassen.

sudo nano /var/www/html/cloud/.user.ini
default_charset = "UTF-8"
upload_max_filesize = 10G
post_max_size = 10G
memory_limit = 512M

Optimieren

Bei mir wurden trotz all den Einstellen noch folgende Sicherheits- und Einrichtungswarnungen angezeigt:

ownCloud Sicherheits- und Einrichtungswarnungen

Systempfade in PHP-fpm aktivieren

Die Konfiguration

sudo nano /etc/php5/fpm/pool.d/www.conf

öffnen und in dieser die folgenden Zeilen durch entfernen des Semikolons aktivieren.

env[HOSTNAME] = $HOSTNAME
env[PATH] = /usr/local/bin:/usr/bin:/bin
env[TMP] = /tmp
env[TMPDIR] = /tmp
env[TEMP] = /tmp

PHP neu starten und die Meldung im Webinterface sollte verschwunden sein.

sudo service php5-fpm restart

Genaueres dazu direkt bei ownCloud.

Caching aktivieren

Damit das Caching aktiviert werden kann muss zunächst ein weiteres PHP-Modul installiert

sudo apt-get install php-apc

und die cloud-Config

sudo nano /var/www/html/cloud/config/config.php

um folgende Zeile erweitert werden.

'memcache.local' => '\OC\Memcache\APCu',

Information zum Caching im ownCloud blog.

Gelockte Dateien

Immer wieder kommt es vor, dass beim Windows ownCloud Client im Aktivitäts Fenster im Reiter nicht syncronisiert folgende Meldung auftaucht: ...,Error downloading https://... - server replied: Locked ("..." is locked)
Im moment bekomme ich das nur durch das Löschen des Inhalts der Tabelle für gelockte Dateien in Griff.

sudo mysql -u root -p
Enter password: das <mySQL root Passwort> eingeben
mysql> USE cloud;

Nun kann man sich erst einmal den Inhalt der Tabelle mit den gelockten Dateien anzeigen lassen.

mysql> SELECT * FROM oc_file_locks;

Mit den folgenden Befehl kann die Tabelle geleert werden.

mysql> TRUNCATE TABLE oc_file_locks;

Wenn man sich nun den Inhalt der Tabelle noch einmal anzeigen lässt, ist diese leer.

mysql> SELECT * FROM oc_file_locks;

Danach können die gelockten Dateien wieder sysncronisiert werden.

Manuell hinzugefügte Dateien

Werden Dateien auf irgend einen Weg in das Dateisystem kopiert, muss ownCloud davon erfahren.
Zuerst in das ownCloud Verzeichnis wechseln

cd /var/www/html/cloud

und folgenden Befehl ausführen:.

sudo -u www-data php occ files:scan --all

Backup

Mit den folgenden Befehl kann man die Konfiguration sichern.

sudo tar -cvzf /home/pi/backup/cloud_config_$(date +%Y-%m-%d).tgz /var/www/html/cloud/config

Danach die mySQL Datenbank sichern. Das kann man ungepackt oder gepackt tun.

mysqldump -u root -p cloud > /home/pi/backup/cloud_mysql_$(date +%Y-%m-%d).bak
mysqldump -u root -p cloud | bzip2 -c > /home/pi/backup/cloud_mysql_$(date +%Y-%m-%d).bak.bz2
mysqldump -u root -p cloud | gzip -c > /home/pi/backup/cloud_mysql_$(date +%Y-%m-%d).bak.gz

ftp Server

Ich habe mich für vsftpd entschieden. Die Bezeichnung vsftpd ist die Kurzform für „Very Secure FTP Daemon. Der FTP Server mit dem Namen vsftpd ist ein FTP Daemon für Betriebssysteme vom Typ Unix. Der Name des Daemons ist Programm. Dies hat den Hintergrund, dass die Sicherheit gegenüber unbefugten Zugriffen ein wesentliches Augenmerk der Entwickler hinter vsftpd ist.
Anders als bei anderen FTP Servern verfolgt man nicht das Ziel, möglichst viele Funktionen zur Verfügung zu stellen, sondern ein sicheres Produkt anzubieten. Vsftpd verfügt über die Möglichkeit, mit virtuellen Benutzerkonten zu arbeiten und lässt sich im IP und/oder Benutzer-Kontext konfigurieren. Seit einigen Versionen kann vsftpd sowohl per inetd als auch als standalone Daemon betrieben werden.
Der FTP-Daemon vsftpd kann durch den folgenden Befehl installiert werden.

sudo apt-get install vsftpd

Nach der Installation wird der vsftpd automatisch gestartet. Wenn man Einstellungen ändern will, muss man wie folgt die Konfigurationsdatei vsftpd.conf anpassen.

sudo nano /etc/vsftpd.conf

Standart Wurzel Verzeichnis einstellen

local_root=/mnt/usbhdd/ftp

.... und die Rechte dafür vergeben????.

Spielbereich


Quellen / Verweise

Änderungsprotokoll