Shell-Programmierung/werkzeugkasten.tex

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

Durch die gezeigten Steuerungsm<73>glichkeiten stehen dem Shell-Pro\-grammie\-rer
M<EFBFBD>g\-lich\-kei\-ten offen, fast alle g<>ngigen Algorithmen zu implementieren. Es
ist tats<74>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 ein eigenes Binary aufgerufen wird.} ein eigener Proze<7A> gestartet. Das
kostet nat<61>rlich Zeit und Speicher.

Zeitkritische Anwendungen sind also kein Einsatzgebiet f<>r Shell-Skripte. Die
schreibt man besser in Perl, Python, 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<EFBFBD>\-gung, die einem die Entwicklung entsprechender eigener Routinen
ersparen.  Diese externen Kommandos sind zudem in anderen Sprachen geschrieben
worden, so da<64> 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<EFBFBD>glichkeiten vorgestellt werden. Eine vollst<73>ndige Beschreibung w<>re
(wenn <20>berhaupt m<>glich) viel zu lang, um an dieser Stelle untergebracht zu
werden. \textbf{Dies ist also nur ein grober <20>berblick, nicht mal ann<6E>hernd
eine vollst<73>ndige Referenz!} F<>r ausf<73>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<61>rlich beides. ;-)

Eine globale Beschreibung aller g<>ngigen Kommandos w<>rde den Rahmen dieses
Textes sprengen. Au<41>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<75>chst
typische Aufgaben beschrieben. Diese enthalten `Links' zu den in Frage
kommenden Werkzeugen. Danach gibt es eine alphabetische Aufz<66>hlung der
wichtigsten Kommandos.

\begin{dinglist}{43}
\item Viele der hier vorgestellten Kommandos stehen in erweiterten Versionen
zur Verf<72>gung. Besonders auf GNU-Systemen~--~und somit auch auf Linux~--~gibt
es viele sehr n<>tzliche Parameter, die man sich auf `standardkonformeren'
Systemen nur w<>nschen kann. Diese Vorteile sind allerdings mit Vorsicht zu
genie<EFBFBD>en: Wenn sie zum Einsatz kommen sind die entstehenden Skripte nicht mehr
plattformunabh<EFBFBD>ngig.

Um <20>berraschungen zu vermeiden wurde versucht, diese Besonderheiten kenntlich
zu machen. Stellen mit einer Markierung wie in diesem Absatz sind also
besonders zu betrachten.
\end{dinglist}


\section{N<EFBFBD>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<64> 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<65>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<72>gung.
Und schlu<6C>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{date} (\ref{date}): Datum oder Zeit 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<EFBFBD>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<69>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<6E>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<61>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<61>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 <20>ndern
\item \texttt{chmod} (\ref{chmod}): Zugriffsrechte einer Datei <20>ndern
\item \texttt{chown} (\ref{chown}): Eigent<6E>mer einer Datei <20>ndern
\item \texttt{cmp} (\ref{cmp}): Bin<69>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 <20>ndern
\item \texttt{which} (\ref{which}): Ausf<73>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 <20>ber Befehlsformen
(\ref{befehlsformen}) vorgestellt. Im wesentlichen besteht es darin, da<64> 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<EFBFBD>destiniert, obwohl die meisten auch alleine eingesetzt werden k<>nnen.

<EFBFBD>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<61>r liegt darin, da<64> diese Programme bei jedem Einsatz gestartet
und ausgef<65>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<EFBFBD>management}\label{prozessmanagement}

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

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

\begin{itemize}
\item \texttt{kill} (\ref{kill}): Signal an einen Proze<7A> schicken
\item \texttt{killall} (\ref{killall}): Signal an mehrere Prozesse schicken
\item \texttt{ps} (\ref{ps}): Proze<7A>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
\item \texttt{wait} (\ref{wait}): Auf einen Proze<7A> warten
\end{itemize}


\section{... und H<>mmer}\label{haemmer}

Um es noch einmal zu betonen: \textbf{Dies ist keine vollst<73>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}

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

Oben wurde \texttt{awk} `Skriptsprache' genannt. Das ist insofern richtig, als
da<EFBFBD> es eine m<>chtige und komplexe Syntax zur Verf<72>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<64> zun<75>chst die Daten spezifiziert werden mit denen gearbeitet
werden soll, dann folgen die auszuf<75>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 <20>ber mehrere Zeilen gehen:
awk '
{
  print $1;
  print $2;
}' datei.txt

# Alternativ k<>nnen die Kommandos auch in eine eigene Datei gespeichert
# und <20>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<42>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<75>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<67><72>eren Wert hat als das erste.
\item Mit Operatoren f<>r das Pattern-Matching, <20>hnlich wie in Perl (\texttt{\~}
oder \texttt{!\~})
\item \texttt{BEGIN} kennzeichnet Prozeduren, die vor der Bearbeitung anderer
Bl<EFBFBD>cke zum Tragen kommen sollen.
\item Analog dazu gibt es ein \texttt{END}, mit dem abschlie<69>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<74>lt:
/regexp/ { print $1 }

# Datens<6E>tze mit mehr als zwei Feldern ausw<73>hlen:
NF > 2

# Das dritte und das zweite Feld jeder Zeile ausgeben, deren erstes Feld
# den String 'WICHTIG' enth<74>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<47><72>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<47><72>e aller TeX-Files:", summe, "kB" }

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

# Alle Hosts aus der /etc/hosts anpingen, mu<6D> 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
<EFBFBD>bergeben. Der in der Angabe enthaltene Pfad wird abgeschnitten, nur der Name
der eigentlichen Datei wird zur<75>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, <20>hnlich wie bei \texttt{expr} um einen
Taschenrechner. Allerdings verf<72>gt dieses Kommando um eine vergleichsweise
komplexe Syntax, die auch Berechnungen mit hoher Genauigkeit zulassen.

F<EFBFBD>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<EFBFBD>nnen mehrere Dateien per \lstinline|cat datei1.txt datei2.txt > datei.txt|
verkettet werden.

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

\begin{dinglist}{43}
\item GNU-\texttt{cat} verf<72>gt <20>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<66>t
werden.
\end{dinglist}

\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<65>rt einem Benutzer und einer Gruppe. Letzteres l<><6C>t sich mit
\texttt{chgrp} einstellen. Als Parameter wird der Name oder die ID der Gruppe,
sowie ein oder mehrere Dateinamen <20>bergeben. Verzeichnisse k<>nnen rekursiv mit
dem Parameter \texttt{-R} bearbeitet werden.

Der Eingent<6E>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<72>gt jede Datei <20>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<42>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<75>tzlich gibt es hier noch die Angabe All (a), mit denen
die Rechte f<>r alle Benutzer ver<65>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<73>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<EFBFBD>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<69>rzahl
vorstellt. Das x steht an der niederwertigsten Stelle, erh<72>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<73>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<75>nfigen
Benutzers an, in der Form name:gruppe k<>nnen sowohl User- als auch Gruppen-ID
gleichzeitig ge<67>ndert werden.

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

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


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

\begin{dinglist}{43}
\item Dies ist kein Standard-Kommando, es steht nicht auf allen Systemen zur
Verf<EFBFBD>gung.
\end{dinglist}

Mit diesem Kommando bietet sich dem Administrator des Systems die
M<EFBFBD>g\-lich\-keit, scriptgesteuert die Pa<50>w<EFBFBD>rter f<>r neue Benutzer zu vergeben.
Manuell <20>ndert man ein Pa<50>wort mit dem Kommando
\texttt{passwd}\index{passwd=\texttt{passwd}}, allerdings l<>scht (flusht)
dieses Programm die Standard-Eingabe, bevor es das neue Pa<50>wort erwartet. Somit
lassen sich Pa<50>w<EFBFBD>rter mit \texttt{passwd} nur interaktiv <20>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<EFBFBD>wort-Kombinationen an die Standard-Eingabe zu <20>bergeben:

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

Allerdings sollte dabei aus Sicherheitsgr<67>nden darauf geachtet werden, da<64>
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<><6C>t sich die Ausgabe von Unterschieden unterdr<64>cken, der
Exit-Status gibt weiterhin das Ergebnis an.

\begin{dinglist}{43}
\item In der GNU-Version 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}).
\end{dinglist}

\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 <20>berschrieben. Letzteres erm<72>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<75>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<61>r kann eins
der Formate N, N-, N-M oder -M benutzt werden.

\LTXtable{\textwidth}{tab_kommandos_cut_beispiele.tex}

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

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


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

Ein einfacher Aufruf von \texttt{date} f<>hrt zu einem Ergebnis in der Art:

\lstinline|Do Jan 27 00:17:51 CET 2005|

Wie man sieht, wird das Datum auf dem System entsprechend der lokalen
Einstellungen ausgegeben. Auf diesem Rechner ist das deutsch, auf den meisten
Rechnern wird Englisch voreingestellt sein.

Neben dieser umfassenden aber starren Ausgabe ist es m<>glich, das Datum den
eigenen W<>nschen entsprechend zu formatieren. Ein paar Beispiele:

\begin{lstlisting}
$ date +"%d.%m.%y, %H:%M"
27.01.05, 00:17

$ date +"Heute ist %A."
Heute ist Donnerstag.

$ date +"%A ist der %u. Tag der Woche."
Donnerstag ist der 4. Tag der Woche.
\end{lstlisting}

Die zur Formatierung bereitstehenden Platzhalter stehen in der Man-Page.
Eigentlich sollte \texttt{\%s} zur Ausgabe der Unix-Systemzeit
\footnote{Sekunden seit dem 01.01.1970, 0:00 Uhr} ein naheliegender Parameter
sein, leider steht er nur in der GNU-Version von \texttt{date} zur Verf<72>gung.

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


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

Mit \texttt{diff} werden zwei Dateien verglichen, und die <20>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<67>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<75>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<64> auch
der echo-Befehl <20>ber Parameter verf<72>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<><6C>t sich wohl am ehesten durch ein kleines
Beispiel erkl<6B>ren:

\LTXtable{\textwidth}{tab_kommandos_eval_beispiel.tex}

Bevor eine Zeile in der Shell tats<74>chlich ausgef<65>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. Wenn \texttt{arr} der Name des Arrays und
\texttt{index} der Name der Variablen ist, die den Index des auszugebenden
Elementes enth<74>lt, dann kann durch die folgende Zeile der Inhalt eines
Array-Elementes ausgegeben werden:

\lstinline|eval echo \$arr$index|

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


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

Mit dem Kommando \texttt{expr} verf<72>gt die Shell praktisch <20>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<EFBFBD>h\-ren, sondern ganz allgemein `Ausdr<64>cke evaluieren'. Damit ist
gemeint, da<64> 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<65>cksichtigen,
sie sind also durch Anf<6E>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<69>end die durchzuf<75>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<6B>pfung, mit einem
vorangestellten \texttt{!} k<>nnen Kriterien negiert werden. Die AND-Verkn<6B>pfung
mu<EFBFBD> nicht explizit angegeben werden, wenn mehrere Kriterien verwandt werden.
Komplexere Ausdr<64>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<67><72>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<74>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<74>ge au<61>er symbolischen Links, in die jeder schreiben
# darf:
find / \! -type l -perm 777

# Suche alle Dateien unter dem Homeverzeichnis, deren Gr<47><72>e 10000000
# Bytes <20>bersteigt und gib sie ausf<73>hrlich aus:
find ~ -size +10000000c -exec ls -l {} \;

# Suche alle Eintr<74>ge im Homeverzeichnis, die innerhalb der letzten zwei
# Tage ge<67>ndert wurden:
find ~ -mtime -2
\end{lstlisting}

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

Die Ausf<73>hrung von \texttt{find} erzeugt unter Umst<73>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<EFBFBD>r schnell wechselnde Best<73>nde.

\textbf{Alternative 2:} Sucht man nach einer ausf<73>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<EFBFBD>rer Ausdr<64>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<73>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<64>ufige Annahme ist, da<64> 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<7A>. Ohne
weitere Parameter ist das tats<74>chlich ein SIGTERM, das den Proze<7A> im Regelfall
dazu bewegt sich zu beenden. Jeder Admin kennt das Verfahren, einem h<>ngenden
Proze<EFBFBD> mittels \texttt{kill -9} den Gnadenschu<68> zu geben. Die 9 steht dabei f<>r
das Signal mit der Nummer 9, SIGKILL. Noch ein gebr<62>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<72>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<7A>-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}

Im Abschnitt <20>ber \texttt{kill} (\ref{kill}) wird beschrieben, wie man ein
Signal an einen Proze<7A> schickt, dessen ID bekannt ist. Kennt man die ID nicht,
oder will man das Signal an mehrere Prozesse schicken, kann dieses Kommando auf
vielen Systemen eine gro<72>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<64>ckt die Ausgaben.

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

Eine <20>hnliche Funktionalit<69>t bietet auch das Kommando \texttt{pkill} (Abschnitt
\ref{pkill}), allerdings hat \texttt{killall} den Vorteil da<64> es auf mehr
Systemen zur Verf<72>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 <20>ber ihr tun
informieren.

Der zu loggende Text wird einfach als Parameter <20>bergeben.

\begin{dinglist}{43}
\item Die GNU-Version verf<72>gt <20>ber einige Parameter, unter anderem kann die
Nachricht mit \texttt{-s} parallel zum System-Log auch auf der
Standard-Fehlerausgabe ausgegeben werden.
\end{dinglist}

\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<><6C>t. Hier sind die wichtigsten,
eine vollst<73>ndige Auflistung bietet wie immer die Man-Page.

\begin{dinglist}{43}
\item Einige der folgenden Parameter entsprechen nicht dem allgemeinen
Standard:
\end{dinglist}
\LTXtable{\textwidth}{tab_kommandos_ls_parameter.tex}

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

\lstinline|-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 <20>hnliches\footnote{Siehe
Man-Page} handelt. Die rwx-Bl<42>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<EFBFBD>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<65>rt. Diese
Parameter werden mit \texttt{chown} (Abschnitt \ref{chown}) bzw. \texttt{chgrp}
(Abschnitt \ref{chgrp}) gesetzt.

Es folgt die Gr<47><72>e der Datei in Bytes, sowie das Datum der letzten <20>nderung.
Liegt dieses mehr als ein halbes Jahr zur<75>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<EFBFBD>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 <20>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<EFBFBD>hrend mit \texttt{cut} (Abschnitt \ref{cut}) Dateien spaltenweise zerlegt
werden, werden sie mit \texttt{paste} zusammengef<65>hrt. Die Dateinamen werden
als Parameter <20>bergeben, woraufhin Zeile f<>r Zeile die Inhalte aller Dateien zu
einer Tabelle gemacht werden.

Die Spalten werden standardm<64><6D>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}

\begin{dinglist}{43}
\item Dies ist kein Standard-Kommando, es steht nicht auf allen Systemen zur
Verf<EFBFBD>gung.
\end{dinglist}

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

\lstinline|pgrep -lf httpd|

<EFBFBD>ber weitere Parameter l<><6C>t sich genauer spezifizieren, wonach gesucht werden
soll, hier die wichtigsten:

\LTXtable{\textwidth}{tab_kommandos_pgrep_parameter.tex}

Die Ausgabe enth<74>lt per Default nur die Proze<7A>-IDs der Fundstellen. Diese l<><6C>t
sich als Parameter f<>r andere Programme benutzen. Das folgende Beispiel liefert
detaillierte Informationen <20>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}

\begin{dinglist}{43}
\item Dies ist kein Standard-Kommando, es steht nicht auf allen Systemen zur
Verf<EFBFBD>gung.
\end{dinglist}

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<EFBFBD>nden viele Prozesse beendet, sollten \textbf{die verwendeten Parameter
genau unter die Lupe} genommen werden, um `Kollateralsch<63>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<6C>t beispielsweise den Syslog-Daemon,
seine Konfiguration neu einzulesen:

\lstinline|pkill -HUP syslogd|

Das Kommando \texttt{killall} (Abschnitt \ref{killall}) bietet eine <20>hnliche
Funktionalit<EFBFBD>t, allerdings fehlen ihm einige Parameter. Trotzdem sollte im
Zweifel \texttt{killall} benutzt werden, da es auf mehr Systemen zur Verf<72>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<74>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<72>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 <20>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 <20>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<68> 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<73>hrlich beschrieben.}.

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

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

\begin{dinglist}{43}
\item Das Kommando versteht in der GNU-Version zwei unterschiedliche Arten von
Optionen. Den sogenannten Unix- bzw. Posix-Stil und den BSD-Stil. Zus<75>tzlich
gibt es noch ausf<73>hrliche Parameter, aber die sollen hier nicht beschrieben
werden. Die jeweiligen Formen stehen nicht auf allen Systemen zur Verf<72>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 <20>bliche Angabe mit Bindestrich aus.
BSD-Pa\-ra\-me\-ter werden ohne Bindestrich angegeben, was neben den meisten
anderen Kommandos etwas ungewohnt aussieht.
\end{dinglist}

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<7A>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<65>ren:
ps -U root -u root -N

# Nur die Proze<7A>-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<EFBFBD>r die Suche nach Prozessen bestimmten Namens steht auf manchen Systemen auch
das Kommando \texttt{pgrep} (Abschnitt \ref{pgrep}) zur Verf<72>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 <20>blicherweise einer
oder mehrere Variablennamen <20>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<72>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<63>tzt werden. Ein Backslash vor einem Newline
bewirkt also eine mehrzeilige Eingabe. Dieses Verhalten kann mit dem Parameter
\texttt{-r} abgeschaltet werden.

\begin{dinglist}{43}
\item Normalerweise wird eine Eingabezeile mit einem Newline abgeschlossen. Mit
dem Parameter \texttt{-d} 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} 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} 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} <20>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<72>lt.

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

Mit \texttt{-t} 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.
\end{dinglist}

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<65>scht werden. Dabei
kann man vorsichtig vorgehen, indem man mit \texttt{-i} daf<61>r sorgt, da<64> jeder
L<EFBFBD>schvorgang be\-st<EFBFBD>\-tigt werden mu<6D>. 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<65>scht.

\begin{dinglist}{43}
\item Die GNU-Version von \texttt{rm} unterst<73>tzt zus<75>tzlich den Parameter
\texttt{-v}, mit dem jeder L<>schvorgang ausgegeben wird.
\end{dinglist}

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


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

Mit \texttt{rmdir} werden Verzeichnisse gel<65>scht. Das funktioniert nur, wenn
sie leer sind. Mit \texttt{-p} kann ein kompletter Verzeichnispfad gel<65>scht
werden, will sagen: Alle h<>her liegenden Verzeichnisse im angegebenen Pfad
werden gel<65>scht. Voraussetzung ist hier nat<61>rlich auch, da<64> die Verzeichnisse
nichts au<61>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<65>scht werden.

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


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

\begin{dinglist}{43}
\item Dies ist kein Standard-Kommando, es steht nicht auf allen Systemen zur
Verf<EFBFBD>gung.
\end{dinglist}

Dieses Kommando eignet sich vorz<72>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<73>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, <20>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<73>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<65>hrt werden soll, mu<6D> 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 <20>ber mehrere Zeilen gehen:
sed '
s/alt/neu/
/loeschen/d' datei.txt

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

Neben den oben erw<72>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.

\begin{dinglist}{43}
\item Die GNU-Version stellt noch ein paar Parameter zur Verf<72>gung, die
Man-Page verr<72>t n<>heres.
\end{dinglist}

\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<75>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<65>ngtes Rufzeichen
negiert werden, der Befehl wirkt dann also auf alle Zeilen die \textbf{nicht}
adressiert wurden.

Aber wie sehen solche Adre<72>angeben aus? Die folgende Tabelle zeigt einige
Beispiele anhand des Kommandos `d', mit dem Zeilen gel<65>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<EFBFBD>gigen Quellen nachgeschlagen werden.

\LTXtable{\textwidth}{tab_kommandos_sed_kommandos.tex}

Mit \texttt{s} wird substituiert. Das hei<65>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:

\lstinline|s/Suchmuster/Ersatzmuster/g|

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

\lstinline|s/Seite ([0-9]*) von ([0-9]*)/\1 aus \2/|

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

\lstinline|y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/|

Normalerweise werden alle Eingabezeilen nach der Bearbeitung wieder ausgegeben,
unabh<EFBFBD>ngig davon ob sie ver<65>ndert wurden oder nicht. Das Verhalten kann <20>ber
den Kommandozeilenparameter \texttt{-n} abgeschaltet werden. Da dann allerdings
nichts mehr ausgegeben wird kann durch ein an ein Kommando angeh<65>ngtes
\texttt{p} bestimmt werden, da<64> die Ver<65>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<6E>cken:
# lies: 'ersetze jeden Zeilenanfang durch f<>nf Leerzeichen'
sed 's/^/     /'

# F<>hrende Blanks (Leerzeichen, Tabulatoren) von den Zeilenanf<6E>ngen
# l<>schen:
# ACHTUNG: An Stelle des \t mu<6D> der Tabulator gedr<64>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<69>ende Blanks l<>schen:
sed 's/^[ \t]*//;s/[ \t]*$//'

# Wenn eine Zeile mit Backslash aufh<66>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<75>ren Ausdruck bis zum Dateiende ausgeben:
sed -n '/regexp/,$p'

# Den Bereich zwischen zwei regul<75>ren Ausdr<64>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<61>er dem Bereich zwischen zwei regul<75>ren Ausdr<64>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}

\begin{dinglist}{43}
\item Dies ist kein Standard-Kommando, es steht nicht auf allen Systemen zur
Verf<EFBFBD>gung.
\end{dinglist}

Oft wird eine auf- oder absteigende Sequenz aufeinanderfolgender Zahlen
ben<EFBFBD>tigt, beispielsweise um eine Schleife 100 mal zu durchlaufen. Es ist nicht
sehr performant bei jedem Schleifendurchlauf hochzuz<75>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<72>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<65>hlt,
und \lstinline|seq 20 -2 10| z<>hlt in zweierschritten r<>ckw<6B>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<73>ter nach den Zahlen sortieren, ist es sinnvoll wenn `schmalere' Zahlen
mit f<>hrenden Nullen aufgef<65>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<6C>t die Shell, f<>r eine angegebene Zeit zu
warten. Die Zeit wird dabei in Sekunden angegeben.

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

Au<EFBFBD>erdem kann die GNU-Variante auch mit nicht-Integer Zeiten arbeiten:
\lstinline|sleep 0.5| schl<68>ft eine halbe Sekunde.
\end{dinglist}

\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<64> ein solches Kommando recht flexibel sein mu<6D>,
daher stehen eine Menge Parameter zur Verf<72>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<6D> 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<65>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<72>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<65>ngt werden.

\begin{dinglist}{43}
\item Die GNU-Version kann auch das Ende mehrere Dateien ausgeben bzw.
verfolgen, wenn mehrere Namen angegeben werden.
\end{dinglist}

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


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

Dies ist praktisch ein T-St<53>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 <20>berschrieben. Dieses
Verhalten kann mit dem Parameter \texttt{-a} ge<67>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 <20>nderungs- und Zugriffszeiten einer Datei
<EFBFBD>ndern. Ohne die Angabe weiterer Parameter wird die Datei erzeugt wenn sie
nicht existierte, bzw. in ihrer <20>nderungs- und Zugriffszeit auf die aktuelle
Zeit gesetzt.

Mit dem Parameter \texttt{-a} wird nur die Zugriffs-, mit \texttt{-m} nur die
<EFBFBD>nderungszeit gesetzt. Mit \texttt{-c} kann die Erstellung einer neuen Datei
unterdr<EFBFBD>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<70>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 <20>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 <20>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 <20>bersch<63>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<64> <20>bersch<63>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<65>scht, die in der Zeichenkette
vorkommen. Mit \texttt{-s} werden doppelt vorkommende Zeichen durch ein
einzelnes ersetzt.

Die Zeichenketten an sich k<>nnen <20>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<72>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<72>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<73>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<72>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<73>hrliche Erkl<6B>rung.

Ein weiterer n<>tzlicher Einsatz f<>r \texttt{trap} ist es, Signale zu
ignorieren. Das kann gew<65>nscht sein, wenn eine Folge von Kommandos in einem
Skript auf keinen Fall unterbrochen werden darf. Um zu verhindern da<64> ein
\Ovalbox{CTRL}+\Ovalbox{C} des Benutzers das Skript beendet wird folgendes
Konstrukt eingesetzt:

\begin{lstlisting}
trap '' 2  # Signal 2 ist Ctrl-C, jetzt deaktiviert.
kommando1
kommando2
kommando3
trap 2     # Reaktiviert Ctrl-C
\end{lstlisting}

Vielleicht w<>re es aber auch dem Benutzer gegen<65>ber freundlicher, auf das
entkr<EFBFBD>ftete Signal hinzuweisen:

\lstinline|trap 'echo "Ctrl-C ist ausser Kraft."' 2|

Eine Sonderbehandlung macht die Shell, wenn als Signal \texttt{DEBUG} angegeben
wird. Dann wird nach jedem ausgef<65>hrten Kommando der Trap ausgel<65>st. Dieses
Feature wird wie der Name schon erahnen l<><6C>t zum Debuggen benutzt, ein Beispiel
findet sich in Abschnitt \ref{fehlersuche}.

\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<65>scht', aber durch
Parameter kann dieses Verhalten angepa<70>t werden.

\begin{dinglist}{43}
\item Einige der folgenden Parameter entsprechen nicht dem allgemeinen
Standard:
\end{dinglist}
\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<69>lich ein \texttt{sort -u}.

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


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

Das Kommando \texttt{wait} wird benutzt um auf die Beendigung eines Prozesses
zu warten. Als Parameter wird eine Proze<7A>-ID <20>bergeben, \texttt{wait} l<>uft so
lange bis sich der Proze<7A> mit der angegebenen ID beendet hat.

Wenn keine Proze<7A>-ID angegeben wurde, wartet \texttt{wait} auf alle
Kind-Prozesse der aktuellen Shell.

Ein Beispiel f<>r die Benutzung findet sich im Kapitel <20>ber Wachhunde (Abschnitt
\ref{wachhunde}).

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


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\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<65>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.

\begin{dinglist}{43}
\item Der Parameter \texttt{-L} gibt in der GNU-Version die L<>nge der l<>ngsten
enthaltenen Zeile aus.
\end{dinglist}

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


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

\begin{dinglist}{43}
\item Dies ist kein Standard-Kommando, es steht nicht auf allen Systemen zur
Verf<EFBFBD>gung.
\end{dinglist}

Sucht im Pfad (vordefinierte Variable
\texttt{\$PATH}\index{\$PATH=\texttt{\$PATH}}, siehe Abschnitt
\ref{vordefinierte_variablen}) nach einer Ausf<73>hrbaren Datei. Wenn mehrere
Dateien auf das Suchwort passen wird die erste Fundstelle ausgegeben, also die
Datei die tats<74>chlich ausgef<65>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 <20>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<69>e sich auch mit einer Zeile
in der folgende Form l<>sen:

\lstinline|find / -name \*.txt -exec grep 'text' {} \;|

Allerdings h<>tte das den Nachteil, da<64> f<>r jede gefundene Datei ein neuer
\texttt{grep} gestartet werden mu<6D>. Das kostet Resourcen. Beide Probleme werden
durch eine Zeile in der folgenden Form umgangen:

\lstinline+find / -name \*.txt | xargs grep 'text'+

Dabei liest \texttt{xargs} aus der Standardeingabe die Parameter, die dann an
den \texttt{grep}-Aufruf angeh<65>ngt werden. Sollten zu viele Dateien gefunden
werden, wird \texttt{grep} mehrfach aufgerufen, allerdings im Gegensatz zum
obigen Beispiel nicht einmal pro Fundstelle.

\begin{dinglist}{43}
\item Neben einigen anderen Parametern informiert die Manpage der GNU-Version
<EFBFBD>ber die Option \texttt{-r}. Damit kann vermieden werden, da<64> \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.
\end{dinglist}

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