Besonders gefallen hat mir das anfangen: Auf meinem Debian musste ich einfach nur

sudo apt-get install arduino

eingeben und schon konnte ich den Arduino-Uno über USB ansprechen. Die Energieversorgung läuft praktischer Weise auch gleich über USB. Also einfach nur mit dem USB-Kabel anschließen und die Arduino-IDE starten. Schon kann man einfache Testprogramme nutzen. Die Programme werden in C++ geschrieben.

Als nächstes hab ich mir dann Fritzing installiert.

sudo apt-get install fritzing

Fritzing ist ein Programm mit dem man einfach Schaltpläne entwerfen kann. Es ist vor allem geeignet um sich über seine Arduino-Projekte auszutauschen. Auch hier wieder Open-Source (sogar GPL).

Da die Arduino-IDE nun sehr schlicht gehalten ist wünscht man sich bei größeren Projekten vielleicht eine umfangreichere IDE. Ich hab Eclipse genommen (weil ich das schon kenne und weil es freie Software ist). Für Eclipse(CDT) installiert man sich einfach dieses Plugin. Die weitere Installation ist auf der verlinkten Seite beschrieben. Das klappt eigentlich ganz gut.

Weil ich aber dazu noch einen USB-zu-MIDI Stecker genutzt habe hat der Zugriff auf den Seriellen Port nicht so toll geklappt. Ich habe aber nicht so richtig verstanden warum. Egal, man kann den seriellen Port auch einfach direkt vom Terminal aus sehen:

cu -l /dev/ttyUSB0 -s 31250

cu ist das Programm Call up. Damit kann man Serielle Ports also die Signale vom Arduino auslesen. /dev/ttyUSB0 ist das Gerät von dem die Ausgaben ausgelesen werden können. Wie es heißt kann man z.B. herausbekommen indem man schaut auf welches Gerät die Arduino-IDE nutzt. Hinter der Option -s kommt die Geschwindikeit. Die geht aus dem Programmcode selber hervor (hier 31250):

void setup() {
// Set baud rate:
Serial.begin(31250);
}

Nunja, man kann natürlich auch alles mit dem Terminal machen. Das Programm avrdude wird hier nützlich sein. Mir hat jemand erzählt er Programmiert grundsätzlich nur mit VIM. Kann man natürlich auch machen. :-)

Da die Quelltexte der Tor Software z.T. offen sind, können wir diese einfach herunterladen und selbst kompilieren. Im Großen und Ganzen werden das 4 Compilevorgänge welche wir ausführen werden:

• Openssl
• Libevent
• Tor
• Tor-arm

Da wir keine Rootrechte haben, werden wir uns eine „/“-ähnliche Struktur im Homeverzeichnis anlegen. 

Openssl kompilieren & installieren

Die erste Voraussetzung für Tor ist openssl. Falls das auf dem System noch nicht vorhanden ist, müssen wir es selbst kompilieren. Dazu wechseln wir in den RAM und erstellen einen separaten Ordner:

cd /tmp/ && mkdir openssl && cd openssl

Im nächsten Schritt laden wir uns das Archiv herunter und entpacken es:

wget http://www.openssl.org/source/openssl-1.0.1e.tar.gz && tar xfv openssl-1.0.1e.tar.gz && cd openssl-1.0.1e

Dem Konfigurationstool „config“ übergeben wir unser Homeverzeichnis als Prefix, damit die Dateien für die Installation entsprechend vorbereitet werden.

./Config --prefix=/home/$USER/
make
make install

Nachdem dieser Prozess abgeschlossen ist, können wir mit der nächsten Prozedur anfangen.

Libevent kompilieren & installieren

Für die Bibliothek „libevent“ führen wir ähnliche Schritte aus. Als erstes erstellen wir wieder einen neuen Ordner.

cd /tmp/ && mkdir libevent && cd libevent

Danach wieder den Quellcoder herunterladen, entpacken, konfigurieren und installieren… ihr wisst schon.

wget https://github.com/downloads/libevent/libevent/libevent-2.0.21-stable.tar.gz 
tar xfv libevent-2.0.21-stable.tar.gz
cd libevent-2.0.21-stable
./configure --prefix=/home/$USER/
make && make install

Endlich: Tor kompilieren & installieren

Jetzt können wir den Vorgang endlich für das eigentliche Programm ausführen. Die Prozedur sollte euch mittlerweile schon bekannt sein ;)

cd /tmp && mkdir tor && cd tor
wget https://www.torproject.org/dist/tor-0.2.3.25.tar.gz
tar xfv tor-0.2.3.25.tar.gz
cd tor-0.2.3.25
./configure --prefix=/home/$USER/
make && make install

Jetzt solltet ihr die Tor-Binaries im ~/bin Verzeichnis finden. Bevor ihr Tor ausführt, solltet ihr diesen korrekt konfigurieren. 

Tor als Relay-Node konfigurieren

Im Tor-System gibt es drei verschiedene Servertypen. Die Entry-, Relay- & Exitnodes. Die ersten Beiden sollte man ohne weitere Kopfschmerzen bzw. Probleme betreiben können. Über die Entry-Nodes verbinden sich die Tor-Nutzer mit dem Tor-Netzwerk. Die Relay-Nodes dienen als Zwischenstellen zwischen dem Entry und dem Exit Node. Der Exit-Node ist dann die Schnittstelle zwischen Tor-Netzwerk und Internet. Die Personen, die diese Art von Server betreiben bekommen oft Post von unglücklichen Administratoren bzw. Multimediaunternehmen ;)

Wie auch immer, wir erstellen nur einen Relay-Node, welcher das Tor-Netzwerk erweitert. Tor liefert eine Beispielkonfiguration, welche wir als Grundlage verwenden und als „torrc“ kopieren.

cp ~/etc/tor/torrc.sample ~/etc/tor/torrc

Öffnet diese danach mit eurem favorisierten Texteditor. Die folgenden Einstellungen sollten ähnlich gesetzt werden. (Suchfunktion empfehlenswert):

• ExitPolicy reject *:* # no exits allowed
  
• Nickname MyUniqueNode #Tor nodes nickname
• ORPort 9001 #Tor port
• RelayBandwidthRate 5000 KB # Throttle traffic to 100KB/s (800Kbps)
• RelayBandwidthBurst 5000 KB # But allow bursts up to 200KB/s (1600Kbps)
• Log notice file /home/[BENUTZER]/var/log/tor/notices.log #Logfile
• Log debug file /home/[BENUTZER]/var/log/tor/debug.log #Logfile
• ControlPort 9051 #Controlport
• HashedControlPassword 16:PASSWORT #(siehe weiter unten)

Den Wert für den Eintrag „HashedControlPassword“ müssen wir zunächst generieren. Die benötigten Hashwert erhaltet ihr über folgenden Aufruf:

~/bin/tor --hash-password PASSWORT

Speichert eure Konfiguration und prüft zwei Mal, ob der Wert ExitPolicy korrekt gesetzt ist ;)

Damit wir Tor später unsere Binaries im ~/bin Verzeichnis ohne weitere Umstände ausführen können, fügen wir den Pfad einfach zur PATH Variable hinzu:

export PATH=$PATH:/home/$USER/bin

Ihr solltet nun Tor über die Eingabe von „tor“ direkt ausführen können. Tor sollte ohne weitere Fehlermeldungen starten, und anfangen seine Arbeit als Relay-Node aufzunehmen. Voraussetzung ist, dass die oben angegebenen Ports von Außen erreichbar sind.

Tor-Arm installieren

Es bietet sich immer an, eine textbasierte UI zu haben, um Informationen über den Torserver zu erhalten. Dazu bietet sich das kleine Tool „tor-arm“ an. Es basiert auf Python. Ich gehe davon aus, dass Python bereits auf dem System zur Verfügung gestellt wird. Andernfalls muss Python nach dem zuvor gezeigten Schema installiert werden.

Um Tor-arm einzurichten, müssen wir ein wenig an den Dateien rum basteln. Zunächst laden wir diese aber erstmal herunter und entpacken das neue Archiv.

mkdir /tmp/torarm && cd /tmp/torarm
wget http://www.atagar.com/arm/resources/static/arm-1.4.5.0.tar.bz2
tar xfv arm-1.4.5.0.tar.bz2 
cd arm

Danach müssen wir  einen Ordner für arm erstellen und die Dateien kopieren:

mkdir -p ~/etc/arm/
cp src/* ~/etc/arm/

Also nächstes kopieren wir das zum Starten benötigte Shellscript:

cp arm ~/bin/

Dieses Script müssen wir noch ein wenig bearbeiten. Öffnet die Datei unter ~/bin/arm und ändert die ersten Zeilen ab:

if [ "$0" = /home/$USER/bin/arm ]; then
  arm_base=/home/$USER/etc/arm/

Speichert die Datei ab. Jetzt solltet ihr „arm“ aufrufen können und es sollte euch nach dem Control-Passwort fragen. Habt ihr dieses eingegeben, dann sollte euch eine schöne UI über euren Tor-Node informieren.

Fazit

Der Artikel wurde am Ende doch etwas länger als erwartet. Ich hoffe aber trotzdem damit einige zu motivieren einen kopfschmerzfreien Tor-Relay Node aufzusetzen, um das Tor-Netzwerk zu unterstützen. Wer die ganzen Quelltexte nicht selbst kompilieren möchte, der kann auf fertige Pakete zugreifen: tor, tor-arm.

~Sebastian

Was ist Mumble?

Mumble ist eine Alternative zu Teamspeak bzw. Skype. Man kann in verschiedenen Kanälen mit verschiedenen Personen sprechen. Es ist quelloffen, und läuft auf den meisten Betriebssystemen.

Die Voraussetzungen

Als Voraussetzung müssen wir ein wenig Software installieren, damit wir den Mumbleserver vom Source kompilieren können.

 sudo apt-get install git build-essential qt4-dev-tools libqt4-dev libspeex1 libspeex-dev \
                libboost-dev libasound2-dev libssl-dev g++ libspeechd-dev \
                libzeroc-ice-dev ice-slice libpulse-dev slice2cpp libcap-dev \
                libspeexdsp-dev libprotobuf-dev protobuf-compiler libogg-dev \
                libavahi-compat-libdnssd-dev libsndfile1-dev libg15daemon-client-dev libxi-dev qconf qt4-qmake

Nachdem die Installation der Software abgeschlossen ist, kann man ohne größere Probleme die nächsten Schritte abarbeiten.

Ich habe für den Mumble einen neuen Benutzer angelegt, damit man es nicht mit root-Rechten ausführt ;)

sudo adduser -m -s /bin/false mumble

Wir vergeben diesem Benutzer keine Bash, da er diese nicht benötigt. Für die späteren Logins werden wir die temporär setzen. Wir loggen uns nun also als mumble-User ein.

sudo su -s /bin/bash mumble

Mumbleserver kompilieren

Zum Kompilieren brauchen wir natürlich den Sourcecode, welchen wir uns über git herunterladen und in den neuen Ordner wechseln werden.

git clone git://github.com/mumble-voip/mumble.git mumble
cd mumble

Als nächstes müssen wir dann noch die Submodule einrichten:

git submodule init
git submodule update

Als nächstes rufen wir qmake gefolgt von make auf:

qmake -recursive main.pro CONFIG+=no-client
make

Der ganze Prozess dauert einige Minuten. Danach sollte sich die Binary im release Ordner befinden. Ich habe mir zur Übersicht einen symbolischen Link ins Homeverzeichnis gepackt.

 cd ~
 ln -s mumble/release/murmurd murmurd

Mumbleserver konfigurieren

Nachdem wir alles kompiliert haben, müssen wir den Server nur noch konfigurieren. Wir kopieren uns dazu die Beispielkonfiguration ins Homeverzeichnis.

 cp mumble/scrips/murmur.ini ~/

Diese könnt ihr dann mit einem Editor eurer Wahl bearbeiten. Folgende Einträge empfehle ich zu bearbeiten:

database=murmurdb.sqlite
dbus=session
ice="tcp -h 127.0.0.1 -p 6602"
icesecretread=[PW]
icesecretwrite=[PW]
logfile=murmur.log
pidfile=murmur.pid
port=64738
host=0.0.0.0
serverpassword=[SPW]
bandwith=72000
users=100
textmessagelength=5000
allowhtml=false
registerName=[ROOT-Channel Name]
uname=mumble

Als nächstes müssen wir das Superuserpasswort setzen. Dazu führen wir einmal murmurd mit dem entsprechenden Parameter auf:

./murmurd -supw [PW]

Mit dem Superuserpasswort könnt ihr euch später einloggen, um als Admin alle Einstellungen zu bearbeiten. murmurd sollte sich nach dieser Aktion wieder beenden.

Mumbleserver starten/stoppen

Wenn die Konfiguration nach den eigenen Wünschen abgeschlossen ist, dann können wir den Server nun starten.

 ./murmurd -ini ./murmur.ini

Ein Blick in die murmur.log bzw. ein Blick in die Prozessliste sollte dann zeigen, ob der Server erfolgreich läuft.

ps aux | grep murmur

Möchten wir den Server wieder beenden, dann lesen wir einfach die pid aus der entsprechenden Datei aus und übergeben dies als Argument für den kill Befehl.

 kill $(cat murmur.pid)

Mumbleserver Webinterface

Möchten wir zur besseren Konfiguration noch ein Webinterface installieren, so führen wir folgende Schritte aus.

Wir installieren das Mumble-Django Paket (Achtung: Apache2 wird mitinstalliert)

 sudo apt-get install mumble-django

Da ich den Apache nicht wirklich leiden kann, habe ich dessen Port in der /etc/apache2/ports.conf auf 88 statt 80 gesetzt. Dies ist nicht notwendig, falls kein anderer Webserver läuft.

Als nächstes führen wir eine Konfiguration des Paketes aus:

 sudo mumble-django-configure

Die Fragen könnt ihr so ähnlich beantworten:

1. 1
2. 1
3. Ice-secret aus der Konfiguration oben eingeben [PW]
4. 1

Ihr findet das Webinterface dann unter der angegeben Domain unter der folgenden URL:

 http://[DOMAIN]:[PORT]/mumble-django/

Ihr könnt euch dort mit dem Superuser anmelden, um zur Administration zu gelangen.

Fazit

Ich hoffe ihr könnt die Anleitung ohne weitere Probleme nachvollziehen, und habt viel Spaß beim Rummumblen ;)

~ Sebastian