Autor: sg

Adressen und Termine zuhause auf dem eigenen Server speichern und mit Notebook und Smartphone abgleichen? Nichts leichter als das, mit einem Raspberry Pi und dem CardDAV / CalDAV Server Baikal.

Zur Vorbereitung muss zunächst der Webserver nginx, die Scriptsprache php und sqlite als Datenbank installiert werden.

sudo apt-get install nginx php5 php5-fpm php-pear php5-common php5-mcrypt php5-mysql php5-cli php5-gd sqlite php5-sqlite

Bevor wir den Webserver starten, sind noch zwei Einstellungen anzupassen, damit er auf dem nicht ganz so potenten Raspberry Pi auch anständig läuft: in der Daten „/etc/nginx/nginx.conf“ muss die Zahl der „worker_processes“ von 4 auf 1 und die der „worker_connections“ von 768 auf 128 reduziert werden.
Damit wir später unsere wertvollen Daten nicht ungesichert durchs Netz schicken, sollte die Datenübermittlung mittels SSL gesichert werden. Dafür erzeugen wir uns zunächst ein eigenes Zertifikat mit entsprechendem Schlüssel.

sudo mkdir /etc/nginx/ssl
cd /etc/nginx/ssl
sudo openssl genrsa -out baikal.key 4096
sudo openssl req -new -sha256 -key baikal.key -out baikal.csr

Jetzt signieren wir das Zertifikat noch selber (daher moniert der Browser später auch unser Zertifikat, weil es nicht von einer „vertrauenswürdigen“ Institution signiert wurde). Bei den Abfragen braucht nur bei „Country Name“ „DE“ für Deutschland und bei „Common Name“ die verwendete Dynamische DNS (DynDNS) (damit trotz wechselnder IP durch den Internetanbieter unser Server auch von außen erreichbar ist) wie etwa „abc.selfhost.xy“ angegeben werden.

sudo openssl x509 -req -sha256 -days 3650 -in baikal.csr -signkey baikal.key -out baikal.crt

Jetzt geht es daran, nginx richtig einzustellen, damit der Webserver unser Zertifikat kennt, die Verbindung immer verschlüsselt hergestellt und php genutzt wird. Dazu passen wir die Datei „/etc/nginx/sites-available/default“ an:

server { 
    listen 80; 
    listen [::]:80 ipv6only=on; # für den Fall, dass ihr schon ipv6 benutzt
    server_name abc.selfhost.xy; # alternativ kann zum Test auch die lokal IP 192.168.2.X genutzt werden
    rewrite ^ https://$server_name$request_uri? permanent; # immer https verwenden 
}
 
server {
    listen 443 ssl; 
    listen [::]:443 ssl ipv6only=on; # für den Fall, dass ihr schon ipv6 benutzt
    server_name abc.selfhost.xy; # alternativ kann zum Test auch die lokal IP 192.168.2.X genutzt werden
    ssl_certificate /etc/nginx/ssl/baikal.crt;  # unsere Zertifikat benutzen
    ssl_certificate_key /etc/nginx/ssl/baikal.key; # unseren Schlüssel benutzen

        root /usr/share/nginx/www;
        index index.html index.htm index.php;

        location / {
                # First attempt to serve request as file, then
                # as directory, then fall back to displaying a 404.
                try_files $uri $uri/ /index.html;
                # Uncomment to enable naxsi on this location
                # include /etc/nginx/naxsi.rules
        }

        location /doc/ {
                alias /usr/share/doc/;
                autoindex on;
                allow 127.0.0.1;
                allow ::1;
                deny all;
        }

    location ~ ^(.+.php)(.*)$ { # damit PHP richtig genutzt wird
        try_files $fastcgi_script_name =404;
        fastcgi_split_path_info  ^(.+.php)(.*)$;
        fastcgi_pass   unix:/var/run/php5-fpm.sock;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        fastcgi_param  PATH_INFO        $fastcgi_path_info;
        include        /etc/nginx/fastcgi_params;
    }

    rewrite ^/.well-known/caldav /baikal/cal.php redirect;
    rewrite ^/.well-known/carddav /baikal/card.php redirect;

    charset utf-8;

    location ~ /(.ht|Core|Specific) {
        deny all;
        return 404;
    }
}

Damit unsere Änderungen auch angenommen werden, starten wir alles neu:

sudo /etc/init.d/nginx restart
sudo /etc/init.d/php5-fpm restart

Als nächstes bereiten wir die Installation von Baikal vor (die aktuelle Fassung des „Flat package“ findet ihr unter http://baikal-server.com.

cd /usr/share/nginx/www
sudo wget http://baikal-server.com/get/baikal-flat-0.2.7.zip
sudo unzip baikal-flat-*.zip
sudo rm baikal-flat-*.zip
sudo mv baikal-flat/ baikal/
sudo chown -R www-data:www-data baikal/
sudo find baikal/ -type d -exec chmod 755 {} ;
cd baikal
sudo touch Specific/ENABLE_INSTALL
sudo chmod 755 Specific/
sudo chmod 755 Specific/db/
sudo chmod 755 Specific/db/db.sqlite

Damit unser Server auch von außen erreichbar ist, muss das Speedport W 724V entsprechend eingerichtet werden. Unter dem Punkt „Internet“ muss unter der Rubrik „Dynamisches DNS“ „Dynamisches DNS verwenden“ angehakt und die entsprechenden Zugangsdaten eingetragen werden. Anschließend muss unter der Rubrik „Portfreischaltung“ die TCP Port-Weiterleitung für 443-443 443-443 sowie 80-80 80-80 auf die IP (oder den vorher vergebenen Gerätenamen) des Raspberry Pi eingestellt werden.
Leider gibt es jetzt beim Speedport W 724V ein Problem: er kann kein NAT Loopback / Hairpin-NAT. Daher ist aus dem lokal Netzwerk unser Raspberry nicht über seine Dynamische DNS erreichbar, sondern nur über seine lokale IP. Für CalDAV und CardDAV, die sich ja wohl sowohl zuhause als auch von unterwegs synchronisieren sollen, ist das ein unhaltbarer Zustand. Eine einfache Lösung gibt es leider nicht. Da der Raspberry Pi aber ja sowieso immer läuft, gibt es einen Ausweg: wir nutzten diesen statt des Speedport als DNS-Server.
Dafür installieren wir DNS / DHCP Server dnsmasq:

sudo apt-get install dnsmasq

und passen anschließend die Datei „/etc/hosts“ folgendermaßen an:

127.0.0.1       localhost
::1             localhost ip6-localhost ip6-loopback
fe00::0         ip6-localnet
ff00::0         ip6-mcastprefix
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters
192.168.2.X   abc.selfhost.xy

Jetzt noch sicherstellen, dass zunächst die hosts dabei und danach der DNS-Server des Speedport abgefragt wird, indem wir die Datei „/etc/resolv.conf“ wie folgt anpassen:

nameserver 127.0.0.1
domain Speedport_W_724V_01011602_00_001
search Speedport_W_724V_01011602_00_001
nameserver 192.168.2.1

Danach dnsmasq neu starten:

sudo /etc/init.d/dnsmasq restart

Damit jetzt auch der Raspberry Pi als DNS-Server genutzt wird, gibt es zwei Möglichkeiten: 1. ihn gleich mit dnsmasq auch als DHCP-Server betreiben oder 2. bei den Geräten, die auf Baikal zugreifen sollen die IP des Raspberry Pi unter den Netzwerkeinstellungen händisch als DNS-Server eintragen. Da ich die zweite Option nutze, gibt es für 1. hier leider keine Anleitung.
Um Baikal nutzen zu können, braucht der CalDAV / CardDAV Server jetzt nur noch unter „https://abc.selfhost.xy/baikal/admin/install/“ installiert werden.
Nach Installation und der Einrichtung der Benutzer, Kalender und Telefonbücher können diese in den entsprechenden Programmen genutzt werden:

CalDAV (allgemein): https://abc.selfhost.xy/baikal/cal.php/calendars/BENUTZER/KALENDER/
CalDAV (für iOS/OS X): https://abc.selfhost.xy/baikal/cal.php/principals/BENUTZER/
CardDAV (allgemein): https://abc.selfhost.xy/baikal/card.php/addressbooks/BENUTZER/TELEFONBUCH/
CarDAV (für iOS/OS X): https://abc.selfhost.xy/baikal/card.php/principals/BENUTZER/

UPDATE zu Baikal 0.4.5

Da Baikal jetzt auf dav.php statt cal.php / card.php setzt und die Hauptdateien nicht mehr in baikal sondern baikal/html/ liegen, sind folgende Änderungen notwendig:

Geänderte rewrite Rules:

rewrite ^/.well-known/caldav /baikal/html/dav.php redirect;
rewrite ^/.well-known/carddav /baikal/html/dav.php redirect;

CalDav/CardDav (für iOS/OS X):

https://abc.selfhost.xy/baikal/html/dav.php/principals/BENUTZER/

Weiterführende Links und Dank an:
Jan Karres
Andrew Oberstar
ruhezustand.net