\documentclass[a4paper,10pt]{article}
\usepackage[utf8]{inputenc}
\usepackage{ngerman}
%\usepackage{hyperref}
%\usepackage{graphicx}
\usepackage{geometry}
\geometry{a4paper, left=25mm, top=10mm}
\title{Workstation Linuxkurs}
\author{Paul Hänsch, Workstation Ideenwerkstatt Berlin e.V.}

\begin{document}
\maketitle

\footnote*{Dieses Werk ist unter einem Creative Commons Namensnennung-Weitergabe unter gleichen Bedingungen 3.0 Deutschland Lizenzvertrag lizenziert. Um die Lizenz anzusehen, gehen Sie bitte zu \\
http://creativecommons.org/licenses/by-sa/3.0/de/ oder schicken Sie einen Brief an Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.}

\tableofcontents

\pagebreak
\section{Tag 1}

\subsection{Arbeit mit Dateien}
Legen wir mal eine Datei an:\\
\verb#touch datei1#\\

Der Befehl '\verb#ls -l datei1#' zeigt uns detaillierte Informationen:\\
\verb#-rw-rw---- 1 user user 0 Feb 21 16:49 datei1#\\

Was sagt uns das nun?\\
\begin{tabular}{l|l|l|l|l|l|l}
\textbf{Zugriffsrechte} & \textbf{Linkzahl} & \textbf{Eigentümer} & \textbf{Gruppe} & \textbf{Größe} & \textbf{Schreibzeit} & \textbf{Name} \\
\hline
\verb#-rw-rw----# & \verb#1# & \verb#user# & \verb#user# & \verb#0# & \verb#Feb 21 16:49# & \verb#datei1# \\
\end{tabular}\\

Bevor wir uns das näher anschauen schreiben wir mal etwas in die Datei:\\
\verb#echo "Hallo Welt" > datei1#\\

und nochmal '\verb#ls -l datei1#':\\
\begin{tabular}{l|l|l|l|l|l|l}
\textbf{Zugriffsrechte} & \textbf{Linkzahl} & \textbf{Eigentümer} & \textbf{Gruppe} & \textbf{Größe} & \textbf{Schreibzeit} & \textbf{Name} \\
\hline
\verb#-rw-rw----# & \verb#1# & \verb#user# & \verb#user# & \verb#11# & \verb#Feb 21 17:02# & \verb#datei1# \\
\end{tabular}\\

Wir sehen:
\begin{itemize}
\item Die Größe ist von 0 auf 11 gewachsen (11 stücke Kuchen?...)
\item Die Zugriffszeit hat sich verändert (warum wohl?)
\end{itemize}

Die Größe wird natürlich in Byte angegeben, das kann einem bei größeren Dateien schon ziemlich auf den Senkel gehen. Geben wir z.B. mal ein:\\
\verb#ls -l /boot/initrd.img-2.6.30-2-686# (vielleicht heißt die Datei auch ein bisschen anders)\\
$\Rightarrow$\\
\verb#-rw-r--r-- 1 root root 7277035 Jan 17 13:00 /boot/initrd.img-2.6.30-2-686#\\

Soso... die Datei ist also 7277035 Byte groß (je nach System vielleicht auch etwas mehr oder weniger, machen wir uns darum gerade mal keinen Kopf) Die Einheit ist natürlich etwas unpraktisch. Fügen wir dem 'ls'-Befehl mal den Parameter 'h' für ``human readable'' (menschenlesbar) hinzu:\\
\verb#ls -l -h /boot/initrd.img-2.6.30-2-686#\\
$\Rightarrow$\\
\verb#-rw-r--r-- 1 root root 7.0M Jan 17 13:00 /boot/initrd.img-2.6.30-2-686#\\

Jetzt lautet die Ausgabe 7.0M, also 7 Megabyte, 'ls' wählt automatisch eine sinnvolle Einheit. Je nach Dateigröße könnte also z.B. auch der Buchstabe K (Kilobyte) oder G (Gigabyte) dort stehen.\\

Mit dem Befehl 'cat' können wir übrigens den Inhalt der Datei ausgeben:\\
\verb#cat datei 1#\\
$\Rightarrow$\\
\verb#Hallo Welt#\\

Wenn wir jetzt nochmal '\verb#ls -l datei1#' eingeben sehen wir übrigens \textbf{keinen} Unterschied zu vorher:\\
\verb#-rw-rw---- 1 user user 11 Feb 21 17:02 datei1#\\

Die Zugriffszeit ändert sich also nur beim \textbf{Schreiben}, wir haben aber gerade nur aus der Datei \textbf{gelesen}. Der Zeitstempel ändert sich dabei nicht. Nochwas fällt dem aufmerksamen Beobachter ins Auge: Die Datei ist angeblich 11 Byte groß, dabei hat ``Hallo Welt'' nur 10 Zeichen (mit Leerzeichen).\\
Die Antwort ist einfach: Am Ende der Datei steht noch ein Zeilenumbruch, der belegt ein Byte.\\

\subsection{Zugriffsberechtigungen}
Damit ist uns erst mal klar, wofür die felder ``Größe'', ``Schreibzeit'' und ``Name'' stehen. Wenn wir uns jetzt den Zugriffsrechten widmen, interessieren uns drei weitere Felder.\\

\begin{tabular}{l|l|l|l|l|l|l}
\textbf{Zugriffsrechte} & Linkzahl & \textbf{Eigentümer} & \textbf{Gruppe} & Größe & Schreibzeit & Name \\
\hline
\verb#-rw-rw----# & \verb#1# & \verb#user# & \verb#user# & \verb#11# & \verb#Feb 21 17:02# & \verb#datei1# \\
\end{tabular}\\

\begin{itemize}
  \item \textbf{Eigentümer:} ist der Benutzer, der die Datei angelegt hat. Der Eigentümer kann nachträglich nicht verändert werden (außer durch root).
  \item \textbf{Gruppe:} ist die Gruppe, der die Datei zugeordnet ist. Nur der Eigentümer (oder root) kann die Gruppenzugehörigkeit der Datei ändern. Der Eigentümer kann die Datei auch nur einer Gruppe zuordnen, in der er selbst Mitglied ist.
  \item \textbf{Zugriffsrechte:} hier wird es komplizierter, wir müssen uns das näher anschauen.
\end{itemize}

\subsubsection*{Das Feld Zugriffsrechte}
Dieses erste Feld beschreibt in extrem kurz gefasster Weise, \textbf{wer} mit der datei \textbf{was} anfangen darf:\\
\begin{tabular}{l|l|l|l}
\textbf{Typ} & \textbf{Eigentümer} & \textbf{Gruppe} & \textbf{Andere} \\
\hline
\verb#-# & \verb#rw-# & \verb#rw-# & \verb#---# \\
\end{tabular}

Ignorieren wir für den Augenblick den Typ. Wir sehen unter Eigentümer die Buchstaben 'r' und 'w'. An dritter Stelle könnte ein 'x' stehen, dies ist hier jedoch \textbf{nicht} der Fall. Das 'r' steht für ``read'' (lesen) und das 'w' für ``write'' (schreiben). Das heißt der Eigentumer der Datei (in unserem Beispiel ``user'') darf die Datei lesen und darin schreiben. Die Datei ist in diesem Beispiel der Gruppe ``user'' zugeordnet. Die Gruppe ``user'' ist nicht zu verwechseln mit dem Benutzer ``user''! (Das ist wirklich wichtig!) Mitglieder der Gruppe ``user'' haben, wie wir sehen ebenfalls die Berechtigungen 'lesen' (r) und 'schreiben' (w). Auch hier ist der dritte mogliche Buchstabe (x) nicht gesetzt. Unter ``Andere'' ist keiner der drei Buchstaben 'rwx' gesetzt. Andere Benutzer als der Benutzer ``user'' bzw. Benutzer, die nicht wenigstens in der Gruppe ``user'' sind dürfen mir der Datei folglich gar nichts anfangen.\\

Achja, wir reden die ganze Zeit von so einem 'x'. Das 'x' verleiht jemandem die Rechte eine Datei auszuführen ('execute'). Bei einer Datei in der nur ``Hallo Welt'' drin steht gibt es nun wohl kaum was auszuführen. Nur bei Programmen macht das Sinn (und bei Verzeichnissen, aber hier greife ich vor). Wenn wir uns also mal die Rechte von '/bin/cat' anschauen (ja, das ist das Programm 'cat', mit dem wir vorhin die Datei ausgegeben haben). Dann sehen wir:\\
\verb#-rwxr-xr-x 1 root root 46848 Jun  5  2009 /bin/cat#\\

\begin{itemize}
  \item Der Eigentümer, nämlich der Benutzer ``root'', ist der Einzige, der in die Datei schreiben darf.
  \item Die Datei gehort auch der Gruppe ``root'', da in dieser Gruppe niemand Mitglied ist außer der Benutzer ``root'' ist das uninteressant. Es ist übrigens sehr interessant, dass das uninteressant ist, dadurch wird der Gruppenzugehörigkeit nämlich bewusst die Bedeutung genommen. Die Datei ist quasi keiner besonderen Gruppe zugeordnet. Aus diesem Grund ist es üblich jedem Benutzer eine persönliche Gruppe zu verpassen.
  \item Jeder beliebige Benutzer darf das Programm lesen bzw. ausführen (dafür sorgt das 'r' und das 'x'). unter ``Andere''.
\end{itemize}

Jetzt wollen wir mal mit den Rechten unserer Experimentierdatei rumspielen. Zum Ändern der Rechte dient das Programm 'chmod' (``Change Mode'' - Ändern des Zugriffsmodus). Wir können zum Beispiel uns, dem Besitzer der Datei die Leserechte entziehen:\\
\verb#chmod u-r datei1#\\
Das 'u' zeigt an, dass wir die Rechte des Eigentümers (user, der Benutzer der Datei) ändern wollen. Der Besitzer hat hier nur zufällig den Namen ``user'', das Kürzel 'u' wird immer verwendet um den Besitzer anzusprechen. Wir benutzen das Minus-Zeichen (\verb#-#) um Rechte zu entziehen. Das Recht, das wir entziehen ist das Leserecht (r).\\
\verb#ls -l datei1#\\
$\Rightarrow$\\
\verb#--w-rw---- 1 user user 11 Feb 21 17:02 datei1#\\

Wir sehen, der Besitzer der Datei hat kein Leserecht mehr. Probieren wir aus der Datei zu lesen:\\
\verb#cat datei 1#\\
$\Rightarrow$\\
\verb#cat: datei1: Permission denied#\\

Die Meldung ist ``Permission denied'' - Zugriff verweigert. Wir dürfen die Datei einfach nicht mehr lesen.\\
\verb#chmod u+r datei1#\\
\verb#cat datei 1#\\
$\Rightarrow$\\
\verb#Hallo Welt#\\

Durch die Verwendung des Plus-Zeichens haben wir das Leserecht (r) für den Besitzer (u) wieder hinzugefügt.\\

Durch Eingabe des Kommandos '\verb#groups#' finden wir heraus, in welchen Gruppen unser Benutzer Mitglied ist, z.B.:\\
\verb#groups#\\
\verb#user fuse share#\\

An erster Stelle wird die primäre Gruppe unseres Benutzers aufgeführt (im Beispiel ist das die Gruppe ``user''). Die primäre Gruppe ist die Gruppe, der jede neu angelegte Datei standardmäßig zugeordnet wird. Mit dem Kommando 'chgrp' (Change Group - Gruppe Ändern) können wir die Datei einer anderen Gruppe zuordnen \textbf{in der wir Mitglied sind}.\\
\verb#chgrp share datei1#\\
\verb#ls -l datei1#\\
$\Rightarrow$\\
\verb#-rw-rw---- 1 user share 11 Feb 21 17:02 datei1#\\

Alle Benutzer in der Gruppe ``share'' haben jetzt Lese- und Schreibzugriff (rw-) auf die Datei.\\
Mit '\verb#chmod g-rw datei1#' entziehen wir Benutzern der Gruppe (g) ``share'' den Lese- (r) und Schreibzugriff (w):\\
\verb#ls -l datei1#\\
$\Rightarrow$\\
\verb#-rw------- 1 user share 11 Feb 21 17:02 datei1#\\

Mit '\verb#chmod o+r datei1#' geben wir ``anderen'' ('o' wie others) Benutzern den Lesezugriff. ``Andere'' sind Benutzer, die weder Besitzer der Datei sind noch in der Gruppe der Datei Mitglied sind.\\
\verb#-rw----r-- 1 user share 11 Feb 21 17:02 datei1#\\

\subsubsection{Berechtigungen auf Verzeichnissen}
Nehmen wir an unser Benutzer hat das Heimverzeichnis '/home/user', ein '\verb#ls -l -d /home/user#' zeigt uns die Daten des Verzeichnisses an. Der Parameter 'd' sorgt dafür, dass wir das Verzeichnis selbst sehen, nicht dessen Inhalt.\\
\verb#drwx------ 120 user user 7160 Feb 22 13:28 /home/user#\\

Wir sehen zunächst, dass das erste Zeichen in der Modusanzeige mit einem 'd' Belegt ist. Dies zeigt an, dass es sich nicht um eine normale Datei handelt, sondern um ein Verzeichnis (directory).\\
Wir sehen außerdem, dass der Besitzer von dem Verrzeichnis (user) dass Verzeichnis lesen (r), schreiben (w) und ausführen (x) kann.
\begin{itemize}
  \item Ein verzeichnis \textbf{lesen} zu können bedeutet, sehen zu können welche Dateien darin enthalten sind (Mit den Leserechten auf den dateien selbst hat das nichts zu tun).
  \item In ein Verzeichnis \textbf{schreiben} zu können bedeutet Dateien darin anlegen oder löschen zu können, dies ist nämlich eine Änderung am Verzeichnis. Man braucht keine Schreibrechte auf einer Datei, um diese zu löschen.
  \item Ein Verzeichnis \textbf{ausführen} zu können bedeutet, das Verzeichnis betreten zu können und sich die Dateien darin näher anschauen zu können.
\end{itemize}

\pagebreak
\subsection{Zusammenfassung}
Wir haben gelernt, wie man Dateien Anlegt, und wie man mit den Berechtigungen auf Dateien und Verzeichnissen umgeht. Die Folgenden Kommandos haben wir verwendet:\\
\begin{itemize}
  \item \textbf{touch} - zum Anlegen einer Datei
    \subitem \verb#touch foobar# legt eine Datei mit dem Namen 'foobar' an
  \item \textbf{ls} - zum Anzeigen von Dateien und Verzeichnissen
    \subitem \verb#ls# zeigt Dateien im aktuellen Verzeichnis an
    \subitem \verb#ls -l# zeigt Dateien im aktuellen Verzeichnis in detaillierter Form an
    \subitem \verb#ls -l -h# oder \verb#ls -lh# zeigt Dateien im aktuellen Verzeichnis in detaillierter Form mit menschenlesbaren Größenangaben an
    \subitem \verb#ls -l foobar# zeigt detaillierte Informationen nur über die Datei 'foobar' (die sich im aktuellen Verzeichnis befindet) an
    \subitem \verb#ls /home/# zeigt den Inhalt des Verzeichnisses '/home/' an
    \subitem \verb#ls -d /home/# zeigt das verzeichnis '/home/' selbst an
    \subitem \verb#ls -l /home/# zeigt den Inhalt des Verzeichnisses '/home' in detaillierter Form an
    \subitem \verb#ls -l -d /home/# zeigt detaillierte Informationen über das Verzeichnis '/home/' selbst an
    \subitem Die Parameter 'l', 'h' und 'd' sind beliebig kombinierbar und können auch ``zusammngezogen'' werden (z.B. \verb#ls -lh#)
  \item \textbf{echo} - zum Ausgeben von Text (den wir auch in eine Datei leiten können)
    \subitem \verb#echo Hallo Welt# gibt ``Hallo Welt'' aus
    \subitem \verb#echo "Hallo Welt"# gibt genau so ``Hallo Welt'' aus
    \subitem \verb#echo -n Hallo Welt# gibt ``Hallo Welt'' ohne abschließenden Zeilenumbruch aus
    \subitem \verb#echo Hallo Welt > quaquuz# leitet den Text ``Hallo Welt'' in die Datei 'quaquuz'
  \item \textbf{cat} - zum Ausgeben des Inhalts einer Datei
    \subitem \verb#cat foo# gibt den Inhalt der Datei 'foo' aus
    \subitem \verb#cat foo qua# gibt den Inhalt der Datei 'foo' und nahtlos anschließend den Inhalt der Datei 'qua' aus
  \item \textbf{chmod} - zum Ändern des Zugriffsmodus (Zugriffsrechte) einer Datei
    \subitem \verb#chmod u-w bar# entzieht dem Besitzer der Datei 'bar' den Schreibzugriff auf die Datei
    \subitem \verb#chmod o+rx /home/user/# gewährt ``anderen'' Benutzern, also in diesem Sinne Benutzern die weder Besitzer des Verzeichnisses '/home/user/' sind, noch der Gruppe des Verzeichnisses '/home/user/' angehören das Recht Dateien in diesem Verzeichnis zu sehen (r), Details über diese Dateien anzuzeigen (x) und das Verzeichnis zu betreten (x)
  \item \textbf{groups} - um anzuzeigen in welchen Gruppen ein Benutzer Mitglied ist
    \subitem \verb#groups# zeigt die Gruppen des aktuellen Benutzers an
    \subitem \verb#groups user# zeigt die Gruppen des Benutzers 'user' an
  \item \textbf{chgrp} - zum Ändern der Gruppenzuweisung einer Datei
    \subitem \verb#chgrp share foobar# ordnet der Datei 'foobar' die Gruppe 'share' zu. Der Benutzer der den Befehl ausführt muss Mitglied von 'share' sein.
\end{itemize}

\pagebreak
\section{Tag 2}

\subsection{Navigation im Dateisystem}
Wenn der Benutzer eine Kommndozeilenumgebung öffnet, so befindet er sich normalerweise in seinem Heimverzeichnis. In jedem Fall lässt sich das aktuelle Arbeitsverzeichnis feststellen durch Eingabe des Befehls '\verb#pwd#' (print working directory - gib das Arbeitsverzeichnis aus).\\
\verb#pwd#\\
$\Rightarrow$\\
\verb#/home/user#\\

'/home/user' (in diesem Beispiel) ist das Verzeichnis, in dem wir gerade arbeiten. Mit dem Befehl '\verb#cd#' (change directory - ändere das Verzeichnis) können wir ein anderes Verzeichnis (auf das wir Ausführungsrechte haben) betreten. Bevor wir das tun, wollen wir uns aber nochmal umschauen:\\
\verb#ls#\\
$\Rightarrow$\\
...\\

Der Befehl '\verb#ls#' wird alle Dateien im Heimverzeichnis des Benutzers auflisten. Auf den Abdruck der Befehlsausgabe soll hier verzichtet werden, da der Grundzustand des Heimverzeichnisses sich je nach Distribution und Benutzerumgebung stark unterscheiden kann.\\
Mit '\verb#cd ./#' wechseln wir in das (nicht aufgelistete) ``Unterverzeichnis'' './'. Das schauen wir uns sogleich näher an:\\
\verb#cd ./#\\
\verb#ls#\\
$\Rightarrow$\\
...\\

Hoppla.. das sieht ziemlich genau so aus, wie vorher. Warum das ganze? Das Verzeichnis './' ist ein Sonderfall: './' ist immer das Verzeichnis, in dem wir uns gerade befinden. Dessen können wir uns auch noch einmal vergewissern:\\
\verb#pwd#\\
$\Rightarrow$\\
\verb#/home/user# ...das gleiche wie vorher.\\

Es gibt ein weiters ``Sonderverzeichnis'', das ist '../':\\
\verb#cd ../#\\
\verb#pwd#\\
$\Rightarrow$\\
\verb#/home#\\

Wir sehen, dass wir nicht mehr im Verzeichnis '/home/user/' sind, sondern ``nur'' noch in '/home/'. Wir sind ein Verzeichnis \textbf{aufgestiegen}, denn '../' ist immer das \textbf{übergeordnete} Verzeichnis, des Verzeichnisses in dem wir uns gerade befinden.\\
\verb#ls#\\
$\Rightarrow$\\
\verb#alice bob carl dave eve fiona user#\\

Da wir uns in '/home' befinden, hat uns '\verb#ls#' nun alle Dateien und Verzeichnisse unterhalb von '/home/' aufgelistet. wir sehen die Heimverzeichnisse aller Benutzer im System, darunter auch unser eigenes. Vielleicht ist unser Heimverzeichnis das einzige in der Liste, zum Beispiel an unserem Privatrechner, vielleicht existieren aber auch noch 20.000 weitere Benutzer im System, das könnte auf einem Universitätsrechner der Fall sein. Steigen wir noch ein Verzeichnis weiter auf:\\
\verb#cd ../#\\
\verb#pwd#\\
$\Rightarrow$\\
'/'\\

Der Pfad, in dem wir uns befinden wird jetzt nur noch durch einen Schrägstrich (oft englisch als ``slash'' bezeichnet) repräsentiert. Das heißt wir haben die Oberste Verzeichnisebene erreicht, das ``Stamm-'' oder ``Wurzelverzeichnis'' (englisch ``root'' - Wurzel). Wenn wir noch einmal '\verb#cd ../#' eingeben, so wird dies keine Wirkung haben.\\
\verb#ls#\\
$\Rightarrow$\\
\verb#bin    etc    media   proc   sys   var#\\
\verb#boot   home   mnt     root   tmp      #\\
\verb#dev    lib    opt     sbin   usr      #\\

Was wir hier sehen ist eine Auflistung der Unterverzeichnisse (und -dateien) vom Stammverzeichnis. J nach Distribution wird sich die Liste etwas unterscheiden. Im wesentlichen ist sie aber nicht nur bei allen Linuxdistributionen sondern sogar bei allen Unix-Systemen gleich. Unabhangig davon ob wir z.B. vor einem BSD, Solaris oder MacOS X sitzen.\\

Mit '\verb#ls#' können wir auch in die Verzeichnisse hinein gucken, ohne sie zu betreten:\\
\verb#ls /bin/#\\
$\Rightarrow$\\
...\\

\verb#ls /boot/#\\
$\Rightarrow$\\
...\\

\verb#ls /dev/#\\
$\Rightarrow$\\
...\\

...\\

\begin{itemize}
  \item \textbf{/bin} enthält ausführbare Programme, die für das System sehr grundlegend sind.
  \item \textbf{/boot} enthält den Systemkernel und einige Dateien, die damit unmittelbar in Zusammenhang stehen.
  \item \textbf{/dev} enthält Gerätedateien, das ist furchtbar interessant und wir werden in einem der nächsten Kapitel dazu kommen.
  \item \textbf{/etc} enthält systemweite Konfigurationsdateien.
  \item \textbf{/home} enthält die Heimverzeichnisse der Benutzer.
  \item \textbf{/lib} enthält sogenannte Softwarebibliotheken, die von Programmen eingebunden werden um auf bestimmte Funktionen zuzugreifen. Näheres hierzu gehört eher in einen Programmierkurs.
  \item \textbf{/media} ist in einigen Linuxdistributionen vorgesehen um die Verzeichnisbäume externer Laufwerke zu beherbergen.
  \item \textbf{/mnt} dient traditionell dem gleichen Zweck, ist allerdings älter.
  \item \textbf{/opt} wird in einigen Distributionen verwendet um Applikationen zu beherbergen die selbst eine Komplexe Verzeichnisstruktur mitbringen. Z.B. OpenOffice.org.
  \item \textbf{/proc} enthält laufende Prozesse (klingt komisch, ist aber so).
  \item \textbf{/root} ist das Heimverzeichnis des Benutzers root.
  \item \textbf{/sbin} enthält Programme zur Systemverwaltung.
  \item \textbf{/sys} enthält virtuelle Dateien, die den Status des Systems beschreiben.
  \item \textbf{/tmp} ist das systemweite Verzeichnis für temporäre Dateien.
  \item \textbf{/usr} enthält Daten für weniger grundlegende Programme wie z.B. die grafische Benutzeroberfläche.
  \item \textbf{/var} enthält Dateien, die sich im Normalbetrieb des Systems ohne Zutun des Benutzers verändern, z.B. die Systemlogbücher.
\end{itemize}

So wie wir in Verzeichnisse hinein schauen können, ohne sie zu betreten, können wir z.B. auch von unserem Heimverzeichnis aus in das Wurzelverzeichnis gucken:\\
\verb#cd ~# (bringt uns immer in unser Heimverzeichnis)\\
\verb#ls /#\\
$\Rightarrow$\\
...\\

Soso, der alleinstehende Schrägstrich bezeichnet also das Wurzelverzeichnis. Bleiben wir noch in unserem Heimverzeichnis, wir können alles von hier aus machen. Wir können wie gerade schon einmal getan wieder einen Blick ins Verzeichnis '/boot' werfen.\\
\verb#ls /boot/#\\
$\Rightarrow$\\
...\\

Wie nicht anders zu erwarten sehen wir wieder den Inhalt vom '/boot'-Verzeichnis (mindestens einen Kernel und wahrscheinlich noch mehr). Die Verzeichnisangabe begann mit einem Schrägstrich (``slash''), das heißt, dass wir einen Verzeichnispfad ausgehend vom Stammverzeichnis angegeben haben. Solche Pfadangaben bezeichnen wir als \textbf{absolute Pfadangaben}, da sie immer vollkommen \textbf{eindeutig} sind.\\

Das Gegenteil von absoluten Pfadangaben sind \textbf{relative Pfadangaben}. Während aabsolute Pfadangaben immer vom Stammverzeichnis des Dateibaums ausgehen, geht eine relative Pfadangabe von dem Verzeichnis aus, in dem sich der Benutzer im Augenblick befindet. Wechseln wir zur Demonstaration in unser Heimverzeichnis:\\
\verb#cd ~#\\

Hier können wir nun ein Unterverzeichnis anlegen, das geschieht mit dem Befehl '\verb#mkdir#':\\
\verb#mkdir verz1#\\
\verb#ls#\\
$\Rightarrow$\\
... \verb#verz1# ...

Wir sehen in der Verzeichnisausgabe des Heimverzeichnis unser frisch angelegtes unterverzeichnis 'verz1'. mit '\verb#ls#' wollen wir uns dessen Inhalt ausgeben lassen:\\
\verb#ls verz1/#\\
$\Rightarrow$\\
(keine Ausgabe)\\

Wir erhalten keine Ausgabe, das heißt das neu angelegte Verzeichnis ist leer (wie nicht anders zu erwarten). Wir haben uns nur den (nicht vorhandenen) Inhalt von 'verz1' anzeigen lassen, wir haben das Verzeichnis dabei \textbf{nicht} betreten.\\
Vorhin sind wir ein Verzeichnis aufgestiegen, wiederholen wir das einfach mal:\\
\verb#cd ../#\\

Versuchen wir jetzt noch einmal den Inhalt vom gerade angelegten Verzeichnis anzeigen zu lassen, so wie wir es eben getan haben:\\
\verb#ls verz1/#\\
$\Rightarrow$\\
\verb#ls: cannot access verz1: No such file or directory#\\

``Kann auf verz1 nicht zugreifen: Keine solche Datei bzw. Verzeichnis''. Das Verzeichnis 'verz1', existiert offenbar nicht. Wir haben es gerade angelegt und wir haben es seitdem nicht gelöscht, es gibt also keinen Grund, warum es nicht existieren sollte. Es  existiert schlicht und ergreifend nicht an dem \textbf{Ort} zu dem wir uns hinbewegt haben.\\

Nochmal kurz zu absoluten und relativen Pfadangaben:
\begin{itemize}
  \item \textbf{absolute Pfadangaben} beginnen \textbf{immer} mit einem Schrägstrich ('/'), dieser repräsentiert das Stammverzeichnis.
  \item \textbf{relative Pfadangaben} beginnen \textbf{niemals} mit einem Schrägstrich. Sie gehen immer von dem Verzeichnis aus, in dem sich der Benutzer im Augenblick befindet (siehe '\verb#pwd#').
\end{itemize}

Immer wenn wir '\verb#ls verz1/#' ausgeführt haben, haben wir uns also einer relativen Pfadangabe bedient. Wir können, von dem Ort aus, an dem wir uns befinden, das Verzeichnis über seinen absoluten Pfad ansprechen. Erinnern wir uns daran, dass wir im Heimverzeichnis waren, als wir 'verz1' angelegt haben. Dann muss der absolute Pfad von 'verz1' also (in diesem Beispiel) '/home/user/verz1/' sein:\\
\verb#ls /home/user/verz1/#\\
$\Rightarrow$\\
(keine Ausgabe)\\

Es ging offenbar alles gut. Eine absolute Pfadangabe funktioniert unabhängig davon, wo wir uns befinden. Wir befinden uns (wie uns auch '\verb#pwd#' verraten kann) im verzeichnis '/home/'. Von hier aus ist der \textbf{relative} Pfad zu 'verz1' folglich (in diesem Beispiel) 'user/verz1/'.
\verb#ls /home/user/verz1/#\\
$\Rightarrow$\\
(keine Ausgabe)\\

\subsection{Zusammenfassung}
Wir haben gelernt, wie wir uns im Dateisystem Bewegen, wie wir Ordner (gleichbedeutend Verzeichnisse) erstellen und wir haben einen flüchtigen Blick auf die in Unix üblichen Verzeichnisse (/bin, /boot, /etc ...) geworfen. Folgende Befehle haben wir verwendet:\\

\begin{itemize}
  \item \verb#pwd# - zeigt an, in welchem Verzeichnis wir uns aktuell befinden
  \item \verb#cd# - bringt uns in ein angegebenes Verzeichnis
    \subitem \verb#cd ./# bringt uns in das Verzeichnis, in dem wir uns gerade befinden (tut also genau nichts)
    \subitem \verb#cd ../# bringt uns vom aktuellen Verzeichnis ein Verzeichnis nach oben (z.B. von '/home/user' nach '/home')
    \subitem \verb#cd /# bringt uns ins Stammverzeichnis (egal von wo)
    \subitem \verb#cd /var/spool/cron# bringt uns direkt ins Verzeichnis '/var/spool/cron'
  \item \verb#mkdir# - erstellt ein Verzeichnis
    \subitem \verb#mkdir foo# erstellt das Unterverzeichnis 'foo' im aktuellen Verzeichnis
    \subitem \verb#mkdir /tmp/bar# erstellt das Unterverzeichnis 'bar' direkt unterhalb von '/tmp'
\end{itemize}

\pagebreak
\section{Tag 3}

\subsection{Arbeit mit Dateien, Verzeichnissen und Pfaden}
An den vorherigen Tagen haben wir folgende Befehle Kennengelernt:
\begin{itemize}
  \item \textbf{Tag 1}
  \subitem \textbf{touch} legt eine Datei an
  \subitem \textbf{ls} zeigt Dateien und Verzeichnissen an
  \subitem \textbf{echo} gibt einen Text aus
  \subitem \textbf{cat} gibt den Inhalt einer Datei aus
  \subitem \textbf{chmod} ändert den Zugriffsmodus (Zugriffsrechte) auf einer Datei
  \subitem \textbf{groups} zeigt an, in welchen Gruppen ein Benutzer Mitglied ist
  \subitem \textbf{chgrp} ändert die Gruppenzuweisung einer Datei
  \item \textbf{Tag 2}
  \subitem \textbf{pwd} um anzuzeigen, in welchem Verzeichnis wir aktuell arbeiten
  \subitem \textbf{cd} um uns in ein anderes Arbeitsverzeichnis zu bringen
  \subitem \textbf{mkdir} um ein Verzeichnis zu erstellen
\end{itemize}

Die Kommandozeile bietet noch sehr viel mehr Befehle, einige davon sollen hier vorgestellt werden.
\begin{itemize}
  \item \textbf{rm} - ``remove'' (entfernen) löscht die angegebenen Dateien
  \item \textbf{rmdir} - ``remove directory'' (Verzeichnis entfernen) löscht die angegebenen (leeren) Verzeichnisse
  \item \textbf{cp} - ``copy'' (kopiere) kopiert die angegebenen Dateien in ein angegebenes Verzeichnis\\
    oder: kopiert eine angegebene Datei zu einer anderen Datei
  \item \textbf{mv} - ``move'' (verschiebe) verschiebt die angegebenen Dateien in ein angegebenes Verzeichnis\\
    oder: verschiebt eine angegebene Datei zu einer anderen Datei (d.h. \textbf{benennt die Datei um})
\end{itemize}

Zur Übung legen wir ein paar Dateien an, und entfernen sie wieder:\\
\verb#touch foo bar qua#\\
\verb#ls#\\
$\Rightarrow$\\
\verb#bar foo qua ...#\\
\\
\verb#rm foo bar qua#\\
\verb#ls#\\
$\Rightarrow$\\
\verb#...#\\

Das gleich jetzt mit Verzeichnissen:\\
\verb#mkdir quux baz#\\
\verb#ls#\\
$\Rightarrow$\\
\verb#baz quux ...#\\
\\
\verb#rmdir quux baz#\\
\verb#ls#\\
$\Rightarrow$\\
\verb#...#\\

Das war einfach. Was passiert aber nun, wenn wir versuchen ein Verzeichnis zu löschen, in dem schon etwas drin ist?\\
\verb#mkdir test#\\
\verb#touch test/datei#\\
\verb#rmdir test#\\
$\Rightarrow$\\
\verb#rmdir: failed to remove `test': Directory not empty#\\

``daran gescheitert 'test' zu entfernen: Verzeichnis nicht leer''. Das zeigt uns, dass rmdir nur leere Verzeichnisse löschen kann. Was ist aber, wenn wir ein Verzeichnis, mit vielen Unterverzeichnissen und -dateien entfernen wollen? Müssen wir dann jedes untergeordnete Objekt einzeln löschen? Naturlich nicht! Das Kommando '\verb#rm#' bietet mit dem Parameter 'r' die Möglichkeit zum sogenannten ``rekursiven'' Löschen:\\
\verb#rm -r test#\\
\verb#ls#\\
$\Rightarrow$\\
\verb#...#\\

Das Verzeichnis samt Inhalt wurde gelöscht und zwar unabhängig davon, wie komlex die untergeordnete Struktur war. Um das zu tun schaut \verb#rm# in jedem Verzeichnis nach Unterverzeichnissen und dateien  und in jedem Unterverzeichnis wiederum nach Unterverzeichnissen und Dateien um diese zu löschen. Ein solches Vorgehen bezeichnet man als ``Rekursion''.\\

Wir kenne bereits das Kommando '\verb#ls#'. Dieses besitzt ebenfalls einen 'R'-Parameter zur ``rekursiven Auflistung'' von Verzeichnissen (hier ist es jedoch ein großes 'R', nicht klein 'r'):\\
\verb#ls -R /etc#\\
$\Rightarrow$\\
...\\

Auf den Abdruck der Befehlsausgabe wird hier verständlicherweise wieder verzichtet. Der Befehl listet den gesamten Inhalt von '/etc' auf, danach den Inhalt aller Unterverzeichnisse und der Unterverzeichnisse davon, Eines nach dem Anderen.\\

Das kopieren von Dateien ist einfach:\\
\verb#mkdir Testverzeichnis#\\
\verb#touch datei1 datei2 datei3#\\
\verb#cp datei1 datei2 datei3 Testverzeichnis/#\\
\verb#ls Testverzeichnis#\\
$\Rightarrow$\\
\verb#datei1 datei2 datei3#\\

An den Befehl \verb#cp# wurden hier 4 Objekte übergeben. Das Programm hat einfach alle gelisteten Dateien in das Ziel kopiert. Als Kopierziel wurde das letzte ubergebene Objekt erkannt. Hätten wir als letztes eine Datei und kein Verzeichnis angegeben, so hätte '\verb#cp#' sich darüber beschwert.\\

Der Befehl '\verb#mv#' funktioniert genau so. Abgesehen davon natürlich, dass er Dateien verschiebt, statt sie zu kopieren.\\
$\rightarrow$ selbst ausprobieren!\\

\pagebreak
\section{Tag 4}

\subsection{Programmaufrufe in der Shell}
Wir haben bisher einige Befehle kennen gelernt, um mit Dateien umzugehen. Von unserer Kommandozeile aus haben wir externe Programme, wie z.B. '\verb#touch#', '\verb#ls#' und '\verb#chmod#' aufgerufen. Das komplexeste Programm, das wir dabei benutzt haben, war allerdings die Kommandozeilenumgebung selbst.\\

Die Befehlszeile wird auch als ``Shell'' (Schale) bezeichnet, da sie gewissermaßen das Betriebssystem umschließt, und dem Benutzer präsentiert. Um die Arbeit der Shell zu verstehen müssen wir uns unsere bisherigen Befehlsaufrufe genauer angucken:\\
\verb#ls -l -h /home/user#\\

Hier wird ein Programm aufgerufen, und es werden Parameter übergeben:\\

\begin{tabular}{l|r|r|l}
\textbf{Programmname} & \textbf{Parameter 1} & \textbf{Parameter 2} & \textbf{Parameter 3} \\
\hline
\verb#ls# & \verb#-l# & \verb#-h# & \verb#/home/user# \\
\end{tabular}\\

Die Shell ist dafür verantwortlich, das eingegebene Kommando anhand der Leerzeichen zu zerlegen, die Programmdatei aufzufinden, auszuführen und dabei die Parameter einzeln zu übergeben. Wie wir sehen handelt es sich bei Parameter 3 um eine Pfadangabe. Für die Shell ist dies zunächst egal (auch wenn sie uns z.T. besondere Unterstützung bei der Eingabe von Pfaden bietet). Die Shell übergibt 3 Parameter an das Programm, wie das Programm (in diesem fall '\verb#ls#') diese Parameter interpretiert ist nicht mehr Sache der Shell.\\

Bei Parameter 1 ('-l') und Parameter 2 ('-h') handelt es sich offensichtlich nicht um Pfadangaben. Dies sind \textbf{Optionen} für das Programm. Auch hier ist die Interpretation der Optionen Sache des Programms. Die Shell übergibt die Parameter nur. Nehmen wir an, wir hätten beim Aufruf von '\verb#ls#' die Kurzform für die Optionen verwendet:\\
\verb#ls -lh /home/user#\\

Die Shell hätte das Programm auf folgende Weise aufgerufen:\\

\begin{tabular}{l|r|l}
\textbf{Programmname} & \textbf{Parameter 1} & \textbf{Parameter 2} \\
\hline
\verb#ls# & \verb#-lh# & \verb#/home/user# \\
\end{tabular}\\

Wir sehen wieder, dass nun beide Optionen als ein Parameter übergeben werden: das Programm ist dafür verantwortlich die Bedeutung dieser verkürzten Optionskette zu erkennen. Nicht jedes Programm ist dazu in der Lage, Parameter in dieser Kurzzform zu erkennen. Generell ist das Identifizieren von Optionen (z.B. anhand eines vorangehenden Bindestrichs) Sache des Programms.\\

Ein noch komplexeres Beispiel für die Arbeit der Shell ist das am Tag 1 ausgeführte '\verb#echo#':\\
\verb#echo Hallo Welt > datei1#\\

\begin{tabular}{l|r|r|r|r}
\textbf{Programmname} & \textbf{Parameter 1} & \textbf{Parameter 2} & \textbf{Shellumleitung} & \textbf{Umleitungsziel}\\
\hline
\verb#echo# & \verb#Hallo# & \verb#Welt# & \verb#># & \verb#datei1#
\end{tabular}\\

Zwei Dinge sind hier interssant:
\begin{enumerate}
  \item Die Shell betrachtet die Worte '\verb#Hallo Welt#' als zwei unterschiedliche Parameter da sie ja durch ein Leerzeichen getrennt sind.
  \item Die Umleitung der Ausgabe in die Datei 'datei1' wird von der \textbf{Shell} ausgeführt, \textbf{nicht vom Programm 'echo'}. Tatsächlich erfährt das Programm '\verb#echo#' zu keinem Zeitpunkt, dass diese Umleitung überhaupt stattfindet. Der Umleitungspfeil und das Umleitungsziel werden \textbf{nicht} als Parameter an das Programm übergeben.
\end{enumerate}

\textbf{Diese zweite Aussage ist besonders wichtig} und wir werden gleich nochmal darauf zurückkommen. Zunächst aber nochmal zur 1. Aussage: ``Hallo'' und ``Welt'' sind zwei verschiedene Parameter. Für die Shell ist es dabei egal, wie viele Leerzeichen vor, zwischen oder nach den Parametern stehen (sie muss die Worte nur unterscheiden können). Was passiert dann aber, wenn wir z.B. ``\verb#Hallo          Welt#'' (mit 10 Leerzeichen) ausgeben wollen?\\
\verb#echo Hallo          Welt#\\

\begin{tabular}{l|r|r}
\textbf{Programmname} & \textbf{Parameter 1} & \textbf{Parameter 2}\\
\hline
\verb#echo# & \verb#Hallo# & \verb#Welt#\\
\end{tabular}\\

Ausgabe $\Rightarrow$\\
\verb#Hallo Welt#\\

Das Programm erfährt nie, dass diese Leerzeichen existieren. Bei beiden Aufrufvarianten wurde an '\verb#echo#' nie ein Leerzeichen übergeben (aus Sicht von '\verb#echo#' waren die beiden letzten Aufrufe sogar identisch). Das Programm hat nur deswegen ein Leerzeichen mit ausgegeben, weil es sich ``denken'' konnte (bzw. weil sich sein Entwickler denken konnte), dass zwischen den beiden Parametern bei der Eingabe ein Leerzeichen stehen musste. Wie übergeben wir die Leerzeichen mit?\\
\verb#echo 'Hallo          Welt'#\\

\begin{tabular}{l|r}
\textbf{Programmname} & \textbf{Parameter 1}\\
\hline
\verb#echo# & \verb#Hallo          Welt#\\
\end{tabular}\\

Ausgabe $\Rightarrow$\\
\verb#Hallo          Welt#\\

\begin{itemize}
  \item Wir haben die Zeichenkette hier bei der Befehlseingabe in einfache Anführungsstriche eingeschlossen.
  \item Das Programm '\verb#echo#' erhält nur einen einzigen Parameter
  \item Der Parameter enthält \textbf{genau das}, was in den Anführungszeichen eingeschlossen ist, dies kann sogar Zeilenumbrüche mit einschließen ($\rightarrow$ Ausprobieren)
  \item Die Anführungszeichen selbst sind \textbf{nicht} Teil des übergeben Parameters!
\end{itemize}

Aus diesem letzten Punkt entsteht übrigens wieder ein Problem: was, wenn wir die Zeichenkette ``\verb#'Hallo Welt'#'' (mit Anführungszeichen) ausgeben wollen?\\
\verb#echo \'Hallo Welt\'#\\

\begin{tabular}{l|r|r}
\textbf{Programmname} & \textbf{Parameter 1} & \textbf{Parameter 2}\\
\hline
\verb#echo# & \verb#'Hallo# & \verb#Welt'#\\
\end{tabular}\\

Ausgabe $\Rightarrow$\\
\verb#'Hallo Welt'#\\

Wir haben jedem Anführungszeichen einfach einen Rückschrägstrich (Backslash) vorangestellt. Ein Backslash macht der Shell klar, dass sie das jeweils nachfolgende Zeichen nicht selbst interpretieren, sondern einfach ans Programm ``durchreichen'' soll. Man bezeichnet den Backslash in dieser Funktion als ``Escapecharacter'' oder deutsch ``Fluchtzeichen'' (umgangssprachlich oft ``Escapezeichen'') da ein Zeichen damit der Interpretation durch die Shell ``entflieht''. das Fluchtzeichen selbst wirrd nicht ans Programm ubergeben. Wenn wir einen Backslash selbst übergeben wollen, ``escapen'' wir diesen übrigens einfach auch mit einem Backslash:\\
\verb#echo \\#\\
$\Rightarrow$\\
\verb#\#\\

\pagebreak
\section{Tag 5}

\subsection{Shellumleitungen}
Wir erwähnten vorher die Shellumleitung in Form eines Pfeils. Für uns sind zunächst zwei Arten von Shellumleitungen interessant:
\begin{itemize}
  \item die Umleitung von Programmausgaben in eine Datei (\verb#># und \verb#>>#)
  \item die Umleitung von Programmausgaben an ein weiteres Programm (\verb#|#)
\end{itemize}

\subsubsection{Ausgabeumleitung in Dateien}

Die Umleitung in eine Datei ist uns bereits bekannt. Wir haben sie wiederholt beim Aufruf von '\verb#echo#' durchgeführt.\\
\verb#echo Hallo Welt > datei1#\\

Da die Umleitung von der Shell ausgeführt wird, ist sie vollkommen Unabhängig vom Programm. Wir können damit also die Ausgabe von jedem beliebigen Programm in eine Datei leiten:\\
\verb#ls > datei1#\\
\verb#cat datei1#\\
$\Rightarrow$\\
... (Verzeichnisauflistung)\\

Angenommen, wir tun folgendes:\\
\verb#ls > datei1#\\
\verb#echo Hallo Welt > datei1#\\
\verb#cat datei1#\\
$\Rightarrow$\\
\verb#Hallo Welt#\\

Die Ausgabe von '\verb#ls#' ist nicht mehr in ``datei1'' enthalten, denn die Datei wurde bei der zweiten Ausgabenumleitung (hinter '\verb#echo#') überschrieben. Mit dem Doppelpfeil können wir eine umgeleitete Ausgabe an die Datei anhängen:\\
\verb#ls > datei1#\\
\verb#echo Hallo Welt >> datei1#\\
\verb#cat datei1#\\
$\Rightarrow$\\
... (Verzeichnisauflistung)\\
\verb#Hallo Welt#\\

\subsubsection{Ausgabeumleitung an Programme}
Sehen wir uns zunächst zwei weitere Unix-Befehle an, mit denen diese Art der Umleitung sinnvoll ist:
\begin{itemize}
  \item \textbf{wc} - ``word count'' (``Wörterzahl'') gibt die Anzahl von Zeilen, Wörtern und Zeichen in einer angegebenen Datei aus
  \item \textbf{tr} - ``translate'' (übersetze) ersetzt Zeichen in einem Datenstrom durch andere.
\end{itemize}

Das Kommando '\verb#wc#' kann auf Dateien angesetzt werden, um darin enthaltene Zeilen, Wörter und Zeichen zu zählen:\\
\verb#echo Hallo Welt > datei1#\\
\verb#echo Was geht ab? >> datei1#\\
\verb#wc datei1#\\
$\Rightarrow$\\
\verb# 2  5 24 datei1#\\

Die Datei hat demnach 2 Zeilen, 5 Wörter und insgesamt 24 Zeichen. Was ist nun, wenn wir eine solche Statistik z.B. für die Ausgabe von '\verb#ls#' haben wollen? Das Programm '\verb#wc#' ist in der Lage, seinen Text nicht nur aus einer Datei, sondern auch aus einer Umleitung zu lesen:\\
\verb#ls |wc#\\
$\Rightarrow$\\
\verb#     72      89     992#\\

Die angezeigten Zahlenwerte hängen natürlich davon ab, welches Verzeichnis wir uns von '\verb#ls#' ausgeben lassen. In diesem Fall haben wir 72 Zeilen ('\verb#ls#' listet genau 1 Objekt pro Zeile), 89 Wörter (einige Dateinamen hier enthalten also offenbar Leerzeichen) und insgesamt 992 Zeichen. Gucken wir uns die Zeile nochmal genauer an:\\

\begin{tabular}{l|r|l}
\textbf{Programmname} & \textbf{Shellumleitung} & \textbf{Programmname}\\
\hline
\verb#ls# & \verb#|# & \verb#wc#\\
\end{tabular}\\

Wir haben also zwei Programme gleichzeitig ausgeführt und dabei die Programmausgabe des ersten Programms ('\verb#ls#') zur Eingabe des zweiten Programms ('\verb#wc#') gemacht.\\

Einige Programme sind sogar darauf ausgelegt, nur auf diese Weise zu arbeiten, und gar nicht mit Dateien umzugehen. ein solches Programm ist '\verb#tr#':\\
\verb#echo Der Esel lauert im Teich. |tr s g#\\
$\Rightarrow$\\
\verb#Der Egel lauert im Teich.#\\

Das Programm '\verb#tr#' hat aus unserem Esel einen Egel gemacht. Betrachten wir kurz den Informationsfluss, der dabei Stattgefunden hat. Jedes Programm hat beim Start mindestens 3 Kanäle zum Austausch von Informationen:
\begin{itemize}
  \item \textbf{stdin} ``Standard Input'' ist der Kanal, auf dem Ein Programm Informationen liest.
  \item \textbf{stdout} ``Standard Output'' ist der Kanal, auf dem Ein Programm Informationen ausgibt.
  \item \textbf{stderr} ``Standard Error'' ist der Kanal, auf dem Ein Programm Fehlerausgaben schreibt.
\end{itemize}

Normalerweise ist 'stdin' eine Eingabe, die von der Tastatur gelesen wird, während 'stdout' und 'stderr' auf dem Terminal angezeigt werden. Die Shell ist in der Lage, diese Kanäle ``umzubiegen''. Betrachten wir den Befehl von eben noch einmal genau:\\

\begin{small}

\hspace{-1.2cm} \begin{tabular}{l|l|r|r|r|r|r|r}
\textbf{stdin von echo} &\textbf{Programm} &\textbf{Param1} &\textbf{Param2} &\textbf{Param3} &\textbf{Param4} & \textbf{Param5} &\textbf{stdout von echo} \\
\hline
(nichts) & \verb#echo# & \verb#Der# & \verb#Esel# & \verb#lauert# & \verb#im# & \verb#Teich.# & \verb#Der Esel lauert im Teich.#\\
\end{tabular}\\

\hspace{-1.2cm} \begin{tabular}{r}
\textbf{Umleitung} \\
\hline
\verb#|# \\
\end{tabular}\\

\hspace{-1.2cm} \begin{tabular}{l|l|r|r|r}
\textbf{stdin von tr} &\textbf{Programm} &\textbf{Param1} &\textbf{Param2} &\textbf{stdout von tr}\\
\hline
\verb#Der Esel lauert im Teich.# & \verb#tr# &  \verb#s# & \verb#g# & \verb#Der Egel lauert im Teich.#\\
\end{tabular}
\end{small}\\

'\verb#echo#' erhält keinerlei Daten auf seiner Standard\textbf{ein}gabe. Es generiert aber aufgrund seiner Parameter Daten auf seiner Standard\textbf{aus}gabe. Die Shell leitet diese ausgegebenen Daten in die Standard\textbf{ein}gabe von '\verb#tr#'. Bei diesem Vorgang geschieht keine Aufbereitung der Daten. Die Shell versucht \textbf{nicht} diesen Datenstrom in irgend einer Weise zu interpretieren, wie sie es mit eingegebenen Kommandozeilen tut. '\verb#tr#' erhält den Datenstrom auf seiner Standard\textbf{ein}gabe und führt eine Verarbeitung aus. '\verb#tr#\ verarbeitet die Daten auf Basis seiner Aufrufparameter und gibt dann den verarbeiteten Datenstrom auf seiner Standard\textbf{aus}gabe aus. Da hier keine weitere Umleitung stattfindet, erscheint der Satz auf dem Terminal.

Ein Programm kann seine Standardkanäle nach dem Start schließen oder weitere Kanäle öffnen. Dateien sind z.B. solche Kanäle. Wenn wir beispielsweise an '\verb#wc#' eine Datei übergeben, so wird das Programm nicht mehr von der Standardeingabe sondern aus dieser Datei lesen. Alle Daten, die es auf der Standardeingabe erhält gehen dabei gewissermaßen verloren:\\
\verb#echo Hallo Welt > datei1#\\
\verb#ls | wc datei1#\\
$\Rightarrow$\\
\verb# 1  2 11 datei1#\\

Offensichtlich hat '\verb#wc#' hier die Statistiken für 'datei1' ausgegeben. Die Standardeingabe, die Daten also, die '\verb#ls#' generiert hat wurden verschluckt. Das liegt am Programmspezifischen verhalten von '\verb#wc#'.

\end{document}
