OpenWrt Kamikaze

Aus Opennet
Wechseln zu: Navigation, Suche

OpenWrt Backfire ist der aktuelle Entwicklungszweig der freien und quelloffenen Linux-Firmware für Embedded (Wireless) Devices. Es hat Kamikaze im Jahr 2010 abgelöst.

Inhaltsverzeichnis

OpenWrt Installation

Um OpenWrt zu installieren sollte man die aktuelle deutsche Anleitung befolgen.

Vollkommen veraltete vorkompilierte Images und Pakete finden sich im Opennet-Repository

Kurzanleitung Image bauen

Beim selber kompilieren hilft einem diese Anleitung hier: kompilieren (englisch)

Hinweise zum Dateisystem

  • *.image-Dateien sind komplette Festplatten-Images incl. Partitionstabelle und MBR mit GRUB
  • *.fs-Dateien sind reine Partitionsimages
  • Wahl zwischen Squashfs+Jffs2 (mit mini_fo Overlay), nur Jffs2 oder Ext2 als Root-Dateisystem
  • 1024 Zylinergrenze beachten, sonst LBA notwendig, ideal -> Partition < 490 MB
  • Jffs2 (ggf. mit squashfs bei kleinen Geräten) ist zu bevorzugen, weil journaling und stabiler bei Stromverlust

Grundkonfiguration

Mit Opennet Kamikaze Firmware Image:

  • Passwort mit passwd' setzen; ggf. /etc/dropbear/authorized_keys mit Public-Key versorgen
  • Autostart-Dienste mit /etc/init.d/<dienst> enable|disable einrichten (z.B. olsrd)
  • Netzwerk in /etc/config/network konfigurieren
  • Drahtloses Schnittstellen in /etc/config/wireless konfigurieren
  • WRAP neu starten

Siehe auch http://wiki.openwrt.org/OpenWrtDocs/KamikazeConfiguration

Konfigurationsdateien

Netzwerkkonfiguration + DNS in /etc/config/network:

config interface loopback
       option ifname   lo
       option proto    static
       option ipaddr   127.0.0.1
       option netmask  255.0.0.0
config interface lan
       option ifname   "eth0"
       option proto    static
       option ipaddr   192.168.33.27
       option netmask  255.255.255.0
       option dns      192.168.0.250

OpenWrt Pakete

Kurzanleitung Pakete bauen

Eine erste kurze Anleitung, um auf das vielfälltige OpenWrt Paketarchiv zuzugreifen und darauf iPK Pakete zu erstellen.

  • Sourcen auschecken (liegen dann in openwrt/packages/):
cd openwrt/
svn co svn://svn.openwrt.org/openwrt/packages 
  • Libaries in OpenWrt-Trunk-Baum einbinden (liegt unter openwrt/)
cd ../trunk/package
ln -s ../../packages/libs/* .
  • gewünsches Paket einbinden
ln -s ../packages/<bereich>/<packet> .
cd .

Anschliessend wie gehabt per make menuconfig das Paket auswählen, "M" drücken (Paket erstellen) und anschliessend OpenWrt mit make bauen. Die erstellen Pakete werden nach bin/packages/ abgelegt und automatisch in den Index bin/packages/Packages hinzugefügt.

madwifi mit Ad-Hoc Device

  • iPK Paket kmod-madwifi installieren
  • Wireless-Konfigurationdatei unter /etc/config/wireless bearbeiten, z.B.:
config wifi-device      wifi0
  option type          atheros
  option channel       50
config wifi-iface
  option device        wifi0
  option mode          "adhoc"
  option ssid          "olsr-a.opennet-initiative.de"
config wifi-device      wifi1
  option type          atheros
  option channel       50
config wifi-iface
  option device        wifi1
  option mode          "adhoc"
  option ssid          "olsr-a.opennet-initiative.de"
  • IP-Konfiguration in /etc/config/network anfügen:
config interface wifi0
  option ifname   ath0
  option proto    static
  option ipaddr   192.168.33.27
  option netmask  255.255.0.0
config interface wifi1
  option ifname   ath1
  option proto    static
  option ipaddr   192.168.33.27
  option netmask  255.255.0.0
  • WRAP neu starten

Siehe auch http://madwifi.org/wiki/UserDocs/FirstTimeHowTo

ntpclient zur Zeitsyncronisation

  • iPK Paket ntpclient installieren
  • Konfiguration in /etc/config/ntpclient vornehmen:
config ntpclient
       option hostname 'izumi.on'
       option count    '100'
  • ggf. Datei /etc/init.d/ntpclient anlegen:
#!/bin/sh /etc/rc.common
# Copyright (C) 2006 OpenWrt.org
START=80 
config_cb() {
       local cfg="$CONFIG_SECTION"
       local cfgtype
       config_get cfgtype "$cfg" TYPE
       case "$cfgtype" in
               ntpclient)
                       config_get hostname     $cfg hostname
                       config_get port         $cfg port
                       config_get count        $cfg count
                       ps w | grep 'bin/[n]tpclient' >&- || {
                               while true; do
                                       ping -c 1 $hostname 2>&- >&- && {
                                               /usr/sbin/ntpclient -c ${count:-1} -s -h $hostname -p ${port:-123} 2>&- >&-
                                       } && return
                                       sleep 3
                               done
                       }
               ;;
       esac
}
start() {
       config_load ntpclient&
}
stop() {
       killall ntpclient 2>&- >&-
}
  • diese ausführbar machen per chmod +x ntpclient
  • als Autostart festlegen durch ./ntpclient enable
  • *Hinweis:* Generell wird ntpclient bereits via Hotplug (/etc/hotplug.d/iface/10-ntpclient) beim Hochfahren von Interfaces aufgerufen. Da die notwendigen OLSR-Routen zu diesem Zeitpunkt in der Regel nicht zur Verfügung stehen, setzen wir hier auf ein Init-Skript, was nach dem OLSRd gestartet wird.

monit zur Diensteüberwachung

  • iPK Paket monit installieren
  • Konfigurationsdatei bearbeiten, zur Überwachung von olsrd + dropbear + httpd z.B.
set daemon 120
set logfile syslog facility log_daemon
set httpd port 443
  allow "0.0.0.0/0"
  allow md5 /etc/passwd
  allow admin:admin read-only
  ssl enable
  pemfile "/etc/ssl/certs/monit.pem"
check process olsrd
   with pidfile "/var/run/olsrd.pid"
   start program = "/etc/init.d/olsrd start"
   stop program = "/etc/init.d/olsrd stop"
check process dropbear
   with pidfile "/var/run/dropbear.pid"
   start program = "/etc/init.d/dropbear start"
   stop program = "/etc/init.d/dropbear stop"
   if failed port 22 then restart
check process httpd
   with pidfile "/var/run/httpd.pid"
   start program = "/etc/init.d/httpd start"
   stop program = "/etc/init.d/httpd stop"
   if failed port 80 then restart
  • hierzu noch die Erstellung eines pid-Files in /etc/init.d/olsrd ergänzen
#!/bin/sh /etc/rc.common
BIN=olsrd
DEFAULT=/etc/default/olsrd
RUN_D=/var/run
PID_F=$RUN_D/$BIN.pid
start() {
       [ -f $DEFAULT ] && . $DEFAULT
       # write pid file (but strip out own pid)
       sleep 3
       mkdir -p $RUN_D
       PID=`pidof $BIN`
       echo ${PID%$$} > $PID_F
}
stop() {
       [ -f $PID_F ] && kill $(cat $PID_F)
}
  • monit starten per /etc/init.d/monit start
  • Webzugriff per https://<node-ip>/ und Login mit root+Passwort (Vollzugriff) oder admin/admin (nur Lesezugriff)
  • Consolenzugriff per monit .., z.B. monit status
  • HTTPS Zugriff nach http://www.tildeslash.com/monit/doc/ssl.php

maradns als DNS-Server

  • iPK Paket maradns installieren
  • Konfigurationsdatei /etc/mararc bearbeiten und z.B. für rekursive Namensauflösung über zwei Upstream-Server konfigurieren:
hide_disclaimer="YES"
chroot_dir="/etc/maradns"
bind_address="172.0.0.1""
maradns_uid=65534
maxprocs=10
random_seed_file="/dev/urandom"
recursive_acl="127.0.0.1/8"
upstream_servers = {}
upstream_servers["."] = "192.168.0.250, 192.168.0.254"
verbose_level=3
verbose_query=1
  • maradns starten per /etc/init.d/maradns start, dauerhaft per maradns enable
  • Anfragen per askmara oder wie üblich nslookup & Co.

Watchdog

  • Packet kmod-softdog installieren
  • watchdog starten per /etc/init.d/watchdog start, dauerhaft per watchdog enable

OpenWrt Innereien

Hier gehts ans Eingemachte! Mit Hilfe dieser Anleitung ist es aber alles gar nicht mehr so schwer. Bitte erweitert dieses Kapitel nach belieben.

OpenWrt Imagebuilder

Mit Hilfe des Imagebuilders lassen sich komplette Images aus bereits kompilierten Paketen recht einfach zusammenstellen.

Doku siehe http://wiki.openwrt.org/ImageBuilderHowTo.

Make-Targets

Die Schritte des "make" lassen sich auch in die einzelnen Teilschritte zerlegen und sich ggf. manuell aufrufen. So ist es z.B. notwendig nach grösseren Veränderungen (wie neuer Kernel) ein "clean" auszuführen. Dies kann für den gesamten Verzeichnissbaum erfolgen, oder für Teilbereiche.

Bereinigen eines Bereiches (alle bereits übersetzen Programmteile löschen):

make target/linux-clean
make package/madwifi-clean

Auspacken der Sourcen:

make package/madwifi-prepare

Konfigurieren der Sourcen:

make package/madwifi-configure

Übersetzen der Sourcen:

make package/madwifi-compile

Installieren/Paket erstellen:

make package/madwifi-install

Oder auch komplettes Neubauen eines speziellen Bereiches erzwingen (z.B. nach einem Kernel-Update):

make target/linux-rebuild; make

Paketliste neu erstellen:

make package/index

Patch erstellen

Fehler zu beseitigen oder neue Features in OpenWrt unterzubringen erfolgt über Patch-Dateien. Dabei werden in der Regel die Uptream-Sourcen (Quellen der eigentlichen Softwareprojekte, die in OpenWrt zusammengefasst sind) angepasst. Die Buildroot(-NG) übernimmt diese Ausgabe automatisch, in dem man die speziellen "patch/"-Verzeichnisse nutzt.

Exemplarisch für einen Patch des Linux-Kerns:

  • Anpassung der Sourcen vornehmen und testen
make target/linux-{clean,prepare} 
cd build_i386/
cp -rL linux linux.old 
cp -rL linux linux.dev
<Anpassungen in linux.dev/... vornehmen>
<Anpassungen zum Testen nach linux/... kopieren>
cd ..
make
  • Patchfile erstellen
cd build_i386/
diff -u linux.old/.. linux/... > /<somewhere>/<filename>.patch
Meine Werkzeuge
Namensräume

Varianten
Aktionen
Start
Opennet
Kommunikation
Karten
Werkzeuge