% $Id$
\chapter{Werkzeugkasten}\label{werkzeugkasten}

Durch die gezeigten Steuerungsmöglichkeiten stehen dem Shell-Pro\-grammie\-rer
Mög\-lich\-kei\-ten offen, fast alle gängigen Algorithmen zu implementieren. Es
ist tatsächlich in der Shell möglich, Sortier- oder Suchfunktionen zu
schreiben.  Leider kommt aber an dieser Stelle einer der bedeutendsten
Nachteile der Shell zum tragen: Die Geschwindigkeit.

In einem Shell-Skript wird für jedes externe Kommando\footnote{Externe
Kommandos sind solche, die nicht direkt in der Shell enthalten sind, für die
also eine eigene Datei aufgerufen wird.} ein eigener Prozeß gestartet. Das
kostet natürlich Zeit und Speicher.

Zeitkritische Anwendungen sind also kein Einsatzgebiet für Shell-Skripte. Die
schreibt man besser in Perl, oder noch besser in einer `compilierten' Sprache
wie C oder C++.

Es stehen jedoch an der Shell viele sehr nützliche externe Kommandos zur
Ver\-fü\-gung, die einem die Entwicklung entsprechender eigener Routinen
ersparen.  Diese externen Kommandos sind zudem in anderen Sprachen geschrieben
worden, so daß sie schneller ablaufen als jedes Shell-Skript. Man kommt als
Shell-Programmierer nicht sinnvoll um den Einsatz dieser Programme herum.

In diesem Abschnitt sollen einige dieser Programme mit typischen
Einsatzmöglichkeiten vorgestellt werden. Eine vollständige Beschreibung wäre
(wenn überhaupt möglich) viel zu lang, um an dieser Stelle untergebracht zu
werden. \textbf{Dies ist also nur ein grober Überblick, nicht mal annähernd
eine vollständige Referenz!} Für ausführlichere Beschreibungen empfiehlt sich
das Studium der Man-Pages oder der Kauf eines entsprechenden Buches (Siehe
Anhang \ref{quellen}, `Quellen'). Am besten macht man natürlich beides. ;-)

Eine globale Beschreibung aller gängigen Kommandos würde den Rahmen dieses
Textes sprengen. Außerdem wäre es nicht leicht, das zu einer Aufgabe passende
Werkzeug zu finden. Die Werkzeuge nach Aufgaben zu sortieren fällt allerdings
auch nicht leicht. Die Entwickler der Kommandos versuchen, ihre Tools möglichst
universell einsetzbar zu halten, also gibt es keine 1:1-Beziehung zwischen
Problem und Lösung.

Um sowohl das Finden eines Werkzeugs zu einem gegebenen Problem als auch das
Finden einer Beschreibung zu einem gegebenen Werkzeug zu vereinfachen, und um
die oben beschriebene n:m-Beziehung abzubilden, werden hier also zunächst
typische Aufgaben beschrieben. Diese enthalten `Links' zu den in Frage
kommenden Werkzeugen. Danach gibt es eine alphabetische Aufzählung der
wichtigsten Kommandos.

Das GNU-Projekt\marginpar{GNU!} hat vielen Kommandos nützliche Parameter
zugefügt, einige der hier beschriebenen Tools stehen ausschließlich auf
GNU-Systemen zur Verfügung. Da diese Optionen nicht auf allen Unix-Systemen zur
Verfügung stehen, werden die betroffenen Stellen wie dieser Absatz am Rand mit
`GNU!' markiert. Wenn diese Kommandos und Optionen benutzt werden muß also das
Zielsystem berücksichtigt werden, im Zweifelsfall sollten die Skripte
ausführlich getestet werden.

\section{Nägel...}\label{naegel}

\subsection{Ein- und Ausgabe}\label{ein_und_ausgabe}

Praktisch jedes Skript verwendet in irgendeiner Form die Ein- oder Ausgabe. Sei
es in interaktiver Art auf dem Terminal, oder im Hintergrund auf Dateien.

An dieser Stelle sei darauf hingewiesen, daß es auf unixoiden Systemen nicht
nur Dateien im Sinne von `ein paar Kilobytes Daten, die irgendwo auf der
Festplatte rumliegen' gibt. Vielmehr findet man hier die Geräte des Rechners
als Dateien unter /dev. Der Kernel selbst stellt Schnittstellen in Form von
virtuellen Dateien unter /proc (ab Kernel 2.6 auch unter /sys) zur Verfügung.
Und Schlußendlich können Prozesse sich sogenannte Named Pipes\index{Named Pipe}
anlegen, in die sie schreiben oder aus denen sie lesen.

Diese Kommandos sind also universell nützlich, nicht nur im Zusammenhang mit
Dateien auf der Festplatte.

\begin{itemize}
\item \texttt{cat} (\ref{cat}): Dateien einlesen und ausgeben
\item \texttt{echo} (\ref{echo}): Daten ausgeben
\item \texttt{grep} (\ref{grep}): In Dateien suchen
\item \texttt{head} (\ref{head}): Dateianfang ausgeben
\item \texttt{logger} (\ref{logger}): Text ins System-Log schreiben
\item \texttt{printf} (\ref{printf}): Formatierte Datenausgabe
\item \texttt{read} (\ref{read}): Zeilen einlesen
\item \texttt{tail} (\ref{tail}): Dateiende ausgeben
\end{itemize}


\subsection{Dateiinhalte bearbeiten}\label{dateiinhalte}

Natürlich bietet die Shell eine Reihe von Befehlen, um die Inhalte von Dateien
zu bearbeiten. Diese Auflistung ist in weiten Teilen deckungsgleich mit der
Liste der Tools zur Manipulation von Pipes, auch diese Kommandos kommen also
in mehreren Situationen zum Einsatz.

\begin{itemize}
\item \texttt{awk} (\ref{awk}): In einer Pipe editieren
\item \texttt{cmp} (\ref{cmp}): Binäre Dateien vergleichen
\item \texttt{cut} (\ref{cut}): Teile einer Zeile ausschneiden
\item \texttt{diff} (\ref{diff}): Textdateien vergleichen
\item \texttt{paste} (\ref{paste}): Dateien zusammenführen
\item \texttt{sed} (\ref{sed}): In einer Pipe editieren
\item \texttt{sort} (\ref{sort}): Zeilenweises Sortieren
\item \texttt{tr} (\ref{tr}): Zeichen ersetzen
\item \texttt{uniq} (\ref{uniq}): Doppelte Zeilen suchen
\end{itemize}


\subsection{Pfade und Dateien}\label{pfade_und_dateien}

Eine der Hauptaufgaben von Shell-Skripten ist natürlich das Hantieren mit
Dateien. In diesem Abschnitt geht es allerdings nicht um den Umgang mit
Dateiinhalten, sondern vielmehr werden einige nützliche Tools im Umgang mit
Dateien an sich vorgestellt.

Auch hier gilt natürlich der Hinweis aus Abschnitt \ref{ein_und_ausgabe}: Eine
Datei kann viel mehr sein als nur ein paar Daten im Filesystem.

\begin{itemize}
\item \texttt{basename} (\ref{basename}): Den Namen einer Datei (ohne Pfad) ausgeben
\item \texttt{cd} (\ref{cd}): Verzeichnis wechseln
\item \texttt{cp} (\ref{cp}): Dateien kopieren
\item \texttt{chgrp} (\ref{chgrp}): Gruppen-ID einer Datei ändern
\item \texttt{chmod} (\ref{chmod}): Zugriffsrechte einer Datei ändern
\item \texttt{chown} (\ref{chown}): Eigentümer einer Datei ändern
\item \texttt{cmp} (\ref{cmp}): Binäre Dateien vergleichen
\item \texttt{dirname} (\ref{dirname}): Den Pfad zu einer Datei (ohne den Namen) ausgeben
\item \texttt{find} (\ref{find}): Dateien suchen
\item \texttt{mkdir} (\ref{mkdir}): Verzeichnisse anlegen
\item \texttt{mv} (\ref{mv}): Dateien verschieben
\item \texttt{rm} (\ref{rm}): Dateien löschen
\item \texttt{rmdir} (\ref{rmdir}): Verzeichnisse löschen
\item \texttt{touch} (\ref{touch}): Eine leere Datei anlegen, bzw. das Zugriffsdatum einer Datei ändern
\item \texttt{which} (\ref{which}): Ausführbare Dateien suchen
\item \texttt{xargs} (\ref{xargs}): Ausgaben eines Kommandos als Parameter eines anderen Kommandos benutzen
\end{itemize}


\subsection{Pipes manipulieren}\label{pipes_manipulieren}\index{Pipe|(textbf}

Das Konzept der Pipes (Röhren) wird bereits in dem Kapitel über Befehlsformen
(\ref{befehlsformen}) vorgestellt. Im wesentlichen besteht es darin, daß Daten
von einem Programm an ein anderes weitergeleitet werden. Auf diese Weise
entsteht eine sogenannte \textit{Pipeline}\index{Pipeline} aus mehreren
Kommandos. Einige Kommandos sind für den Einsatz in einem solchen Konstrukt
prädestiniert, obwohl die meisten auch alleine eingesetzt werden können.

Übrigens gibt es einen goldenen Merksatz für die Auswahl einiger dieser Tools:

Benutze nicht \texttt{awk}, wenn Du \texttt{sed} benutzen kannst. Benutze
nicht \texttt{sed}, wenn Du \texttt{grep} benutzen kannst. Benutze nicht
\texttt{grep}, wenn Du \texttt{cut} benutzen kannst.

Der Grund dafür liegt darin, daß diese Programme bei jedem Einsatz gestartet
und ausgeführt werden müssen. Und man sollte sich um der Performance willen den
kleinsten geeigneten Hammer nehmen.

\begin{itemize}
\item \texttt{awk} (\ref{awk}): In einer Pipe editieren
\item \texttt{cut} (\ref{cut}): Teile einer Zeile ausschneiden
\item \texttt{grep} (\ref{grep}): In einer Pipe suchen
\item \texttt{sed} (\ref{sed}): In einer Pipe editieren
\item \texttt{sort} (\ref{sort}): Zeilenweises Sortieren
\item \texttt{tee} (\ref{tee}): Datenstrom in einer Datei protokollieren
\item \texttt{tr} (\ref{tr}): Zeichen ersetzen
\item \texttt{uniq} (\ref{uniq}): Doppelte Zeilen suchen
\item \texttt{wc} (\ref{wc}): Zeilen, Wörter oder Zeichen zählen
\end{itemize}

\index{Pipe|)}


\subsection{Prozeßmanagement}\label{prozessmanagement}

Oft werden Shell-Skripte benutzt um Prozesse zu steuern oder zu überwachen. So
werden Systemdienste üblicherweise über die Init-Skripte hoch- oder
heruntergefahren. Es ist auch nicht sonderlich schwer, mit einem Skript einen
`Wachhund' zu implementieren, der regelmäßig kontrolliert ob ein Prozeß noch
läuft und ihn bei bedarf nachstartet.

Für Aufgaben in diesem Bereich stehen unter anderem die folgenden Kommandos zur
Verfügung.

\begin{itemize}
\item \texttt{kill} (\ref{kill}): Signal an einen Prozeß schicken
\item \texttt{killall} (\ref{killall}): Signal an mehrere Prozesse schicken
\item \texttt{ps} (\ref{ps}): Prozeßliste ausgeben
\item \texttt{pgrep} (\ref{pgrep}): Bestimmte Prozesse suchen
\item \texttt{pkill} (\ref{pkill}): Bestimmte Prozesse töten
\item \texttt{trap} (\ref{trap}): Auf Signale reagieren
\end{itemize}


\section{... und Hämmer}\label{haemmer}

Um es noch einmal zu betonen: \textbf{Dies ist keine vollständige
Kommandoreferenz!} Es werden nur die wichtigsten Kommandos vorgestellt, und
deren Funktion wird in den meisten Fällen auch nur kurz angerissen. Für
ausgiebigere Informationen empfehle ich entsprechende Bücher (siehe Anhang
\ref{quellen}, `Quellen') und vor allem die Man-Pages.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{awk}\label{awk}\index{awk=\texttt{awk}|(textbf}

Über die Skriptsprache \texttt{awk} wurden schon ganze Bücher geschrieben, eine
vollständige Beschreibung würde den Rahmen dieses Dokumentes bei weitem
sprengen. Hier werden nur ein paar grundlegende Techniken beschrieben, die
häufig im Zusammenhang mit Shell-Skripten auftauchen.

Oben wurde \texttt{awk} `Skriptsprache' genannt. Das ist insofern richtig, als
daß es eine mächtige und komplexe Syntax zur Verfügung stellt, um Texte
automatisiert zu bearbeiten. Es fällt somit in die gleiche Tool-Kategorie wie
\texttt{sed} (Abschnitt \ref{sed}).

Es unterscheidet sich aber in seinen grundlegenden Prinzipien entscheidend von
den meisten anderen Programmiersprachen: \texttt{awk} arbeitet `Datenbasiert'.
Das bedeutet, daß zunächst die Daten spezifiziert werden mit denen gearbeitet
werden soll, dann folgen die auszuführenden Kommandos. Das Prinzip wird schnell
klar, wenn man sich einige der Beispiele weiter unten ansieht.

\subsubsection{Aufruf}

Auch der Aufruf erfolgt analog zu \texttt{sed}: Bei einfachen Aufgaben kann das
\texttt{awk}-Programm direkt an der Kommandozeile mitgegeben werden, komplexere
Programme werden in Dateien gespeichert und von dort gelesen.

Eine weitere Gemeinsamkeit ist die Art der Ein- und Ausgabe. Wenn eine
Eingabedatei angegeben wird, wird diese verarbeitet. Ansonsten wird die
Standard-Eingabe gelesen. Ausgaben erfolgen immer auf der Standard-Ausgabe.

\begin{lstlisting}
# Aufruf als Filter:
kommando1 | awk '{ print $1; print $2 }' | kommando2

# Aufruf mit einer zu bearbeitenden Datei:
awk '{ print $1; print $2 }' datei.txt

# In einem Skript kann das Kommando auch über mehrere Zeilen gehen:
awk '
{
  print $1;
  print $2;
}' datei.txt

# Alternativ können die Kommandos auch in eine eigene Datei gespeichert und
# über den Parameter -f eingebunden werden:
awk -f script.awk datei.txt
\end{lstlisting}

Neben dem Parameter \texttt{-f} zum Einlesen der Programmdatei gibt es noch den
Parameter \texttt{-F} mit dem der Feld-Trenner angegeben werden kann. Die
folgende Zeile gibt beispielsweise alle Benutzernamen und deren User-IDs aus
der Doppelpunktseparierten Datei \texttt{/etc/passwd} aus:

\lstinline|awk -F: '{ print $1" hat ID "$3 }' /etc/passwd|

\subsubsection{Muster und Prozeduren}

Die Skripte für \texttt{awk} bestehen aus Blöcken von Mustern und Prozeduren.
Ein Block hat den folgenden Aufbau:

\textsl{muster}\texttt{ \{ }\textsl{prozedur}\texttt{ \}}

Dabei sind beide Bestandteile des Blockes Optional: Wird das Muster
weggelassen, wird die Prozedur auf alle Textbestandteile angewandt. Und wird
keine Prozedur angegeben, wird der betroffene Text einfach ausgegeben.

Das Muster kann dabei auf verschiedene Weise angegeben werden:
\begin{itemize}
\item Als regulärer Ausdruck (siehe Abschnitt \ref{mustererkennung}),
eingebettet in Slashes: \texttt{/}\textsl{muster}\texttt{/}
\item Als relationaler Ausdruck, bei dem bestimmte Kriterien auf die
Eingabedaten zutreffen müssen. Mit \texttt{\$2>\$1} werden beispielsweise
Zeilen angesprochen, deren zweites Feld einen größeren Wert hat als das erste.
\item Mit Operatoren für das Pattern-Matching, ähnlich wie in Perl (\texttt{\~}
oder \texttt{!\~})
\item \texttt{BEGIN} kennzeichnet Prozeduren, die vor der Bearbeitung anderer
Blöcke zum Tragen kommen sollen.
\item Analog dazu gibt es ein \texttt{END}, mit dem abschließende Aktionen
gekennzeichnet werden.
\end{itemize}

Abgesehen von \texttt{BEGIN} und \texttt{END} können die Muster auch durch
logische Operatoren (\texttt{\&\&}, \texttt{||} oder \texttt{!}) kombiniert
werden. Durch Komma getrennt besteht die Möglichkeit, Wirkungsbereiche zu
definieren.

Die Prozeduren können Variablen- oder Array-Zuweisungen, Ausgabeanweisungen,
Funktionsaufrufe oder Kontrollstrukturen enthalten.

\subsubsection{Variablen}

Es gibt in \texttt{awk} eine Reihe eingebauter Variablen, die in Mustern oder
Prozeduren verwendet werden können:

\LTXtable{\textwidth}{tab_kommandos_awk_variablen.tex}

Eigene Variablen können nach Belieben verwendet werden, siehe dazu das Beispiel
mit den TeX-Dateien weiter unten.

\subsubsection{Beispiele}

Hier ein paar Einfache Beispiele für Blocks aus Mustern und Prozeduren:

\begin{lstlisting}
# Das erste Feld jeder Zeile ausgeben:
{ print $1 }

# Alle Zeilen ausgeben, die 'regexp' enthalten:
/regexp/

# Das erste Feld jeder Zeile ausgeben, die 'regexp' enthält:
/regexp/ { print $1 }

# Datensätze mit mehr als zwei Feldern auswählen:
NF > 2

# Das dritte und das zweite Feld jeder Zeile ausgeben, deren erstes Feld den
# String 'WICHTIG' enthält:
$1 ~ /WICHTIG/ { print $3, $2 }

# Die Vorkommen von 'muster' zählen, und deren Anzahl ausgeben:
/muster/ { ++x }
END { print x }

# Alle Zeilen mit weniger als 23 Zeichen ausgeben:
length($0) < 23

# Alle Zeilen ausgeben, die mit 'Name:' anfangen und exakt sieben Felder
# enthalten:
NF == 7 && /^Name:/

# Alle Felder der Eingabedaten zeilenweise in umgekehrter Reihenfolge ausgeben:
{
  for (i = NF; i >= 1; i--)
    print $i
}

# Die Größe aller TeX-Dateien addieren, die Summe in kB umrechnen und ausgeben,
# verarbeitet die Ausgabe von 'ls -l':
/.*tex/ { summe += $5 }
END { summe /= 1024; print "Die Größe aller TeX-Files beträgt", summe, "kB" }

# Pipe-Separierte Liste aller gemounteten Partitionen und derer Füllstände
# ausgeben, verarbeitet die Ausgabe von 'df':
BEGIN { OFS="|" }
/^\/dev\// { print $1,$5 }

# Alle Hosts aus der /etc/hosts anpingen, muß mit der /etc/hosts als
# Eingabedatei aufgerufen werden:
/^[^#]/ { system("ping -c 1 "$1) }
\end{lstlisting}

\index{awk=\texttt{awk}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{basename}\label{basename}\index{basename=\texttt{basename}|(textbf}

Dem Tool \texttt{basename} wird als Parameter ein Pfad zu einer Datei
übergeben. Der in der Angabe enthaltene Pfad wird abgeschnitten, nur der Name
der eigentlichen Datei wird zurückgegeben. Siehe auch \texttt{dirname}
(\ref{dirname}).

\index{basename=\texttt{basename}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{bc}\label{bc}\index{bc=\texttt{bc}|(textbf}

Bei \texttt{bc} handelt es sich, ähnlich wie bei \texttt{expr} um einen
Taschenrechner. Allerdings verfügt dieses Kommando um eine vergleichsweise
komplexe Syntax, die auch Berechnungen mit hoher Genauigkeit zulassen.

Für einfache Grundrechenaufgaben wie das Inkrementieren von Variablen sollte
man entweder die eingebaute Arithmetik-Expansion der Shell (Siehe
\ref{arithmetikexpansion}) oder das wesentlich ressourcenfreundlichere
\texttt{expr} (Siehe \ref{expr}) benutzen.

\index{bc=\texttt{bc}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cat}\label{cat}\index{cat=\texttt{cat}|(textbf}

Auch \texttt{cat} ist ein oft unterbewertetes Tool. Seine Aufgabe besteht zwar
lediglich darin, etwas von der Standardeingabe oder aus einer Datei zu lesen,
und das dann auf der Standardausgabe wieder auszugeben. Allerdings leistet es
an vielen, teilweise sehr unterschiedlich gelagerten Aufgaben wertvolle
Dienste.

Durch Umlenklung der Ausgabe können Dateien erzeugt und erweitert werden. So
können mehrere Dateien per \lstinline|cat datei1.txt datei2.txt > datei.txt|
verkettet werden.

Außerdem kann man mit einem Aufruf in der Art
\lstinline|cat datei.txt | kommando| Daten an ein Programm übergeben, das nur
von der Standardeingabe lesen kann (Filter).

GNU-\texttt{cat}\marginpar{GNU!} verfügt über eine Reihe von Parametern, um die
Ausgabe zu formatieren, so können mit \texttt{-n} bzw. \texttt{-b} die Zeilen
numeriert werden, oder mit \texttt{-s} mehrere Zeilen zu einer einzigen
zusammengefaßt werden.

\index{cat=\texttt{cat}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cd}\label{cd}\index{cd=\texttt{cd}|(textbf}

Mit dem Kommando \texttt{cd} wird das aktuelle Verzeichnis gewechselt.

\index{cd=\texttt{cd}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chgrp}\label{chgrp}\index{chgrp=\texttt{chgrp}|(textbf}

Jede Datei gehört einem Benutzer und einer Gruppe. Letzteres läßt sich mit
\texttt{chgrp} einstellen. Als Parameter wird der Name oder die ID der Gruppe,
sowie ein oder mehrere Dateinamen übergeben. Verzeichnisse können rekursiv mit
dem Parameter \texttt{-R} bearbeitet werden.

Der Eingentümer der Datei wird mit \texttt{chown} (Abschnitt \ref{chown})
festgelegt.

\index{chgrp=\texttt{chgrp}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chmod}\label{chmod}\index{chmod=\texttt{chmod}|(textbf}

In unixoiden Systemen verfügt jede Datei über eine Reihe von Attributen. Damit
kann eine Menge gemacht werden, für den vollen Funktionsumfang empfiehlt sich
das Studium der Man-Page oder einer umfangreicheren Kommandoreferenz. Hier nur
das wichtigste in Kürze:

Die Syntax lautet \texttt{chmod [options] mode file...}.

Die einzig wichtige Option ist, analog zu \texttt{chgrp} und \texttt{chown} der
Parameter \texttt{-R} für die rekursive Bearbeitung von Verzeichnissen.

In der Syntax steht `file' für einen oder mehrere Dateinamen.

Den Modus einer Datei sieht man, indem man \texttt{ls -l} darauf ansetzt, die
Ausgabe wird im entsprechenden Abschnitt (\ref{ls}) beschrieben.

Dort ist von den drei `rwx-Blöcken' die Rede, die die Berechtigungen für User
(u), Group (g) und Other (o) angeben. Genau die können mittels \texttt{chmod}
gesteuert werden. Zusätzlich gibt es hier noch die Angabe All (a), mit denen
die Rechte für alle Benutzer verändert werden können.

Hier wird der Modus gesteuert, indem direkt angegeben wird für wen welche
Rechte gelten sollen. Mit `+' werden die Rechte erweitert, `-' nimmt Rechte
und mit `=' werden die Rechte hart gesetzt.

\texttt{chmod u+x datei} macht die Datei für den Besitzer ausführbar. Mit dem
Parameter \texttt{u=rw,go=r} werden die Rechte auf `rw-r--r--' gesetzt, der
Besitzer kann lesen und schreiben, alle anderen nur lesen.

Neben dieser Art der Notation gibt es noch eine~--~wesentlich
gängigere~--~numerische Schreibweise. Dabei werden die Berechtigungen in Form
von Zahlen angegeben. Dabei werden drei Zahlen von eins bis sieben benutzt.
Deren Bedeutung ergibt sich, wenn man sich die drei Stellen `rwx' als Binärzahl
vorstellt. Das x steht an der niederwertigsten Stelle, erhält also den Wert 1.
Das w steht für die 2 und r für 4. In Summe ergeben diese Zahlen die
Berechtigung. Also ist `rwx' gleichbedeutend mit 4+2+1=7. `rw' entspricht
4+2=6. Die reine Leseberechtigung `r' bleibt als 4 stehen.

Zur Verdeutlichung ein paar Beispiele, wo es möglich ist in beiden Notationen:

\LTXtable{\textwidth}{tab_kommandos_chmod_beispiele.tex}

Am wichtigsten sind also die Aufrufe \lstinline|chmod 644 datei| und
\lstinline|chmod 755 datei|, je nachdem ob die Datei ausführbar sein soll oder
nicht.

\index{chmod=\texttt{chmod}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chown}\label{chown}\index{chown=\texttt{chown}|(textbf}

Mit \texttt{chown} lassen sich Benutzer- und Gruppen-ID von Dateien und
Verzeichnissen festlegen. Mit dem Parameter \texttt{-R} sogar rekursiv für
Verzeichnisse.

Ein einzelner Parameter gibt die User-ID oder den Namen des zukünfigen
Benutzers an, in der Form name:gruppe können sowohl User- als auch Gruppen-ID
gleichzeitig geändert werden.

Will man lediglich die Gruppen-ID ändern, benutzt man das Kommando
\texttt{chgrp} (Abschnitt \ref{chgrp}).

\index{chown=\texttt{chown}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chpasswd}\index{chpasswd=\texttt{chpasswd}|(textbf}\marginpar{GNU!}

Mit diesem GNU-Kommando bietet sich dem Administrator des Systems die
Mög\-lich\-keit, scriptgesteuert die Paßwörter für neue Benutzer zu vergeben.
Manuell ändert man ein Paßwort mit dem Kommando
\texttt{passwd}\index{passwd=\texttt{passwd}}, allerdings löscht (flusht)
dieses Programm die Standard-Eingabe, bevor es das neue Paßwort erwartet. Somit
lassen sich Paßwörter mit \texttt{passwd} nur interaktiv ändern\footnote{Es
gibt auch einen anderen Weg: Man kann \texttt{passwd} auch mittels
\texttt{expect} fernsteuern. Allerdings ist diese Methode weniger elegant.}.

Das Kommando wird in der Form

\texttt{echo }\textit{name}\texttt{:}\textit{pass}\texttt{ | chpasswd}

aufgerufen. Es ist auch möglich, dem Programm eine Datei mit vielen Name /
Paßwort-Kombinationen an die Standard-Eingabe zu übergeben:

\texttt{cat }\textit{passwoerter.txt}\texttt{ | chpasswd}

Allerdings sollte dabei aus Sicherheitsgründen darauf geachtet werden, daß
diese Datei nicht allgemein lesbar ist.

\index{chpasswd=\texttt{chpasswd}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cmp}\label{cmp}\index{cmp=\texttt{cmp}|(textbf}

Mit \texttt{cmp} werden zwei Dateien verglichen. Wenn die beiden Dateien
identisch sind gibt es keine Ausgabe, ansonsten wird die Position des ersten
Unterschiedes ausgegeben.

Einer der beiden anzugebenden Dateinamen kann auch durch \texttt{-} ersetzt
werden, dann wird die Standard-Eingabe mit der anderen angegebenen Datei
verglichen.

Mit dem Parameter \texttt{-l} werden alle abweichenden Bytes aufgelistet,
jeweils mit der Position (dezimal) und den beiden Bytes (oktal).

Durch \texttt{-s} läßt sich die Ausgabe von Unterschieden unterdrücken, der
Exit-Status gibt weiterhin das Ergebnis an.

In der GNU-Version\marginpar{GNU!} gibt es auch Parameter, mit denen Bereiche
der Datei vom Vergleich ausgeschlossen werden können (\texttt{-i}), oder mit
denen nur die ersten n Bytes der Dateien verglichen werden (\texttt{-n}).

\index{cmp=\texttt{cmp}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cp}\label{cp}\index{cp=\texttt{cp}|(textbf}

Mit \texttt{cp} werden Dateien kopiert. Die wichtigsten Optionen im
Zusammenhang mit Skripten sind \texttt{-f} und \texttt{-R}. Ersteres erzwingt
(force) das Kopieren, falls an der Zielstelle schon Dateien existieren werden
sie überschrieben. Letzteres ermöglicht ein rekursives Kopieren.
Verzeichnisse~--~auch leere~--~können nur mit \texttt{-R} kopiert werden.

\index{cp=\texttt{cp}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cut}\label{cut}\index{cut=\texttt{cut}|(textbf}

Wie der Name (fast) schon sagt, kann man mit diesem Kommando Zeilen
zerschneiden. Mit den Parametern \texttt{-c} (Character) oder \texttt{-f}
(Field) wird bestimmt, in welcher Einheit die Schnittstellen abgesteckt werden
sollen. Falls die Zeilen in Felder zerteilt werden sollen, kann zusätzlich
mittels \texttt{-d} der Delimiter, also das Trennzeichen bestimmt werden. Wird
das nicht explizit getan, wird der Tabulator benutzt.

Dieser Definition folgt die Angabe des zu behaltenden Bereichs. Dafür kann eins
der Formate N, N-, N-M oder -M benutzt werden.

\LTXtable{\textwidth}{tab_kommandos_cut_beispiele.tex}

Praktisch das Gegenstück zu \texttt{cut} ist \texttt{paste}, damit werden
Dateien in Spalten zusammengeführt. Nährers dazu in Abschnitt \ref{paste}.

\index{cut=\texttt{cut}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{diff}\label{diff}\index{diff=\texttt{diff}|(textbf}

Mit \texttt{diff} werden zwei Dateien verglichen, und die Änderungen auf der
Standardausgabe aufgelistet, die nötig sind um die erste an die zweite Datei
anzupassen.

Mit dem Parameter \texttt{-r} können auch ganze Verzeichnisse rekursiv
verglichen werden.

Die ausgegebenen Listen können mit dem \texttt{patch}-Kommando auf Dateien
angewandt werden um sie auf den geänderten Stand zu bringen.

\index{diff=\texttt{diff}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{dirname}\label{dirname}\index{dirname=\texttt{dirname}|(textbf}

Analog zu \texttt{basename} (\ref{basename}) gibt \texttt{dirname} nur die
Pfad-Komponente einer angegebenen Datei zurück.

\index{dirname=\texttt{dirname}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{echo}\label{echo}\index{echo=\texttt{echo}|(textbf}

Dies ist wohl der grundlegendste Befehl, der in einem Skript verwendet werden
kann. Er ist die Voraussetzung, um eines der wichtigsten Werkzeuge der
Kybernetik auch mittels eines Shell-Skriptes effizient umzusetzen: Hello World.
:-)

Die eigentliche Aufgabe dieses Befehls dürfte jedem bekannt sein, der sich bis
zu dieser Stelle durchgearbeitet hat. Allerdings wissen viele nicht, daß auch
der echo-Befehl über Parameter verfügt. Zumindest zwei davon erweisen sich in
der Praxis oft als sehr hilfreich:

\LTXtable{\textwidth}{tab_kommandos_echo_parameter.tex}

\index{echo=\texttt{echo}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{eval}\label{eval}\index{eval=\texttt{eval}|(textbf}

Die Wirkungsweise von \texttt{eval} läßt sich wohl am ehesten durch ein kleines
Beispiel erklären:

\LTXtable{\textwidth}{tab_kommandos_eval_beispiel.tex}

Bevor eine Zeile in der Shell tatsächlich ausgeführt wird, wird sie von der
Shell expandiert, bzw. evaluiert. Der letzte Begriff deutet schon an was damit
gemeint ist: Enthaltene Variablennamen werden durch ihre Werte ersetzt.

Das Kommando \texttt{eval} führt die Zeile die durch die Expansion entstanden
ist noch einmal aus. So ist es möglich, Variablennamen aus den Inhalten anderer
Variablen zu bilden.

Eine wichtige Anwendung für dieses Kommando ist der Fall, wenn eigentlich ein
Array\index{Array} gebraucht würde. Der Inhalt eines Array-Elements kann
beispielsweise mittels \lstinline|eval echo \$arr$index| ausgegeben
werden, dabei ist \texttt{arr} der Name des Arrays und \texttt{index} der Name
der Variablen, die den Index des auszugebenden Elementes enthält.

\index{eval=\texttt{eval}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{expr}\label{expr}\index{expr=\texttt{expr}|(textbf}

Mit dem Kommando \texttt{expr} verfügt die Shell praktisch über einen
Taschenrechner für einfache Berechnungen. Für komplexe Aufgaben bietet sich das
Tool \texttt{bc} an, näheres dazu steht in Abschnitt \ref{bc}.

Genau genommen kann man mit \texttt{expr} nicht nur Berechnungen
durch\-füh\-ren, sondern ganz allgemein `Ausdrücke evaluieren'. Damit ist
gemeint, daß es zum Beispiel auch Operatoren für Pattern-Matching gibt. Die
wichtigsten Operatoren lauten wie folgt:

\LTXtable{\textwidth}{tab_kommandos_expr_parameter.tex}

Bei einigen Sonderzeichen ist deren Bedeutung in der Shell zu berücksichtigen,
sie sind also durch Anführungszeichen oder Backslashes zu quoten:
\lstinline|i=`expr $i \* 3`|.

Eine andere Möglichkeit für einfache Rechnungen besteht in der sogenannten
Arith\-me\-tik-Ex\-pan\-sion (Siehe \ref{arithmetikexpansion}).

\index{expr=\texttt{expr}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{find}\label{find}\index{find=\texttt{find}|(textbf}

Auf einem modernen System sind nicht selten mehrere zehn- oder hunderttausend
Dateien vorhanden. Um eine bestimmte Datei anhand komplexer Kriterien ausfindig
zu machen benutzt man \texttt{find}.

Bei einem Aufruf wird zuerst das zu durchsuchende Verzeichnis, dann die
Suchkriterien und eventuell abschließend die durchzuführenden Aktionen
angegeben.

Die Angabe der Suchkriterien ist sehr vielseitig, hier werden nur die
wichtigsten Optionen beschrieben. Wie immer empfehle ich das Studium der
Man-Page oder eines entsprechenden Buches.

\LTXtable{\textwidth}{tab_kommandos_find_parameter.tex}

Die verschiedenen Suchkriterien können kombiniert werden. Mit \texttt{-a} oder
\texttt{-o} erreicht man eine logische AND- bzw. OR-Verknüpfung, mit einem
vorangestellten \texttt{!} können Kriterien negiert werden. Die AND-Verknüpfung
muß nicht explizit angegeben werden, wenn mehrere Kriterien verwandt werden.
Komplexere Ausdrücke können durch runde Klammern gruppiert werden, dabei ist
jedoch deren Sonderbedeutung in der Shell entsprechend zu quoten (Siehe
Abschnitt \ref{quoting}).

Bei der Angabe numerischer Parameter zu den Suchkriterien wird normalerweise
nach dem exakten Wert gesucht. Statt eines einfachen \textsl{n} kann jedoch
auch \textsl{+n} oder \textsl{-n} angegeben werden, damit wird dann nach
Vorkommen größer bzw. kleiner als \textsl{n} gesucht.

Da die reine Beschreibung der Parameter manchmal etwas verwirrend ist, folgen
hier ein paar praktische Beispiele:

\begin{lstlisting}
# Suche alle Einträge in bzw. unter dem aktuellen Verzeichnis:
find .
# Suche alle normalen Dateien mit der Endung txt unter /home:
find /home -type f -name \*.txt
# Suche alle Einträge außer symbolischen Links, in die jeder schreiben darf:
find / \! -type l -perm 777
# Suche alle Dateien unter dem Homeverzeichnis, deren Größe 10000000 Bytes
# übersteigt und gib sie ausführlich aus:
find ~ -size +10000000c -exec ls -l {} \;
# Suche alle Einträge im Homeverzeichnis, die innerhalb der letzten zwei Tage
# geändert wurden:
find ~ -mtime -2
\end{lstlisting}

Wenn mittels \texttt{-exec} weitere Kommandos gestartet werden, sollte beachtet
werden daß mindestens ein Prozeß pro Fundstelle gestartet wird. Das kostet sehr
viel, unter Umständen macht der Einsatz von \texttt{xargs} (Abschnitt
\ref{xargs}) Sinn.

Die Ausführung von \texttt{find} erzeugt unter Umständen sehr viel Last auf der
Festplatte, bei Netzlaufwerken auch Netzwerkbandbreite. In einigen Fällen
bieten sich alternative Suchverfahren an:

\textbf{Alternative 1:} Falls man den Namen der zu suchenden Datei kennt, und
das Locate-System installiert ist kann man die Datei auch mittels
\texttt{locate} suchen. Das ist ressourcenschonender, da nicht `live' das
Filesystem durchforstet wird, sondern nur die Locate-Datenbank. Diese wird
allerdings im Regelfall nur einmal täglich aktualisiert, die Suche taugt nicht
für schnell wechselnde Bestände.

\textbf{Alternative 2:} Sucht man nach einer ausführbaren Datei, die im Pfad
vorhanden ist (`Wo liegt eigentlich Firefox?'), dann sucht man mittels
\texttt{which} (Abschnitt \ref{which}).

Siehe auch: Abschnitt \ref{beispiele_suchen_dateien}.

\index{find=\texttt{find}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{grep}\label{grep}\index{grep=\texttt{grep}|(textbf}

Das Tool \texttt{grep} stammt aus dem Standard-Repertoire eines jeden
Sys\-tem\-ad\-mi\-ni\-stra\-tors. Mit seiner Hilfe kann in einer oder mehreren
Dateien, oder eben auch in einem Datenstrom nach dem Auftreten bestimmter
regulärer Ausdrücke (siehe \ref{mustererkennung}) gesucht werden.

Die folgende Tabelle stellt einige der vielen Parameter vor:

\LTXtable{\textwidth}{tab_kommandos_grep_parameter.tex}

Siehe auch: Abschnitt \ref{beispiele_suchen}.

\index{grep=\texttt{grep}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{head}\label{head}\index{head=\texttt{head}|(textbf}

\texttt{head} ist das Gegenstück zu \texttt{tail} (Siehe \ref{tail}). Hier
werden allerdings nicht die letzten Zeilen angezeigt, sondern die ersten.

\index{head=\texttt{head}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{kill}\label{kill}\index{kill=\texttt{kill}|(textbf}

Die landläufige Annahme ist, daß man mit dem \texttt{kill}-Kom\-man\-do
Prozesse `umbringt'. Das ist zwar wahr, aber nicht die ganze Wahrheit.

Im Prinzip sendet \texttt{kill} lediglich ein Signal an einen Prozeß. Ohne
weitere Parameter ist das tatsächlich ein SIGTERM, das den Prozeß im Regelfall
dazu bewegt sich zu beenden. Jeder Admin kennt das Verfahren, einem hängenden
Prozeß mittels \texttt{kill -9} den Gnadenschuß zu geben. Die 9 steht dabei für
das Signal mit der Nummer 9, SIGKILL. Noch ein gebräuchliches Signal ist SIGHUP
(1), der `Hangup'. Historisch wurde das gesendet wenn die Leitung zum Rechner
aufgelegt wurde, mittlerweile ist es gängige Praxis damit einen Daemon neu zu
initialisieren.

Daneben stehen noch eine Reihe weiterer Signale zur Verfügung. Mit \texttt{kill
-l} kann man sich eine Liste ansehen. 

Es gibt verschiedene Wege, das Signal abzusetzen. Welchen man wählt ist
Geschmackssache. Hier ein paar Beispiele:

\begin{lstlisting}
# Die folgenden Befehle sind gleichwertig. Alle senden ein HUP an Prozeß-ID 42:
kill -1 42
kill -HUP 42
kill -SIGHUP 42
kill -s 1 42
kill -s HUP 42
kill -s SIGHUP 42

# virtueller Selbstmord: Alle Prozesse umbringen, die man umbringen kann:
kill -9 -1

# SIGTERM an mehrere Prozesse senden:
kill 123 456 789
\end{lstlisting}

Siehe auch: Das Beispiel `Fallensteller' in Abschnitt \ref{traps} zeigt, wie
ein Skript auf Signale reagieren kann.

\index{kill=\texttt{kill}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{killall}\label{killall}\index{killall=\texttt{killall}|(textbf}\marginpar{GNU!}

Im Abschnitt über \texttt{kill} (\ref{kill}) wird beschrieben, wie man ein
Signal an einen Prozeß schickt, dessen ID bekannt ist. Kennt man die ID nicht,
oder will man das Signal an mehrere Prozesse schicken, kann dieses Kommando auf
GNU-Systemen eine große Hilfe darstellen.

Mit dem Parameter \texttt{-i} wird vor jedem Signal interaktiv gefragt, ob es
geschickt werden soll. Mit \texttt{-v} wird angegeben, ob die Signale
erfolgreich versandt wurden, \texttt{-q} hingegen unterdrückt die Ausgaben.

Da ein Prozeß nach einem Signal nicht notwendigerweise sofort stirbt, gibt es
eine Option \texttt{-w}. Diese Veranlaßt \texttt{killall} zu warten, bis alle
Empfänger tot sind. Dieser Parameter ist allerdings mit Vorsicht zu genießen:
Wenn der Prozeß sich weigert zu sterben, wartet \texttt{killall} ewig.

Eine ähnliche Funktionalität bietet auch das Kommando \texttt{pkill} (Abschnitt
\ref{pkill}), \texttt{killall} hat aber den Vorteil daß es auf mehr Systemen
zur Verfügung steht.

\index{killall=\texttt{killall}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{logger}\label{logger}\index{logger=\texttt{logger}|(textbf}

Mit \texttt{logger} werden Nachrichten an die Log-Mechanismen des Systems
geschickt. So können auch unbeobachtet laufende Skripte über ihr tun
informieren.

Der zu loggende Text wird einfach als Parameter übergeben.

Die GNU-Version\marginpar{GNU!} verfügt über einige Parameter, unter anderem
kann die Nachricht mit \texttt{-s} parallel zum System-Log auch auf der
Standard-Fehlerausgabe ausgegeben werden.

\index{logger=\texttt{logger}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{ls}\label{ls}\index{ls=\texttt{ls}|(textbf}

Den Inhalt von Verzeichnissen im Dateisystem bringt man mit \texttt{ls} in
Erfahrung. Ein einfacher Aufruf listet lediglich die Dateinamen im aktuellen
oder angegebenen Verzeichnis auf, das Kommando hat aber auch sehr viele
Parameter mit denen sich die Ausgabe anpassen läßt. Hier sind die wichtigsten,
eine vollständige Auflistung bietet wie immer die Man-Page:

\marginpar{GNU!}\LTXtable{\textwidth}{tab_kommandos_ls_parameter.tex}

Besonders informativ gibt sich der Parameter \texttt{-l}, da damit auch die
Eigentümer und die Berechtigungen der Dateien angezeigt werden. Die Ausgabe hat
die folgende Form:

\texttt{-rw-r--r--  1 rschaten users 6252 Nov 19 14:14 shell.tex}

Die linke Spalte der Ausgabe zeigt die bestehenden Berechtigungen. Es ist ein
Block in der Form `drwxrwxrwx'. An Stelle des d können auch andere Buchstaben
stehen, hier wird der Dateityp angegeben, also ob es sich um eine einfache
Datei (-), ein Verzeichnis (d), einen Link (l) oder ähnliches\footnote{Siehe
Man-Page} handelt. Die rwx-Blöcke geben die Dateiberechtigungen jeweils für den
Besitzer, die Gruppe und andere User an. Dabei steht das r für read, w für
write und x für execute. An ihrer Stelle können auch Striche stehen, die
repräsentieren nicht gesetzte Attribute. Die Datei im Beispiel ist also für
ihren Besitzer les- und schreibbar, für alle anderen nur lesbar. Die
Berechtigungen werden mit dem Kommando \texttt{chmod} (Abschnitt \ref{chmod})
gesetzt.

Die nächste Spalte stellt die Anzahl der Links dar, die auf diese Datei
verweisen, im Beispiel existiert die Datei an nur einer Stelle im Filesystem.

Dann folgen der Benutzer und die Gruppe, denen die Datei gehört. Diese
Parameter werden mit \texttt{chown} (Abschnitt \ref{chown}) bzw. \texttt{chgrp}
(Abschnitt \ref{chgrp}) gesetzt.

Es folgt die Größe der Datei in Bytes, sowie das Datum der letzten Änderung.
Liegt dieses mehr als ein halbes Jahr zurück wird an Stelle der Uhrzeit die
Jahreszahl angegeben, es gilt also Vorsicht walten zu lassen, wenn dieser Wert
in Skripten benutzt werden soll.

Abschließend wird der Name der jeweiligen Datei ausgegeben.

\index{ls=\texttt{ls}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{mkdir}\label{mkdir}\index{mkdir=\texttt{mkdir}|(textbf}

Mit diesem Kommando werden Verzeichnisse angelegt. Dabei kann mit \texttt{-m}
angegeben werden, welche Berechtigungen das Verzeichnis bekommen soll. Mit
\texttt{-p} werden bei Bedarf auch Parent-Verzeichnisse angelegt, es entsteht
also ein kompletter Pfad.

Entfernen lassen sich Verzeichnisse mit \texttt{rmdir} (Abschnitt \ref{rmdir}).

\index{mkdir=\texttt{mkdir}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{mv}\label{mv}\index{mv=\texttt{mv}|(textbf}

Dateien und Verzeichnisse können mit dem Kommando \texttt{mv} verschoben
werden. Falls am Ziel schon Dateien existieren erzwingt der Parameter
\texttt{-f} die Aktion, die alten Dateien werden überschrieben. Mit \texttt{-i}
wird der Vorgang interaktiv, vor jeder Dateibewegung wird nachgefragt.

\index{mv=\texttt{mv}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{paste}\label{paste}\index{paste=\texttt{paste}|(textbf}

Während mit \texttt{cut} (Abschnitt \ref{cut}) Dateien spaltenweise zerlegt
werden, werden sie mit \texttt{paste} zusammengeführt. Die Dateinamen werden
als Parameter übergeben, woraufhin Zeile für Zeile die Inhalte aller Dateien zu
einer Tabelle gemacht werden.

Die Spalten werden standardmäßig durch Tabulatorzeichen getrennt, man kann mit
dem Parameter \texttt{-d} auch ein oder mehrere andere Trennzeichen definieren.
Werden mehrere Zeichen angegeben, werden sie der Reihe nach zum trennen der
Spalten benutzt.

Mit \texttt{-s} wird die Tabelle transponiert, also praktisch um 90 Grad
gedreht.

\index{paste=\texttt{paste}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{pgrep}\label{pgrep}\index{pgrep=\texttt{pgrep}|(textbf}\marginpar{GNU!}

Eine häufig wiederkehrende Aufgabe ist es, zu sehen ob ein bestimmter Prozeß
existiert oder nicht. Falls das Kommando \texttt{pgrep} zur Verfügung steht,
kannn man auf das Konstrukt mit \texttt{ps} und \texttt{grep} verzichten. Der
folgende Aufruf liefert alle Prozeß-IDs, deren Name httpd enthält, inclusive
des vollen Kommandos:

\lstinline|pgrep -lf httpd|

Über weitere Parameter läßt sich genauer spezifizieren, wonach gesucht werden
soll, hier die wichtigsten:

\LTXtable{\textwidth}{tab_kommandos_pgrep_parameter.tex}

Die Ausgabe enthält per Default nur die Prozeß-IDs der Fundstellen. Diese läßt
sich als Parameter für andere Programme benutzen. Das folgende Beispiel liefert
detaillierte Informationen über alle xterm-Prozesse:

\lstinline|ps -fp $(pgrep -d, -x xterm)|

Siehe auch: Abschnitt \ref{beispiele_suchen_prozesse}.

\index{pgrep=\texttt{pgrep}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{pkill}\label{pkill}\index{pkill=\texttt{pkill}|(textbf}\marginpar{GNU!}

Dieses Kommando ist eng verwandt mit \texttt{pgrep} (Siehe Abschnitt
\ref{pgrep}), es versteht im Wesentlichen die gleichen Parameter. Allerdings
werden die Fundstellen hier nicht ausgegeben. Wie der Name schon andeutet,
werden hiermit Prozesse umgebracht. Da man hier mit einem Kommando unter
Umständen viele Prozesse beendet, sollten \textbf{die verwendeten Parameter
genau unter die Lupe} genommen werden, um `Kollateralschäden' zu vermeiden. :-)

Es besteht auch die Möglichkeit, den Prozessen andere Signale zuzuschicken,
diese Funktion wird im Abschnitt zu \texttt{kill} (\ref{kill}) näher
beschrieben. Das folgende Kommando veranlaßt beispielsweise den Syslog-Daemon,
seine Konfiguration neu einzulesen:

\lstinline|pkill -HUP syslogd|

Das Kommando \texttt{killall} (Abschnitt \ref{killall}) bietet eine ähnliche
Funktionalität, allerdings fehlen ihm einige Parameter. Trotzdem sollte im
Zweifel \texttt{killall} benutzt werden, da es auf mehr Systemen zur Verfügung
steht.

\index{pkill=\texttt{pkill}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{printf}\label{printf}\index{printf=\texttt{printf}|(textbf}

Analog zum gleichnamigen Befehl in Programmiersprachen wie Perl oder C dient
\texttt{printf} der formatierten Ausgabe von Daten. Als Parameter wird ein
sogenannter Format-String und eine Liste von auszugebenden Daten mitgegeben.
Dabei enthält der Format-String eine Reihe von Platzhaltern, die nach
bestimmten Regeln durch die Daten ersetzt werden.

Der Format-String folgt im Wesentlichen den gleichen Regeln wie in der
C-Version. Näheres dazu erfährt man mit \lstinline|man 3 printf|.

Hier die wichtigsten Parameter für den Format-String:

\LTXtable{\textwidth}{tab_kommandos_printf_parameter.tex}

Besonders nützlich ist dieses Kommando bei der tabellarischen Ausgabe von
Daten. Im folgenden Beispiel werden alle Benutzernamen, deren
Home-Verzeichnisse und Default-Shells aus der Datei \texttt{/etc/passwd}
extrahiert und übersichtlich ausgegeben:

\begin{lstlisting}
#!/bin/sh
IFS=:
while read user pass uid gid name home shell; do
  printf "%-15s %-25s %s\n" $user $home $shell
done < /etc/passwd
\end{lstlisting}

Zur Erinnerung: Die vordefinierte Variable
\texttt{\$IFS}\index{\$IFS=\texttt{\$IFS}} ist der Feld-Separator, die
Eingabezeilen werden also als Doppelpunkt-separierte Liste gesehen. Näheres
dazu steht im Abschnitt über vordefinierte Variablen
(\ref{vordefinierte_variablen}).

\index{printf=\texttt{printf}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{ps}\label{ps}\index{ps=\texttt{ps}|(textbf}

Mit \texttt{ps} gibt man einen Schnappschuß des Zustandes der aktuell laufenden
Prozesse aus\footnote{Wenn man interaktiv den Zustand der laufenden Prozesse
beobachten möchte, benutzt man \texttt{top}, das eignet sich jedoch nicht zur
Shell-Programmierung und wird deshalb nicht ausführlich beschrieben.}.

Ohne weitere Parameter listet \texttt{ps} alle Prozesse auf, die dem
aufrufenden Benutzer gehören und die mit dem aktuellen Terminal assoziiert
sind. Angezeigt werden dann die Prozeß-ID, das Terminal, die verbrauchte
CPU-Zeit und der Name des laufenden Kommandos.

In Skripten möchte man üblicherweise feststellen, ob ein bestimmtes Kommando
aktiv ist, ob also zum Beispiel ein bestimmter Serverdienst läuft. Dazu macht
man \texttt{ps} über Optionen gesprächiger.

Das Kommando versteht in der GNU-Version\marginpar{GNU!} zwei unterschiedliche
Arten von Optionen. Den sogenannten Unix- bzw. Posix-Stil und den BSD-Stil.
Zusätzlich gibt es noch ausführliche Parameter, aber die sollen hier nicht
beschrieben werden. Die jeweiligen Formen stehen nicht auf allen Systemen zur
Verfügung, wenn ein Skript beispielsweise auch unter Solaris benutzt werden
soll ist man gezwungen, die Unix-Parametrisierung zu benutzen.

Unix-Parameter zeichnen sich durch die übliche Angabe mit Bindestrich aus.
BSD-Pa\-ra\-me\-ter werden ohne Bindestrich angegeben, was neben den meisten
anderen Kommandos etwas ungewohnt aussieht.

Es gibt sehr viele verschiedene Parameter, die beste Informationsquelle ist wie
immer die Man-Page bzw. ein entsprechendes Buch. Hier werden nur ein paar
typische Aufrufbeispiele gezeigt, deren Ausgabe sich jeder selber ansehen kann:

\begin{lstlisting}
# Alle Prozesse auflisten, Unix-Syntax:
ps -e
ps -ef
ps -eF
ps -ely

# Alle Prozesse auflisten, BSD-Syntax:
ps ax
ps axu

# Prozeßbaum ausgeben. Das ist in Skripten weniger Sinnvoll, wird hier aber
# angegeben weil es so eine praktische Funktion ist... :-)
ps -ejH
ps axjf

# Alle Prozesse ausgeben, die nicht dem Benutzer `root' gehören:
ps -U root -u root -N

# Nur die Prozeß-ID von Syslog ausgeben:
ps -C syslogd -o pid=

# Nur den Namen des Prozesses mit der ID 42 ausgeben:
ps -p 42 -o comm=
\end{lstlisting}

Für die Suche nach Prozessen bestimmten Namens steht auf manchen Systemen auch
das Kommando \texttt{pgrep} (Abschnitt \ref{pgrep}) zur Verfügung.

Siehe auch: Abschnitt \ref{beispiele_suchen_prozesse}.

\index{ps=\texttt{ps}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{read}\label{read}\index{read=\texttt{read}|(textbf}

Mit dem Kommando \texttt{read} kann man Eingaben von der
Standard-Eingabe\index{Standard-Eingabe} lesen. Dabei wird üblicherweise einer
oder mehrere Variablennamen übergeben. Dem ersten Namen wird das erste
eingegebene Wort zugewiesen, dem zweiten das zweite Wort usw.  Dem letzen
Variablennamen wird der verbleibende Rest der Eingabezeile zugewiesen. Wenn
also nur ein Variablenname angegeben wird, erhält dieser die komplette
Eingabezeile. Wenn weniger Worte gelesen werden als Variablen angegeben sind,
enthalten die verbleibenden Variablen leere Werte. Als Wort-Trennzeichen dienen
alle Zeichen, die in der vordefinierten Variable
\texttt{\$IFS}\index{\$IFS=\texttt{\$IFS}} enthalten sind (siehe Abschnitt
\ref{vordefinierte_variablen}).

Wenn keine Variablennamen angegeben werden, wird die Eingabe in der Variable
\texttt{REPLY} abgelegt.

Sonderzeichen können während der Eingabe normalerweise mittels eines Backslash
vor der Interpretation geschützt werden. Ein Backslash vor einem Newline
bewirkt also eine mehrzeilige Eingabe. Dieses Verhalten kann mit dem Parameter
\texttt{-r} abgeschaltet werden.

Normalerweise wird eine Eingabezeile mit einem Newline abgeschlossen. Mit dem
Parameter \texttt{-d}\marginpar{GNU!} ist es möglich, ein anderes
Zeilenendezeichen anzugeben.  Beispielsweise liest
\lstinline|read -d " " var| alle Zeichen bis zum ersten Leerzeichen in die
Variable \texttt{var} ein.

Wenn nur eine bestimmte Zahl von Zeichen gelesen werden soll, kann diese durch
den Parameter \texttt{-n}\marginpar{GNU!} angegeben werden. Der Befehl
\lstinline|read -n 5 var| liest die ersten fünf Zeichen in die Variable
\texttt{var} ein. Demzufolge kann ein Skript durch ein \lstinline|read -n 1|
dazu gebracht werden, auf einen einzelnen Tastendruck~--~nicht zwingend ein
Return~--~zu warten.

Mit dem Parameter \texttt{-p}\marginpar{GNU!} kann man einen Prompt, also eine
Eingabeaufforderung ausgeben lassen. \lstinline|read -p "Gib was ein:" var|
schreibt also erst den Text \textit{Gib was ein:} auf das Terminal, bevor die
Eingaben in die Variable \texttt{var} übernommen werden. Dieser Prompt wird nur
an einem interaktiven Terminal ausgegeben, also nicht in einem Skript das seine
Eingaben aus einer Datei oder aus einem Stream erhält.

Wenn die Eingabe von einem Terminal kommt und nicht auf dem Bildschirm
erscheinen soll, zum Beispiel bei Paßwortabfragen, kann die Ausgabe mit dem
Parameter \texttt{-s}\marginpar{GNU!} (Silent) unterdrückt werden.

Mit \texttt{-t}\marginpar{GNU!} kann ein Time-Out definiert werden, nach dessen
Ablauf das Kommando mit einem Fehler abbricht. Dieser Parameter ist nur bei
interaktiver Eingabe oder beim Lesen aus einer Pipe aktiv.

Der Rückgabewert des \texttt{read}-Kommandos ist 0, es sei denn es trat ein
Timeout oder ein EOF auf.

\index{read=\texttt{read}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{rm}\label{rm}\index{rm=\texttt{rm}|(textbf}

Mit diesem Kommando können Dateien und Verzeichnisse gelöscht werden. Dabei
kann man vorsichtig vorgehen, indem man mit \texttt{-i} dafür sorgt, daß jeder
Löschvorgang be\-stä\-tigt werden muß. Oder rabiat, indem man mit \texttt{-f}
das Löschen erzwingt.

Verzeichnisse können mit dem Parameter \texttt{-R} entfernt werden, im
Gegensatz zu \texttt{rmdir} werden dann auch sämtliche enthaltenen Dateien und
Unterverzeichnisse gelöscht.

Die GNU-Version\marginpar{GNU!} von \texttt{rm} unterstützt zusätzlich den
Parameter \texttt{-v}, mit dem jeder Löschvorgang ausgegeben wird.

\index{rm=\texttt{rm}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{rmdir}\label{rmdir}\index{rmdir=\texttt{rmdir}|(textbf}

Mit \texttt{rmdir} werden Verzeichnisse gelöscht. Das funktioniert nur, wenn
sie leer sind. Mit \texttt{-p} kann ein kompletter Verzeichnispfad gelöscht
werden, will sagen: Alle höher liegenden Verzeichnisse im angegebenen Pfad
werden gelöscht. Voraussetzung ist hier natürlich auch, daß die Verzeichnisse
nichts außer dem angegebenen Unterverzeichnis enthalten.

Angelegt werden Verzeichnisse mit \texttt{mkdir} (Abschnitt \ref{mkdir}),
nicht-leere Verzeichnisse können rekursiv mit \texttt{rm -r} (Abschnitt
\ref{rm}) gelöscht werden.

\index{rmdir=\texttt{rmdir}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{script}\label{script}\index{script=\texttt{script}|(textbf}\marginpar{GNU!}

Dieses Kommando eignet sich vorzüglich für das Debuggen fertiger Skripte. Man
ruft es in Verbindung mit einem Dateinamen auf. Dieser Aufruf startet eine neue
Shell, in der man beliebige Kommandos ausführen kann. Wenn man fertig ist,
beendet man den script-Befehl durch die Eingabe von \texttt{exit},
\texttt{logout} oder Druck der Tastenkombination \Ovalbox{CTRL}+\Ovalbox{d}
(EOF).

Script schreibt alle Ein- und Ausgaben die an dem Terminal vorgenommen werden
in die angegebene Datei. So kann man auch interaktive Skripte relativ leicht
debuggen, da sowohl Ein- als auch Ausgaben in dem Logfile sichtbar sind.
\index{script=\texttt{script}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sed}\label{sed}\index{sed=\texttt{sed}|(textbf}

Der `Stream Editor' \texttt{sed} stellt, ähnlich wie \texttt{awk} (Abschnitt
\ref{awk}) eigentlich eine eigene Skriptsprache dar. Er wird auch
`nicht-interaktiver Editor' genannt. Die Kommandos sind minimalistisch, aber
exakt auf die Aufgabe zugeschnitten.

\texttt{sed} liest Zeilenweise aus einer Datei, wenn keine Datei angegeben
wurde wird von der Standard-Eingabe gelesen. Auf die eingelesenen Zeilen wird
dann ein mehr oder weniger kompliziertes \texttt{sed}-Skript angewendet, bevor
auf der Standard-Ausgabe die Resultate ausgegeben werden.

Eine vollständige Beschreibung von \texttt{sed} würde an dieser Stelle den
Rahmen sprengen, es gibt aber im Handel gute Bücher zu dem Thema. Hier sollen
nur die gängigsten Kommandos und einige Anwendungsbeispiele genannt werden.

\subsubsection{Aufruf}

\begin{lstlisting}
# Aufruf als Stream-Editor:
kommando1 | sed 's/alt/neu/' | kommando2

# Aufruf mit einer zu bearbeitenden Datei:
sed 's/alt/neu/' datei.txt

# Wenn mehr als ein Kommando ausgeführt werden soll, muß der Parameter -e
# verwendet werden:
sed -e 's/alt/neu/' -e '/loeschen/d' datei.txt

# Man kann auch mehrere Kommandos mit einem -e aufrufen, wenn sie durch ein
# Semikolon getrennt werden:
sed 's/alt/neu/; /loeschen/d' datei.txt

# In einem Skript kann das Kommando auch über mehrere Zeilen gehen:
sed '
s/alt/neu/
/loeschen/d' datei.txt

# Alternativ können die Kommandos auch in eine eigene Datei gespeichert und
# über den Parameter -f eingebunden werden:
sed -f script.sed datei.txt
\end{lstlisting}

Neben den oben erwähnten Parametern kann \texttt{sed} auch mit \texttt{-n}
ruhig gestellt werden. Damit werden die Zeilen nur dann ausgegeben, wenn das
mittels `p' explizit gefordert wird. Die GNU-Version\marginpar{GNU!} stellt
noch ein paar Parameter zur Verfügung, die Man-Page verrät näheres.

\subsubsection{Addressierung}

Durch die Adressierung können Befehle gezielt auf bestimmte Zeilen angewandt
werden. Dabei können einem Befehl keine, eine oder zwei Adressen mitgegeben
werden.

Wenn keine Zeilen adressiert werden, wirkt der Befehl auf alle Zeilen.

Wenn eine Adresse mitgegeben wird, wirkt der Befehl auf alle Zeilen die durch
diese Adresse angesprochen werden. Das können, zum Beispiel bei einem regulären
Ausdruck, auch mehrere Zeilen sein.

Werden zwei Adressen angegeben, wirkt der Befehl auf die erste betroffene
Zeile, sowie auf alle weiteren bis zur zweiten angegebenen Zeile. Die beiden
Adressen müssen durch ein Komma getrennt angegeben werden.

Die Auswahl der Zeilen kann durch ein an die Adresse angehängtes Rufzeichen
negiert werden, der Befehl wirkt dann also auf alle Zeilen die \textbf{nicht}
adressiert wurden.

Aber wie sehen solche Adreßangeben aus? Die folgende Tabelle zeigt einige
Beispiele anhand des Kommandos `d', mit dem Zeilen gelöscht werden:

\LTXtable{\textwidth}{tab_kommandos_sed_adressen.tex}

Adressen können auch vor geschweiften Klammern stehen, dann wirken sie auf die
komplette Befehlsfolge innerhalb der Klammern.

\subsubsection{Kommandos}

Es gibt eine ganze Reihe von Kommandos, diese Beschreibung konzentriert sich
aber auf die wichtigsten `Brot und Butter-Kommandos'. In den Beispielen weiter
unten kommen auch andere Kommandos vor, die können bei Bedarf anhand der
einschlägigen Quellen nachgeschlagen werden.

\LTXtable{\textwidth}{tab_kommandos_sed_kommandos.tex}

Mit \texttt{s} wird substituiert. Das heißt, in der Eingabezeile wird nach
einem Muster gesucht, und im Erfolgsfall wird es ersetzt. Wichtigster
Modifikator für dieses Kommando ist \texttt{g}, damit wird `global' ersetzt,
falls mehrere Fundstellen in einer Zeile vorkommen. Der Aufruf sieht wie folgt
aus:

\texttt{s/Suchmuster/Ersatzmuster/g}

Im Ersatzmuster können auch Teile der Fundstelle wieder vorkommen, wenn sie
durch Klammern in einen Puffer kopiert werden:

\texttt{s/Seite ([0-9]*) von ([0-9]*)/\textbackslash{}1 aus \textbackslash{}2/}

Mit \texttt{y} hingegen werden einzelne Buchstaben durch andere vertauscht. Das
folgende Kommando wandelt alle eingehenden Kleinbuchstaben in Großbuchstaben
um\footnote{Umlaute und Sonderzeichen ausgeschlossen}:

\texttt{y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/}

Normalerweise werden alle Eingabezeilen nach der Bearbeitung wieder ausgegeben,
unabhängig davon ob sie verändert wurden oder nicht. Das Verhalten kann über
den Kommandozeilenparameter \texttt{-n} abgeschaltet werden. Da dann allerdings
nichts mehr ausgegeben wird kann durch ein an ein Kommando angehängtes
\texttt{p} bestimmt werden, daß die Veränderten Zeilen~--~und nur
die~--~ausgegeben werden.

\subsubsection{Beispiele}

Da es in diesem Text nicht um \texttt{sed}-Skripte, sondern um Shell-Skripte
gehen soll werden hier keine komplexen Sachen vorgestellt, sondern nur ein paar
Einzeiler. Nichtsdestotrotz können es auch diese unscheinbaren Aufrufe in sich
haben.

\begin{lstlisting}
### SUCHEN UND ERSETZEN

# Im kompletten Text 'rot' durch 'blau' ersetzen:
sed 's/rot/blau/'   # Ersetzt nur das erste Vorkommen in jeder Zeile
sed 's/rot/blau/4'  # Ersetzt nur das vierte Vorkommen in jeder Zeile
sed 's/rot/blau/g'  # Ersetzt nur jedes Vorkommen in jeder Zeile

# 'rot' durch 'blau' ersetzen, aber NUR in Zeilen die auch 'gelb' enthalten:
sed '/gelb/s/rot/blau/g'

# 'rot' durch 'blau' ersetzen, AUSSER in Zeilen die auch 'gelb' enthalten:
sed '/gelb/!s/rot/blau/g'

# 'rosa', 'hellrot' und 'magenta' durch 'pink' ersetzen:
sed 's/rosa/pink/g;s/hellrot/pink/g;s/magenta/pink/g'
gsed 's/rosa\|hellrot\|magenta/pink/g'                # nur in GNU sed

# Jede Zeile um fünf Leerzeichen einrücken:
# lies: 'ersetze jeden Zeilenanfang durch fünf Leerzeichen'
sed 's/^/     /'

# Führende Blanks (Leerzeichen, Tabulatoren) von den Zeilenanfängen löschen:
# ACHTUNG: An Stelle des \t muß der Tabulator gedrückt werden, die Darstellung
#          als \t versteht nicht jedes sed!
sed 's/^[ \t]*//'

# Schliessende Blanks vom Zeilenende löschen, siehe oben:
sed 's/[ \t]*$//'

# Führende und schließende Blanks löschen:
sed 's/^[ \t]*//;s/[ \t]*$//'

# Wenn eine Zeile mit Backslash aufhört den Zeilenumbruch entfernen:
sed -e :a -e '/\\$/N; s/\\\n//; ta'

### BESTIMMTE ZEILEN AUSGEBEN

# Nur Zeile 42 ausgeben:
sed -n '42p'                 # Methode 1
sed '42!d'                   # Methode 2

# Nur die Zeilen 23-42 ausgeben (inklusive):
sed -n '23,42p'              # Methode 1
sed '23,42!d'                # Methode 2

# Von einem regulären Ausdruck bis zum Dateiende ausgeben:
sed -n '/regexp/,$p'

# Den Bereich zwischen zwei regulären Ausdrücken ausgeben (inklusive):
sed -n '/rot/,/blau/p'

# Nur Zeilen mit mindestens 42 Zeichen ausgeben:
sed -n '/^.\{42\}/p'

# Nur Zeilen mit höchstens 42 Zeichen ausgeben:
sed -n '/^.\{42\}/!p'        # Methode 1, analog zu oben
sed '/^.\{42\}/d'            # Methode 2, einfachere Syntax

### BESTIMMTE ZEILEN LÖSCHEN

# Die ersten zehn Zeilen löschen:
sed '1,10d'

# Die letzte Zeile löschen:
sed '$d'

# Alles außer dem Bereich zwischen zwei regulären Ausdrücken ausgeben:
sed '/rot/,/blau/d'

# Alle Leerzeilen löschen:
sed '/^$/d'                           # Methode 1
sed '/./!d'                           # Methode 2

# Alle Leerzeilen am Dateianfang löschen:
sed '/./,$!d'
\end{lstlisting}

\index{sed=\texttt{sed}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{seq}\label{seq}\index{seq=\texttt{seq}|(textbf}\marginpar{GNU!}

Oft wird eine auf- oder absteigende Sequenz aufeinanderfolgender Zahlen
benötigt, beispielsweise um eine Schleife 100 mal zu durchlaufen. Es ist nicht
sehr performant bei jedem Schleifendurchlauf hochzuzählen und dann die
entstandene Zahl mit dem Limit zu vergleichen. Daher nimmt man an der Stelle
\texttt{seq} zur Hilfe, wenn es zur Verfügung steht.

Die zu zählenden Werte werden durch drei unterschiedliche Arten der
Parametrisierung definiert: Ein Aufruf in der Form \lstinline|seq 10| gibt die
Zahlen von 1 bis 10 aus. Mit \lstinline|seq 10 20| wird von 10 bis 20 gezählt,
und \lstinline|seq 20 -2 10| zählt in zweierschritten rückwärts von 20 nach 10.

Per default kommen die Werte zeilenweise, mit dem Parameter \texttt{-s} kann
aber auch ein anderes Trennzeichen definiert werden. Will man etwas numerieren
und später nach den Zahlen sortieren, ist es sinnvoll wenn `schmalere' Zahlen
mit führenden Nullen aufgefüllt werden. Das erreicht man mit dem Parameter
\texttt{-w}.

\index{seq=\texttt{seq}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sleep}\label{sleep}\index{sleep=\texttt{sleep}|(textbf}

Das Kommando \texttt{sleep} veranlaßt die Shell, für eine angegebene Zeit zu
warten. Die Zeit wird dabei in Sekunden angegeben.

In der GNU-Variante\marginpar{GNU!} von \texttt{sleep} kann die Einheit der
angegebenen Zeitspanne durch Suffixe definiert werden: \lstinline|sleep 10s|
schläft zehn Sekunden, \lstinline|sleep 10m| zehn Minuten. Genauso werden
Stunden (h) und Tage (d) definiert.

Außerdem kann die GNU-Variante auch mit nicht-Integer Zeiten arbeiten:
\lstinline|sleep 0.5| schläft eine halbe Sekunde.

\index{sleep=\texttt{sleep}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sort}\label{sort}\index{sort=\texttt{sort}|(textbf}

Mit diesem Befehl wird wie der Name schon andeutet sortiert. Wenn kein
Dateiname als Parameter angegeben wird, liest \texttt{sort} von der
Standard-Eingabe. Geschrieben wird immer auf der Standard-Ausgabe.

Man kann sich vorstellen, daß ein solches Kommando recht flexibel sein muß,
daher stehen eine Menge Parameter zur Verfügung:

\LTXtable{\textwidth}{tab_kommandos_sort_parameter.tex}

Die Sortierung nach der Spalte (mit \texttt{-k}) ist etwas tricky. Die genaue
Syntax wird in der Man-Page mit \texttt{-k POS1[,POS2]} angegeben, das bedeutet
man muß einen Parameter angeben, man kann bei Bedarf einen zweiten angeben.
Bei der Sortierung wird dann der Bereich ab POS1, bzw. der Bereich zwischen
POS1 und POS2 berücksichtigt.

Dabei lautet die Syntax für POS \texttt{F[.C][OPTS]}. Dabei gibt F die
Feldnummer an (siehe Parameter \texttt{-t}). Wenn nicht nach dem Feld an sich
sortiert werden soll, kann C die Position des Zeichens innerhalb des Feldes
angeben. Und als ob das noch nicht kompliziert genug wäre, kann man dem ganzen
Konstrukt noch einen einbuchstabigen Parameter für die Sortier-Option mitgeben.

Wenn das angegebene Feld nicht existiert wird nach der ganzen Zeile sortiert.

OK, Beispiele:

\LTXtable{\textwidth}{tab_kommandos_sort_beispiele.tex}

Weitere Parameter verrät wie immer die Man-Page.

\index{sort=\texttt{sort}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{tail}\label{tail}\index{tail=\texttt{tail}|(textbf}

Der Befehl \texttt{tail} gibt die letzten zehn Zeilen einer Datei aus. Wenn
kein Dateiname (oder ein \texttt{-}) angegeben wird, liest \texttt{tail} von
der Standard-Eingabe. Man kann die Anzahl der ausgegebenen Zeilen mit dem
Parameter \texttt{-n} steuern.

Mit dem Parameter \texttt{-f} (follow) gibt \texttt{tail} neue Zeilen aus,
sobald sie an die Datei angehängt werden.

Die GNU-Version\marginpar{GNU!} kann auch das Ende mehrere Dateien ausgeben
bzw. verfolgen, wenn mehrere Namen angegeben werden.

\index{tail=\texttt{tail}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{tee}\label{tee}\index{tee=\texttt{tee}|(textbf}

Dies ist praktisch ein T-Stück für Pipes. \texttt{tee} liest von seiner
Standard-Eingabe, und gibt alle Eingaben direkt auf der Standard-Ausgabe wieder
aus. Nebenbei werden die Ausgaben in eine oder mehrere Dateien geschrieben.

Wenn die Ausgabedateien schon existieren, werden sie überschrieben. Dieses
Verhalten kann mit dem Parameter \texttt{-a} geändert werden.

\index{tee=\texttt{tee}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{touch}\label{touch}\index{touch=\texttt{touch}|(textbf}

Mit diesem Kommando kann man einerseits Dateien anlegen wenn sie nicht
existieren, und andererseits die Änderungs- und Zugriffszeiten einer Datei
ändern. Ohne die Angabe weiterer Parameter wird die Datei erzeugt wenn sie
nicht existierte, bzw. in ihrer Änderungs- und Zugriffszeit auf die aktuelle
Zeit gesetzt.

Mit dem Parameter \texttt{-a} wird nur die Zugriffs-, mit \texttt{-m} nur die
Änderungszeit gesetzt. Mit \texttt{-c} kann die Erstellung einer neuen Datei
unterdrückt werden.

Die eingesetzte Zeit kann auch durch die Parameter \texttt{-t} bzw. \texttt{-d}
angegeben werden. Mit \texttt{-r} kann die Zeit der einer angegebenen
Referenzdatei angepaßt werden.

\index{touch=\texttt{touch}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{tr}\label{tr}\index{tr=\texttt{tr}|(textbf}

Will man ganze Worte oder komplexe Muster in Dateien oder Pipes suchen und
ersetzen, greift man üblicherweise zu \texttt{sed} (Abschnitt \ref{sed}). Für
einzelne Buchstaben nimmt man hingegen \texttt{tr}.

Normalerweise wird \texttt{tr} mit zwei Zeichenketten als Parametern
aufgerufen und übernimmt die zu konvertierenden Daten von der Standard-Eingabe.
Jedes Zeichen im eingehenden Datenstrom wird anhand der beiden Zeichenketten
ersetzt, dabei wird das erste Zeichen der ersten Kette durch das erste Zeichen
der zweiten Kette ersetzt, das zweite durch das zweite, und so weiter.

Ist die zweite Zeichenkette länger als die erste, werden überschüssige Zeichen
ignoriert. Ist die zweite Zeichenkette kürzer als die erste, wird ihr letztes
Zeichen so lange wiederholt bis sie gleich sind. Durch den Parameter
\texttt{-t} kann dieses Verhalten abgeschaltet werden, so daß überschüssige
Zeichen abgeschnitten werden.

Mit dem Parameter \texttt{-c} wird die erste Zeichenkette `invertiert', es
werden also alle Zeichen ersetzt die nicht darin vorkommen.

\texttt{tr} kann aber auch mit nur einer Zeichenkette aufgerufen werden, wenn
die Parameter \texttt{-d} oder \texttt{-s} benutzt werden. Mit \texttt{-d}
werden alle Zeichen aus dem Eingabestrom gelöscht, die in der Zeichenkette
vorkommen. Mit \texttt{-s} werden doppelt vorkommende Zeichen durch ein
einzelnes ersetzt.

Die Zeichenketten an sich können übrigens nicht nur Buchstaben oder Zahlen
enthalten, sondern auch Sonderzeichen oder Zeichenklassen. Näheres dazu steht
in der Man-Page.

Die folgenden Beispiele verdeutlichen die Anwendung:

\begin{lstlisting}
text="Dies ist ein Testtext"

# kleine Umlaute durch grosse ersetzen:
echo "$text" | tr aeiou AEIOU
# -> DIEs Ist EIn TEsttExt

# Kleinbuchstaben durch Großbuchstaben ersetzen:
echo "$text" | tr a-z A-Z
# -> DIES IST EIN TESTTEXT

# alle Vokale durch Unterstriche ersetzen:
echo "$text" | tr aeiouAEIOU _
# -> D__s _st __n T_stt_xt

# Großbuchstaben löschen:
echo "$text" | tr -d A-Z
# -> ies ist ein esttext

# doppelte Buchstaben löschen:
echo "$text" | tr -s "a-zA-Z"
# -> Dies ist ein Testext

# doppelte Buchstaben löschen, mit Zeichenklasse:
echo "$text" | tr -s "[:alpha:]"
# -> Dies ist ein Testext
\end{lstlisting}

\index{tr=\texttt{tr}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{trap}\label{trap}\index{trap=\texttt{trap}|(textbf}

Wie alle anderen Prozesse in einem Unix-System auch, so können auch
Shell-Skripte Signale empfangen. Diese können durch Kommandos wie \texttt{kill}
(Abschnitt \ref{kill}) geschickt worden sein, oder zum Beispiel durch einen
Tastatur-Interrupt.

Mit \texttt{trap} kann ein Skript darauf vorbereitet werden, ein oder mehrere
Signale zu empfangen. Beim Aufruf wird eine Aktion mitgegeben, und eine oder
mehrere Bedingungen die zum Ausführen der Aktion führen sollen. Das folgende
Kommando gibt zm Beispiel eine Fehlermeldung aus wenn sein Skript ein Signal 1
(HUP), 2 (INT) oder 15 (TERM) erhält:

\lstinline|trap 'echo "`basename $0`: Ooops..." 1>&2' 1 2 15|

Die Zeile ist dem Beispiel aus Abschnitt \ref{traps} entnommen, dort findet
sich auch nochmal eine ausführliche Erklärung.

\index{trap=\texttt{trap}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{uniq}\label{uniq}\index{uniq=\texttt{uniq}|(textbf}

Mit dem Kommando \texttt{uniq} werden doppelt vorkommende Zeilen in einer
Eingabedatei oder der eingehenden Pipe (Standard-Eingabe) bearbeitet. Per
default steht `bearbeitet' an dieser Stelle für `gelöscht', aber durch
Parameter kann dieses Verhalten angepaßt werden:

\LTXtable{\textwidth}{tab_kommandos_uniq_parameter.tex}

Achtung: \texttt{uniq} betrachtet beim Vergleich nur direkt aufeinander
folgende Zeilen. Sollen alle Duplikate Dateiweit betrachtet werden, bietet sich
ein `vorsortieren' mit \texttt{sort} (Abschnitt \ref{sort}) an, vielleicht
sogar ausschließlich ein \texttt{sort -u}.

\index{uniq=\texttt{uniq}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{wc}\label{wc}\index{wc=\texttt{wc}|(textbf}

Wie der Name schon suggeriert\footnote{Oder etwa nicht?!? ;-)} kann man mit
diesem Kommando Wörter zählen (word count). Gezählt wird entweder in einer
Datei, oder~--~wenn kein Dateiname angegeben wurde~--~in der Standardeingabe.

Weitaus häufiger wird aber der Parameter \texttt{-l} benutzt, mit dem sich die
Zeilen zählen lassen. Weiterhin kann man Bytes (\texttt{-c}) oder Zeichen
(\texttt{-m}) zählen lassen.

Der Parameter \texttt{-L} gibt in der GNU-Version \marginpar{GNU!} die Länge
der längsten enthaltenen Zeile aus.

\index{wc=\texttt{wc}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{which}\label{which}\index{which=\texttt{which}|(textbf}\marginpar{GNU!}

Sucht im Pfad (vordefinierte Variable
\texttt{\$PATH}\index{\$PATH=\texttt{\$PATH}}, siehe Abschnitt
\ref{vordefinierte_variablen}) nach einer Ausführbaren Datei. Wenn mehrere
Dateien auf das Suchwort passen wird die erste Fundstelle ausgegeben, also die
Datei die tatsächlich ausgeführt würde. Mit \texttt{-a} werden alle Fundstellen
ausgegeben.

\index{which=\texttt{which}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{who}\label{who}\index{who=\texttt{who}|(textbf}

Das Kommando \texttt{who} gibt eine Liste aller angemeldeten Benutzer, zusammen
mit deren aktueller Konsole und der Anmeldezeit aus.

\index{who=\texttt{who}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{xargs}\label{xargs}\index{xargs=\texttt{xargs}|(textbf}

Bisweilen kommt man in die Verlegenheit, versehentlich zu lange Einzeiler
geschrieben zu haben. Neben den Fällen, in denen der Tipp-Eifer überhand
genommen hat handelt es sich in aller Regel um Zeilen in der Art
\lstinline|grep 'text' $(find / -name \*.txt)|. Dieses Kommando sucht alle
Dateien mit der Endung txt, die im System vorhanden sind. Diese werden `in die
Kommandozeile eingebaut'. Wenn sehr viele Dateien gefunden werden, wird die
Zeile zu lang für die Shell\footnote{Die maximale Länge der Kommandozeile
unterscheidet sich von System zu System}.

Ein weiterer und in der Praxis mindestens ebenso sinnvoller Einsatzzweck ist
das Vermeiden von Schleifen. Das obige Problem ließe sich auch mit einer Zeile
in der Form \lstinline|find / -name \*.txt -exec grep 'text' {} \;| lösen.
Allerdings hätte das den Nachteil, daß für jede gefundene Datei ein neuer
\texttt{grep} gestartet werden muß. Das kostet Resourcen.

Beide Probleme werden durch eine Zeile in der Form
\lstinline+find / -name \*.txt | xargs grep 'text'+ umgangen. Dabei liest
\texttt{xargs} aus der Standardeingabe die Parameter, die dann an den
\texttt{grep}-Aufruf angehängt werden. Sollten zu viele Dateien gefunden
werden, wird \texttt{grep} mehrfach aufgerufen, allerdings im Gegensatz zum
obigen Beispiel nicht einmal pro Fundstelle.

Neben einigen anderen Parametern informiert die Manpage der
GNU-Version\marginpar{GNU!} über die Option \texttt{-r}. Damit kann vermieden
werden, daß \texttt{xargs} das Kommando startet wenn keine Eingabe vorhanden
ist. Bezogen auf das angegebene Beispiel würde \texttt{grep} ohne Dateinamen
gestartet, wenn \texttt{find} nichts findet. Es würde auf Input von der
Standardeingabe warten, der aber wahrscheinlich nicht kommt. Das Skript würde
hängen, wenn der Parameter \texttt{-r} nicht angewandt würde.

\index{xargs=\texttt{xargs}|)}