chruetertee.ch

Möchte man herausfinden, zu welchem Port eine installierte Datei gehört, kann dazu pkg_info mit der -W Option benützt werden:

# pkg_info -W pod2latex
/usr/local/bin/pod2latex was installed by package perl-5.8.8_1

Wird die gesuchte Datei nicht in einem Verzeichnis der $PATH Variable gefunden, muss der komplette Pfad zur Datei angegeben werden:

# pkg_info -W xml2Conf.sh
pkg_info: xml2Conf.sh: file is not in PATH
# pkg_info -W /usr/local/etc/xml2Conf.sh
/usr/local/etc/xml2Conf.sh was installed by package libxml2-2.6.30

Benutzer welche portupgrade installiert haben können dazu auch pkg_which verwenden:

Mehr Informationen zu pkg_info findet man in der Manpage pkg_info(1).

Möchte man bei einem make buildworld in /usr/src nur angezeigt bekommen, bei welchem Schritt man gerade ist und welches Modul zur Zeit gebaut wird, kann dazu worldtools verwendet werden. Die worldtools findet man im FreeBSD Portsbaum unter sysutils/worldtools:

# cd /usr/ports/sysutils/worldtools && make install clean

Danach kann die Ausgabe von make buildworld mit einer Pipe an whereintheworld weitergeleitet werden. Im folgenden Beispiel wird eine tcsh verwendet und die komplette Ausgabe von make buildworld findet man in der Datei /tmp/build.log:

# cd /usr/src
# make buildworld |& tee /tmp/build.log | whereintheworld
--------------------------------------------------------------
>>> Rebuilding the temporary build tree                               
--------------------------------------------------------------
>>> stage 1.1: legacy release compatibility shims                     
--------------------------------------------------------------
>>> stage 1.2: bootstrap tools                                        
--------------------------------------------------------------
>>> stage 2.1: cleaning up the object tree                            
--------------------------------------------------------------
>>> stage 2.2: rebuilding the object tree                             
--------------------------------------------------------------
>>> stage 2.3: build tools                                            
--------------------------------------------------------------
>>> stage 3: cross tools                                              
--------------------------------------------------------------
>>> stage 4.1: building includes                                      
--------------------------------------------------------------
>>> stage 4.2: building libraries                                     
--------------------------------------------------------------
=> kerberos5/lib/libasn1 (obj,depend,all,install) 

In der untersten Zeile sieht man, was make buildworld gerade zur Zeit macht. Mehr Informationen zu whereintheworld aus den worldtools findet man in der Manpage whereintheworld(8).

Wurde die /etc/master.passwd gelöscht oder beschädigt, können zum Beispiel keine neue Benutzer mehr angelegt oder die Passwörter der bestehenden Benutzer verändert werden:

# passwd
Changing local password for root
New Password:
Retype New Password:
passwd: /etc/master.passwd: No such file or directory

Mit Hilfe von pwd_unmkdb kann nun die master.passwd aus der /etc/spwd.db generiert werden. pwd_unmkdb findet man im FreeBSD Portsbaum unter sysutils/pwd_unmkdb:

# cd /usr/ports/sysutils/pwd_unmkdb && make install clean

Nun kann ins /etc Verzeichnis gewechselt werden und die master.passwd wiederhergestellt werden:

# cd /etc && pwd_unmkdb
dbopen()'ing spwd.db...  Done
fopen()'ing master.passwd...  Done
Looping through the records in spwd.db...  Done

Mehr Informationen zu pwd_unmkdb findet man in der Manpage pwd_unmkdb(8), Informationen zur master.passwd in passwd(5).

Auf FreeBSD gibt es die Möglichkeit, innerhalb einer Jail das ZFS Dateisystem zu administrieren. Dazu muss auf dem Hostsystem ZFS aktiviert werden:

# echo 'zfs_enable="YES"' >> /etc/rc.conf 
# /etc/rc.d/zfs start

Nachdem man eine FreeBSD Jail erstellt hat, muss sichergestellt werden, dass die Jail auch auf /dev/zfs zugreifen kann. Dazu kann in der /etc/devfs.rules folgender Eintrag eingefügt werden:

[zfs=10]
add include $devfsrules_hide_all
add include $devfsrules_unhide_basic
add include $devfsrules_unhide_login
add path 'zfs' unhide

Nun müssen bei den Jail-Einträgen der /etc/rc.conf folgende Einträge hinzugefügt werden:

jail_<Jailname>_devfs_enable="YES"
jail_<Jailname>_devfs_ruleset="zfs"

Damit innerhalb der Jail ZFS Dateisysteme gemountet werden können, muss die security.jail.mount_allowed auf 1 gesetzt werden. Durch das Setzen von security.jail.enforce_statfs auf 0 werden alle gemounteten Dateisysteme des Hostsystemes in der Jail sichtbar. Das Setzen beider Werte wird für das Verwenden von ZFS innerhalb einer Jail benötigt, können jedoch die Sicherheit des Systemes heruntersetzen.

# sysctl security.jail.mount_allowed=1
# sysctl security.jail.enforce_statfs=0
# echo security.jail.mount_allowed=1 >> /etc/sysctl.conf
# echo security.jail.enforce_statfs=0 >> /etc/sysctl.conf 

Danach kann ein ZFS-Pool erstellt werden. In folgendem Beispiel wird der ZFS-Pool /tank aus /dev/ad0s1e erstellt:

# zpool create tank /dev/ad0s1e
WARNING: ZFS is considered to be an experimental feature in FreeBSD.
ZFS filesystem version 6
ZFS storage pool version 6

Nun wird das ZFS-Dateisystem erstellt, welches man danach der Jail zur Verfügung stellt.

# zfs create tank/jail
# zfs set jailed=on tank/jail

Damit das ZFS-Dateisystem der Jail zugewiesen werden kann, muss die Jail-ID der Jail mit jls(8) herausgefunden werden:

# jls
  JID  IP Address  Hostname     Path
    1  <IP>        <Jail-Name>  <Pfad zur Jail>

Nun wird tank/jail der Jail mit der ID 1 zugewiesen:

# zfs jail 1 tank/jail

Danach kann das ZFS Dateisystem innerhalb der Jail administriert werden. Im folgenden Beispiel wird innerhalb der Jail das ZFS-Dateisystem tank/jail/beat erstellt und nach /home/beat gemountet:

jail# zfs create tank/jail/beat
jail# zfs set mountpoint=/home/beat tank/jail/beat

Startet man das Hostsystem neu, wird im Moment das ZFS-Dateisystem nicht automatisch wieder der Jail zugewiesen. Dazu muss die Jail-ID der Jail wieder mit jls bestimmt werden:

# zfs jail <JID> tank/jail

Nun können die ZFS-Dateisysteme innerhalb der Jail gemountet werden.

jail# zfs mount -a

Mehr Informationen zu ZFS findet man in der Manpage zfs(8). Eine kleine Einführung in ZFS auf FreeBSD findet man hier: http://www.chruetertee.ch/blog/archive/2007/05/26/zfs-auf-freebsd.html

Möchte man auf FreeBSD eine Partition verschlüsseln, kann man dazu GELI verwenden. Im folgenden Beispiel wird die Partition ad0s1f verschlüsselt und nach /home/beat gemountet.

Damit das GELI-Kernelmodul beim Starten des Systems geladen wird, muss folgender Eintrag in der /boot/loader.conf gemacht werden:

# echo 'geom_eli_load="YES"' >> /boot/loader.conf

Nun kann ein Schlüssel generiert werden, welcher zum Verschlüsseln der Partition benötigt wird. Der Schlüssel sollte dabei an einem Ort gespeichert werden, an welchem er nicht einfach überschrieben oder gelöscht werden kann. Gegebenenfalls kann der Schlüssel auch auf einem USB-Stick gespeichert werden, so dass man zum Einhängen der verschlüsselten Partition neben einem Passwort auch den USB-Stick besitzen muss. In diesem Fall kann die Partition allerdings nicht ohne Weiteres während des Bootens gemountet werden. Im folgenden Beispiel wird der Schlüssel unter /root gespeichert:

# dd if=/dev/random of=/root/ad0s1f.key bs=64 count=1

Danach wird die verschlüsselte Partition initiiert, dabei muss man ein Passwort festlegen:

# geli init -s 4096 -K /root/ad0s1f.key /dev/ad0s1f
Enter new passphrase:
Reenter new passphrase:

Nun wird die Partition ins System eingebunden, dabei muss man das vorher bestimmte Passwort eingeben:

# geli attach -k /root/ad0s1f.key /dev/ad0s1f
Enter passphrase:

Jetzt wird die neue Partition mit Zufallswerten überschrieben, das kann eine Zeit dauern:

# dd if=/dev/random of=/dev/ad0s1f.eli bs=1m

Danach wird ein neues Dateisystem auf der verschlüsselten Partition erstellt und diese das erste Mal ins System gemountet:

# newfs /dev/ad0s1f.eli
# mount /dev/ad0s1f.eli /home/beat

Die verschlüsselte Partition kann danach wie folgt geunmountet werden:

# umount /home/beat
# geli detach ad0s1f.eli

Soll die Partition automatisch beim Systemstart gemountet werden, müssen folgende Einträge in der /etc/rc.conf gemacht werden:

geli_devices="ad0s1f"
geli_ad0s1f_flags="-k /root/ad0s1f.key"

Jetzt noch den entsprechenden Eintrag in der /etc/fstab machen:

/dev/ad0s1f.eli         /home/beat              ufs             rw      0       0

Startet man nun das System neu, wird man automatisch nach dem Passwort gefragt und die verschlüsselte Partition wird gemountet.

Mehr Informationen zu verschlüsselten Partitionen mit GELI findet man in der Manpage geli(8). Wie man den Swap-Bereich mit GELI verschlüsselt, findet man in folgender Anleitung: http://www.chruetertee.ch/blog/archive/2007/06/30/swap-verschluesseln.html

Möchte man einen PPTP-VPN-Server zum Beispiel für Windows-Clients einrichten, kann man dazu poptop verwenden. Zuerst muss sichergestellt werden, dass der Kernel des Systems mit Tunnelsupport gebaut ist. Dies ist beim GENERIC-Kernel der Fall:

# grep tun /usr/src/sys/i386/conf/<KERNELCONFIGURATION>
device          tun             # Packet tunnel.

Nun muss noch das Weiterleiten von Paketen auf dem System aktiviert werden:

# sysctl net.inet.ip.forwarding=1
# echo 'gateway_enable="YES"' >> /etc/rc.conf

Danach kann poptop aus dem Portsbaum installiert werden:

# cd /usr/ports/net/poptop && make install clean

Nun kann die /usr/local/etc/pptpd.conf erstellt werden. Bei der localip ist die IP-Adresse einzutragen, welche der PPTP Server kriegt, bei der remoteip sind die IP-Adressen einzutragen, welche an die Clients verteilt werden:

debug
localip 192.168.0.1
remoteip 192.168.0.100-120

Danach können folgende Einträge in der /etc/ppp/ppp.conf gemacht werden. Bei set ifaddr wird zuerst die IP-Adresse des Servers und danach der Range der Clients angegeben:

pptp:
  set dial
  set login
  set ifaddr 192.168.0.1 192.168.0.100-120 255.255.255.255
  set log phase lcp ipcp command
  set timeout 1800
  enable chap
  enable pap
  enable mschap
  enable mschapv2
  enable proxy
  enable mssfixup
  accept dns
  set dns <IP des DNS Servers>

Nun wird noch eine /etc/ppp/options mit folgendem Inhalt erstellt:

debug
proxyarp
+MSChap-V2 mppe-128 mppe-stateless

In der /etc/ppp/ppp.secret werden nun die VPN-Benutzer und deren Passwörter konfiguriert:

<Benutzername 1> <Passwort> *
<Benutzername 2> <Passwort> *
...

Da die Passwörter im Klartext gespeichert werden, werden nun noch die richtigen Rechte auf der Datei gesetzt:

# chmod 600 /etc/ppp/ppp.secret

Nun wird noch der pptpd und ARP-Proxy in der /etc/rc.conf aktiviert:

# echo 'pptpd_enable="YES"' >> /etc/rc.conf
# echo 'arpproxy_all="YES"' >> /etc/rc.conf

Danach kann der pptpd gestartet werden:

# /usr/local/etc/rc.d/pptpd start

Verwendet man die pf Firewall, müssen noch die benötigten Ports für PPTP freigeschaltet werden. Das NAT für die Clients kann gleich aktiviert werden. Folgende Regeln in die bestehende /etc/pf.conf an der richtigen Stelle einfügen:

ext_if="<Externe Netzwerkschnittstelle>"

set skip on tun0

nat on $ext_if from 192.168.0.0/24 to any -> ($ext_if)

pass in on $ext_if proto gre keep state
pass in on $ext_if proto tcp from any to any port 1723 keep state

Mehr Informationen zum pptpd findet man in der Manpage pptpd(8).

Möchte man die gesetzten Variablen in /usr/ports/Mk/bsd.port.mk einfach auslesen, so kann das Skript portsvar.sh unter /usr/ports/Tools/scripts/ genutzt werden. Einfach die gewünschten Variablen an portsvar.sh übergeben:

# /usr/ports/Tools/scripts/portsvar.sh PORTSDIR OSVERSION
PORTSDIR = /usr/ports
OSVERSION = 602000

Auch Regex lassen sich mit Hilfe der -e Option in portsvar.sh bei der Suche nach Variablen verwenden.

# /usr/ports/Tools/scripts/portsvar.sh -e "PKG[M,D].*"
PKGDEINSTALL = ${PKGDIR}/pkg-deinstall
PKGDIR = ${MASTERDIR}
PKGMESSAGE = ${PKGDIR}/pkg-message

Standardmässig wird nur in bsd.port.mk nach Variablen gesucht. Möchte man ein anderes Makefile unter /usr/ports/Mk/ in die Suche mit aufnehmen, kann dies mit der -w Option gemacht werden. In den folgenden Beispielen wird die Standardversion vom Apache, PHP und PostgeSQL aus dem jeweiligen Makefile ausgelesen:

# /usr/ports/Tools/scripts/portsvar.sh -w apache -e "APACHE_[P,S].*"
APACHE_PORT = www/apache13
APACHE_SUPPORTED_VERSION = 13 20 21 22
# /usr/ports/Tools/scripts/portsvar.sh -w php -e "PHP_VER.*"
PHP_VER = 5
PHP_VERSION = 5.2.5
# /usr/ports/Tools/scripts/portsvar.sh -w database -e "DEFAULT_PGSQL.*"
DEFAULT_PGSQL_VER = 81

Alle Optionen von portsvar.sh erhält man mit der -h Option.

Auf einem Server mit einem Smart Array RAID Controller werden Änderungen am Status eines Logical Drives von FreeBSD nach /var/log/messages geschrieben. Folgendes Beispiel zeigt die Ausgabe in /var/log/messages bei einem Diskwechsel:

kernel: ciss0: *** Hot-plug drive removed: SCSI port 1 ID 0
kernel: ciss0: *** Physical drive failure: SCSI port 1 ID 0
kernel: ciss0: *** State change, logical drive 0
kernel: ciss0: logical drive 0 (pass0) changed status OK->interim recovery, spare status 0x0
...
kernel: ciss0: *** Hot-plug drive inserted: SCSI port 1 ID 0
kernel: ciss0: *** State change, logical drive 0
kernel: ciss0: logical drive 0 (pass0) changed status interim recovery->ready for recovery, spare status 0x0
kernel: ciss0: *** State change, logical drive 0
kernel: ciss0: logical drive 0 (pass0) changed status ready for recovery->recovering, spare status 0x0
...
kernel: ciss0: *** State change, logical drive 0
kernel: ciss0: logical drive 0 (pass0) changed status recovering->OK, spare status 0x0

Möchte man sich den aktuellen Status anzeigen lassen, ohne /var/log/messages auf die letzte Änderung durchsuchen zu müssen, kann man den Port sysutils/cciss_vol_status installieren. Damit cciss_vol_status kompiliert werden kann, müssen die Kernel-Sourcen auf dem System vorhanden sein:

# cd /usr/ports/sysutils/cciss_vol_status && make install clean

Nun kann der Status des Smart Array Controllers abgefragt werden:

# cciss_vol_status /dev/ciss0
/dev/ciss0: (Smart Array 5i) RAID 1 Volume 0 status: OK.

Mehr Informationen zu cciss_vol_status und eine Beschreibung aller möglichen Status findet man in der Manpage cciss_vol_status(8).

Möchte man eine FreeBSD Jail erstellen, aber nicht wie normalerweise die Jail mit einem make world in /usr/src kompilieren, so kann eine Jail auch mit dem Base-Distributions-Set der FreeBSD Installations CD erstellt werden. Falls für das CD-ROM Laufwerk einen entsprechender Eintrag in der /etc/fstab besteht, kann die Installations CD wie folgt gemountet werden:

# mount /cdrom

Danach kann ins Verzeichnis mit dem Base-Distribution-Set gewechselt werden. In diesem Beispiel wird die FreeBSD 7.0-BETA4 Installations CD verwendet:

# cd /cdrom/7.0-BEAT4/base

Jetzt kann mit der DESTDIR Variable der Pfad gesetzt werden, wo die Jail installiert werden soll. Zum Beispiel in der (t)csh:

# setenv DESTDIR /usr/jail/

Nun wird die Installation gestartet. Dazu muss die Kontrollfrage mit y beantwortet werden:

# ./install.sh
You are about to extract the base distribution into /usr/jail/ -
are you SURE you want to do this over your installed system (y/n) y

Nun kann die Jail ganz normal fertig konfiguriert werden. Dazu muss zuerst das devfs in die Jail gemoutet werden:

# mount -t devfs devfs /usr/jail/dev

Als Nächstes muss man ein Alias mit der Jail-IP Adresse konfigurieren:

# ifconfig <Netzwerkkarte> alias <Jail IP>/32

Danach kann die Jail das erste Mal gestartet werden:

# jail /usr/jail <Jail Hostnamen> <Jail IP> /bin/sh

Jetzt müssen noch einige Konfigurationen in der Jail vorgenommen werden:

# touch /etc/fstab
# echo 'rpcbind_enable="NO"' >> /etc/rc.conf
# echo 'network_interfaces=""' >> /etc/rc.conf
# echo 'sshd_enable="YES"' >> /etc/rc.conf
# echo 'nameserver <DNS Server IP>' >> /etc/resolv.conf
# newaliases

Danach kann noch das root-Passwort, die Zeitzone konfiguriert und Benutzer und Gruppen angelegt werden. Hat man die Jail fertig konfiguriert, verlässt man die Jail:

# exit

Als Letztes wird die Jail vollständig gestartet:

# jail /usr/jail <Jail Hostnamen> <Jail IP> /bin/sh /etc/rc

Soll die Jail bei einem Neustart automatisch gestartet werden, müssen noch die entsprechenden Einträge in der /etc/rc.conf gemacht werden. Mehr Informationen zu den Jails findet man in der Manpage jail(8).

Auf FreeBSD können mit stat verschiedene Details einer Datei ausgelesen werden. So kann zum Beispiel ausgelesen werden, wann zum letzten Mal auf die Datei zugegriffen wurde und wann diese zum letzten Mal verändert wurde. Auch lässt sich auslesen, wann der Inode zur Datei alloziert und wann das letzte Mal verändert wurde. Im folgenden Beispiel wird eine neue Datei erstellt und anschliessend die Zeiten der Datei ausgelesen. Dabei wird die Zeit angezeigt, wann der Inode zut Datei alloziert (birth) wurde:

# echo test > testdatei
# stat -f "birth: %SB  change: %Sc  modify: %Sm  access: %Sa" testdatei
birth: Dec 15 14:30:22 2007  change: Dec 15 14:30:22 2007  modify: Dec 15 14:30:22 2007  access: Dec 15 14:30:22 2007

Wird nun die Datei verändert, wird die Modifikationszeit der Inodes (change) und die Modifikationzeit der Datei (modify) geändert:

# echo test2 >> testdatei
# stat -f "birth: %SB  change: %Sc  modify: %Sm  access: %Sa" testdatei
birth: Dec 15 14:30:22 2007  change: Dec 15 14:30:44 2007  modify: Dec 15 14:30:44 2007  access: Dec 15 14:30:22 2007

Werden nun die Dateirechte verändert, so wird nur die Modifikationszeit des Inodes (change) verändert:

# chmod 600 testdatei
# stat -f "birth: %SB  change: %Sc  modify: %Sm  access: %Sa" testdatei
birth: Dec 15 14:30:22 2007  change: Dec 15 14:31:05 2007  modify: Dec 15 14:30:44 2007  access: Dec 15 14:30:22 2007

Wird nun die Datei ausgelesen, so wird die Zugriffszeit (access) verändert:

# cat testdatei
test
test2
# stat -f "birth: %SB  change: %Sc  modify: %Sm  access: %Sa" testdatei
birth: Dec 15 14:30:22 2007  change: Dec 15 14:31:05 2007  modify: Dec 15 14:30:44 2007  access: Dec 15 14:31:23 2007

Alle Möglichkeiten und Optionen von stat findet man in der Manpage stat(1).