Linux für Poweruser - download.knowware.de · KnowWare ' Amberg/Reeger: Linux für Poweruser Œ Probeseiten von 3 Inhaltsverzeichnis Willkommen zum Linux-Aufbaukurs!..... 5 Schleifen

© Amberg/Reeger: Linux für Poweruser � Probeseiten von www.knowware.de

Linux für Poweruser von: Eric Amberg und Kathrin Reeger

Seitenzahl: 72 ISBN: 87-91364-42-6

Probeseiten vom KnowWare-Verlag: www.knowware.de jederzeit online bestellbar!

Dieses Heft ist die Fortsetzung unseres Erfolgstitels Umsteigen! ... auf Linux von den gleichen Autoren und baut auf dem dort erworbenen Wissen auf. Diesmal geht es vorrangig um die Konsole.

Folgendes lernst du kennen:

- Standard-Shell Bash - Tar und Cron

- Shellskript-Programmierung - Systemstatus und Systemstart

- Midnight Commander - TarBalls (Quellcode kompilieren)

- Netzwerkkonfiguration - Firewall iptables

Das Heft ist trotz des hohen Anspruchs sehr verständlich und unterhaltsam geschrieben.

Hinweise zum Lesen dieser PDF-Datei

© KnowWare.de

2

Bildqualität Wir versuchen die Dateigröße zu reduzieren, um die Downloadzeit zu verkür-zen. Daher ist die Bildqualität in dieser Download-Datei nicht in allen Fällen optimal. Im Druck tritt dieses Problem nicht auf.

Acrobat Reader: Wie komme ich klar? F5/F6 öffnet/schließt die Ansicht Lesezeichen

Strg+F sucht

Im Menü Ansicht stellst du ein, wie die Datei angezeigt wird

STRG+0 = Ganze Seite STRG+1 = Originalgröße STRG+2 = Fensterbreite

Im selben Menü kannst du folgendes einstellen: Einzelne Seite, Fort-laufend oder Fortlaufend - Doppelseiten ... Probiere es aus, um die Unterschiede zu sehen.

Navigation

Pfeil Links/Rechts: eine Seite vor/zurück

Alt+ Pfeil Links/Rechts: Wie im Browser: Vorwärts/Zurück

Strg++ vergrößert und Strg+– verkleinert

Bestellung und Vertrieb für den Buchhandel KnowWare-Vertrieb, Postfach 3920, D-49029 Osnabrück Tel.: +49 (0)541 33145-20 Fax: +49 (0)541 33145-33 [email protected] www.knowware.de

Autoren gesucht Der KnowWare-Verlag sucht ständig neue Autoren. Hast du ein Thema, dass dir unter den Fingern brennt? - ein Thema, das du anderen Leu-ten leicht verständlich erklären kannst?

Schicke uns einfach ein paar Beispielseiten und ein vorläufiges In-haltsverzeichnis an folgende Adresse:

[email protected]

Wir werden uns deinen Vorschlag ansehen und dir so schnell wie mög-lich eine Antwort senden.

www.knowware.de

KnowWare


3

Inhaltsverzeichnis Willkommen zum Linux-Aufbaukurs!......... 5

Was sollte ich mitbringen? .....................................5 Was lerne ich hier? ................................................5 � und was lerne ich nicht?....................................5

Die Bash � Der Turbo auf der Konsole ...... 6 Kommandoeingabe................................................6 Tastenkürzel ..........................................................6 Die Bash-History....................................................7 Aliase � Ein X für ein U ..........................................7 Einstellungen für die Bash .....................................8 Benutzerdefinierte Farben .....................................8 Ein- und Ausgabeumleitungen...............................9 Pipes � Gib her, ich mach weiter .........................10 tee � Aus eins mach zwei �................................10 Hintergrundprozesse ...........................................10 Mehrere Kommandos ausführen .........................11 Jokerzeichen � Das Ass im Ärmel .......................11 Regular Expressions � Teil 1 ...............................11 Sonderzeichen ignorieren ....................................12 Kommandosubstitution ........................................14 Shellvariablen ......................................................14

PATH � Der Pfad durch Linux .................................. 14 Variablenwerte ändern ............................................. 14 PS1 � Der Prompt .................................................... 15

Weitere nützliche Befehle ......................... 16 find � Sherlock Homes.........................................16 locate � Dr. Watson .............................................17 grep und die Regular Expressions.......................17 wc � Kein Toilettenbefehl �! ...............................19 cat � Von wegen Katze........................................19 sort � Der Ordnung halber ...................................19 date � Wie spät ist es?.........................................19 whoami � Wer bin ich?.........................................20 id � Wo bin ich Mitglied? ......................................20 who � Wer ist da? ................................................20

Tar � Einpacken, auspacken, wegpacken 21 Tar-Archive erstellen............................................21 Archive komprimieren ..........................................21 tar-Archive einsehen............................................22 Archive entpacken ...............................................22 gzip und gunzip....................................................22

bzip2 eine Alternative zu gzip................................... 22 Cron � Der Taskplaner unter Linux .......... 23

Weitere Funktionen .................................................. 23 Wer darf Cron benutzen? ......................................... 23

Wie wird cron genutzt ..........................................24 Shellskript-Programmierung .................... 25

Was sind Shellskripte eigentlich? ........................25 Ein erstes Skript...................................................25 Abfragen � Wenn �, dann �..............................26

Schleifen � Mach�s noch mal ...............................27 Parameter beim Skriptstart ..................................28 Zeichenketten ausschneiden ...............................30 Listen � Die For-Schleife .....................................31 Case � Fallweise �.............................................32 Test � Schau mal, ob � ......................................32

Midnight Commander � Der Dateimanager auf der Konsole.......................................... 34

Grundfunktionen ..................................................34 Dateien ansehen .................................................35 Dateien bearbeiten ..............................................35 Die Befehlszeile...................................................35 Das Menü ............................................................35

Festplatten-Management........................... 36 fdisk � den Kuchen aufteilen................................36 Formatierung .......................................................37 Einbinden in das Dateisystem .............................38 fsck � Wenn�s mal nicht so läuft ..........................38 SOS � Das Rettungssystem ................................39 du � Wer braucht welchen Platz? ........................40 df � Wieviel Platz habe ich noch?........................40

Der Systemstatus � CPU, RAM, Prozesse, Netzwerk ..................................................... 41

vmstat � RAM, Swap und CPU............................41 top � Die Top-Ten-Liste .......................................41 free � Verfügbarer Arbeitsspeicher ......................42 uptime � Zeit seit dem Booten .............................42 ps � Die Prozessliste ...........................................42 pstree � Mutter, Vater, Kind.................................43 kill � Prozesse �umbringen� .................................43 killall � Alles wech................................................43 uname � Wie heißt du eigentlich? .......................43

Der Linux-Systemstart und die Runlevel . 44 Das Konzept der Runlevel ...................................44 Die Organisation des Systemstarts .....................44 /etc/inittab ............................................................44 Die Runlevel-Verzeichnisse.................................45 Die Verwaltung der Dienste .................................46 Der Runlevel-Editor .............................................46

TarBalls � Quellcode kompilieren und installieren.................................................. 48

make und das Makefile........................................48 configure..............................................................48 Projekt: Installation von Apache ..........................48 Den Webserver starten und testen ......................50 Den Dienst einbinden ..........................................51

In den Untiefen von KDE........................... 52 rc-Dateien ............................................................52 Spezifische Verzeichnisse ...................................52

KnowWare


4

kdelnk � Verknüpfungen ......................................52 Tastenkürzel für KDE...........................................53

Linux�Netzwerkkonfiguration .................. 54 Die Netzwerkschnittstelle.....................................54 Konfiguration........................................................54

Einstellungen über YaST.......................................... 54 Konfiguration auf der Konsole .................................. 55 Namensauflösung..................................................... 57

Netzwerkbefehle ..................................................58 (x)inetd � Der Superdaemon..................... 59 Linux � Sicherheit...................................... 61

Benutzerrechte ....................................................61 umask ....................................................................... 61 Sonderberechtigungen ............................................. 62

Der TCP-Wrapper ................................................62 Paketfilter � Die Firewall ......................................63

iptables � Die Linux-Firewall .................... 64 Die Tabellen.........................................................65 Die Regelketten ...................................................65 Die Filterregeln ....................................................65

Richtlinien ................................................................. 65 Vorbereitung ............................................................. 65 Lokale Kommunikation ............................................. 65

Stateful Inspection ...............................................66 ICMP � Ping u.a. ...................................................... 66 DNS � Domain Name Service .................................. 66 WWW � Surfen......................................................... 66 Mail � Senden und empfangen................................. 66

Firewall-Logging ..................................................67 Das Firewall-Skript...............................................67 Tipps und Tricks ..................................................68

Schlusswort ............................................... 68 Stichwortverzeichnis................................. 69

Hundert interessante KnowWare-Titel!

KnowWare bringt jeden Monat zwei neue Computerhefte auf den Markt, von A wie Access über H wie Homepage und P wie Pro-grammierung bis W wie Word oder X wie Excel oder XML. Bitte blättere zum Bestellschein auf Seite 71 oder surfe zu www.knowware.de! Auch wenn die Titel am Zeitschriftenkiosk längst vergriffen sind, halten wir alle 110 Hefte auf unse-rer Webseite zum Nachbestellen bereit! Kennst du schon den Vorgänger zu diesem Heft? Umsteigen! � auf Linux von Kathrin Reeger und Eric Amberg, 64 Seiten, 4,- Euro, IBSN 87-91364-25-6:

• Was ist Linux? • Wie wird es installiert? • Drucken, Scannen, MP3 • Briefe schreiben • Internet und E-Mail • Systemverwaltung

Das Heft ist sehr verständlich geschrieben und da-her auch für EEiinnsstteeiiggeerr zu empfehlen!

Kennst du schon unsere neue Ratgeberreihe �Life21� mit Themen wie Arbeitslosengeld II (Hartz IV), BAföG, Wohngeld, Unterhalt usw.? Mehr Infos fin-dest du auf www.life21.de bzw. www.knowware.de!

Willkommen zum Linux-Aufbaukurs!


5

Willkommen zum Linux-Aufbaukurs! Wahrscheinlich hast du es schon bemerkt: Linux ist ein sehr leistungsfähiges Betriebssystem. In den meisten Kategorien hält es locker mit Windows mit � und vielfach ist es sogar besser. Und doch hat Linux ein großes Problem: Die Ein-stiegshürde ist höher als bei Windows. Und auch wenn sie schon genommen ist, sucht der ambitio-nierte Linux-Neuling zunächst einmal nach allen Dingen, die ihm von Windows her bekannt vor-kommen. Glücklicherweise gibt es mit KDE und GNOME zwei Desktop-Umgebungen, die inzwischen kaum noch Wünsche offenlassen. Das System funktio-niert (so einigermaßen), man findet sich bald zu-recht und ist zufrieden, dass man es bis hierher ge-schafft hat. Ende der Fahnenstange � Das trifft auf dich nicht zu? Du möchtest mehr wissen? Du willst erfahren, was hinter den Kulis-sen von Linux abläuft und wie du das System op-timal nutzen kannst? Na dann: Herzlich willkommen bei Linux für Po-weruser! Wir werden versuchen, deinen Wissens-durst zu stillen.

Was sollte ich mitbringen? Dieses Heft setzt auf seinem Vorgänger Umstei-gen! � auf Linux (KnowWare Extra 20) auf. Du solltest • Linux schon einmal installiert und auf deinem

Rechner haben, • die grundlegenden Dateibefehle auf der Konso-

le kennen, also wissen, wie du Dateien und Ordner erstellst, kopierst, verschiebst, löschst usw.,

• dich mit den Grundfunktionen von KDE aus-kennen (Menüführung, Kontrollzentrum, Kon-sole, Konqueror),

• Grundkenntnisse der Benutzer- und Rechte-verwaltung mitbringen,

• wissen, wie du Softwarepakete von deinen Distributions-CDs nachinstallierst und

• ggf. eine Internetanbindung unter Linux zur Verfügung haben.

Wir werden uns auf die Version 9.0 von SuSE be-ziehen. Da wir aber vorwiegend Themen bespre-chen, die distributionsunabhängig sind, kannst du auch RedHat, Mandrake oder eine andere Distribu-tion deiner Wahl verwenden.

Was lerne ich hier? Um es vorweg zu nehmen: Der Großteil spielt sich auf der Konsole ab! Die Stärken von Linux liegen auf dieser Ebene. Auch wenn vieles inzwischen über grafische Oberflächen (KDE, GNOME) zu machen ist � ein entscheidender Unterschied zwi-schen Windows und Linux ist:

Linux versteckt seine Möglichkeiten nicht hinter bunten Oberflächen.

Es gibt nahezu nichts, was unter Linux nicht auch auf der Konsole geht. Selbst surfen kannst du kon-solenbasiert � Nun gehören wir nicht zu den Linux-Benutzern, die eine schöne grafische Oberfläche nicht zu schätzen wüssten � viele Dinge gehen hier einfa-cher von der Hand. Wir sehen uns also auch Auf-bau und Konfiguration von KDE an, indem wir ei-nen Blick hinter die Kulissen werfen. Andererseits erschließen sich die vielfältigen Fä-higkeiten von Linux oft nur auf der Konsole. Wir werden daher zunächst einige nützliche fortge-schrittene Befehle kennen lernen, die dir das Leben erleichtern können, wenn du intensiv mit Linux ar-beitest. In diesem Zusammenhang werfen wir einen tiefen Blick auf die Bash und ihre Möglichkeiten. Du lernst, wie du zeitgesteuerte Aufträge erstellst, wie du Einfluss auf den Startvorgang von Linux neh-men kannst, dir Informationen über den Systemsta-tus holst u.v.m. Darüber hinaus werden wir uns mit den Netzwerk-fähigkeiten von Linux auseinandersetzen. Nach der Lektüre dieses Heftes wirst du schon recht fit sein in Sachen Linux und kannst dich als Poweruser bezeichnen ;-).

� und was lerne ich nicht? Wir machen hier kein �Klicki Bunti� à la Win-dows. Die Möglichkeiten auf der grafischen Ober-fläche sind intuitiv erlernbar, und du kannst als er-fahrener Windows-Benutzer viele Funktionen selbst herausfinden. In diesem Heft zeigen wir dir die Dinge, die du dir nicht so einfach selbst bei-bringen kannst. In diesem Sinne wünschen wir dir viel Spaß und maximale Erfolge!

Die Bash � Der Turbo auf der Konsole


6

Die Bash � Der Turbo auf der Konsole Die Bash ist die Standard-Shell unter Linux. Für Linux ist die Bash einfach das erste Programm, das nach dem erfolgreichen Anmelden eines Benutzers gestartet wird. Für dich dagegen ist diese Shell (anderes Wort für Konsole bzw. Kommandointer-preter) die zentrale Schnittstelle zwischen dir und deinem Betriebssystem.

Es gibt viele Shells für Unix und Linux: csh (ge-sprochen: C-Shell), ksh (Korn-Shell), zsh (Z-Shell) u.a. Die Bash (Bourne Again Shell), eine Weiter-entwicklung älterer Unix-Shells, ist heute eine der leistungsfähigsten Benutzerschnittstellen über-haupt. Du selbst kannst bestimmen, welche Shell ein be-stimmter Benutzer beim Anmelden erhalten soll. Dazu gehst du in /etc/passwd (z. B. mit dem Edi-tor vi) und änderst den letzten Eintrag in der ent-sprechenden Zeile:

Alle verfügbaren Shells liegen unter /bin. Welche Shells zur Verfügung stehen, siehst du in /etc/shells (schau dir die Datei einfach mal mit less o.ä. an). Über die Installations-CDs deiner Distribution kannst du weitere Shells hinzufügen. Jede Shell unter Unix/Linux stellt eine eigene Pro-grammiersprache zur Erstellung von Skripten zur Verfügung. Damit kannst du Routineaufgaben au-tomatisieren. Fast jeder Systemdienst wird über solche Shellskripte gesteuert. Wir werden dir im Kapitel Shell-Skripte auf Seite 25 zeigen, wie du solche Skripte selbst erstellen kannst.

Kommandoeingabe In der Shell gibst du deine Befehle ein. Sie haben meist die Form Kommandoname [-Optionen] [Argumente]

So kopiert z. B. der Befehl cp –r ./Ordner1 /Archiv/Ordner1

den Inhalt von Unterverzeichnis Ordner1 samt Unterverzeichnissen (wegen –r) nach /Archiv/Ordner1. Die Option ist hierbei –r (für rekursiv), und die Argumente sind Quelle und Ziel für den Kopiervorgang (das Zielverzeichnis muss bereits existieren).

Pflichtangaben werden in spitze Klammern ge-fasst, z. B. <Datei>. Optionale Angaben stehen in eckigen Klammern, z. B. [-Optionen]. Optionen werden fast immer mit einem Minus (-) eingeleitet. Für viele Optionen gibt es eine Langform, die mit zwei Minuszeichen (--) ein-geleitet wird, z. B. cp --help. Optionen müssen nicht (wie z. B. bei DOS üblich) jeweils durch ein Leerzeichen und ein weiteres Minus voneinander getrennt werden, sie können vielmehr direkt hin-tereinander angegeben werden, wie z. B. in ls -la.

Du wirst in diesem Heft viele Befehle kennen ler-nen. Einige Linux-Befehle verfügen über sehr um-fangreiche Optionen. Manche Optionslisten lesen sich wie das Alphabet �

Für eine Übersicht über die zu einem Befehl ver-fügbaren Optionen gibst du man <Befehl> oder

<Befehl> --help ein.

Tippe nun spaßeshalber ls --help ein � hättest du gedacht, dass ein so simpler Befehl mit Optio-nen wie ls –ctfuSUX gestartet werden kann?

Tastenkürzel Willst du ein Virtuose auf der Konsole werden, solltest du dich mit den zahlreichen Hilfestellun-gen auskennen, die die Bash zur Verfügung stellt.

Die aktuelle Befehlszeile lässt sich wie in einem Textverarbeitungsprogramm editieren � Zeichen

löschen, ersetzen, hinzufügen an beliebiger Stelle, usw.

Darüber hinaus gibt es weitere Hilfestellungen. Hier ein paar wichtige: • [½] bzw. [¼]: wechselt durch die zuletzt ein-

gegebenen Kommandos. • [Æ] bzw. [æ]: Cursor auf der aktuellen Be-

fehlszeile vor und zurück bewegen. • [ÿ] (Tabulator): vervollständigt den Befehl,

Datei- oder Verzeichnisangaben, sobald sie ein-deutig sind. Zweimal [ÿ] ruft ggf. alle Mög-lichkeiten auf.

• [Pos1], [Ende]: Cursor an Beginn/Ende der Zeile.

• [Backspace], [Entf]: Zeichen rückwärts/vor-wärts löschen.



7

• [Alt] + [D]: Wort löschen, Cursor muss auf dem ersten Zeichen stehen.

• [Strg] + [K]: Ab dem Cursor bis zum Ende der Zeile löschen.

• [Strg] + [L]: Löscht den gesamten Bildschirm (wie der Befehl clear).

• [Strg] + [R]: Ruft die Suchfunktion der Bash auf. Gibst du die ersten Zeichen des gesuchten Befehls ein, sucht die Bash nach alten Einga-ben, die die entsprechenden Zeichen (z. B. ls) enthalten.

Es wird der erste Eintrag gezeigt. Drückst du wiederholt [Strg] + [R], werden nacheinander andere passende Einträge angezeigt.

Stopp! Lies jetzt nicht einfach weiter � sonst ver-gisst du sofort, was du gerade gelernt hast. Statt-dessen dürfen wir dich zu einer kleinen Übung ein-laden � ☺.

Übung: Gib eine Zeile mit einem beliebigen Inhalt ein, z. B.

Jetzt testest du der Reihe nach alle oben genannten Tastenkürzel, bis du ein Gefühl dafür bekommen hast. Anschließend wirst du dann die Hilfestellun-gen der Bash nicht mehr missen wollen. Teste insbesondere auch die Suchfunktion � sie ist etwas gewöhnungsbedürftig, aber sehr nützlich. Natürlich musst du dazu schon einige Befehle ein-gegeben haben. Aber das lässt sich ja ggf. schnell nachholen. Daneben solltest du die [Tabulator]-Funktion ausgiebig erkunden � sie ist die mäch-tigste Funktion der Bash, da sie die Eingaben um ein Vielfaches beschleunigen kann.

Die Bash-History Vielleicht hast du dich schon gefragt, woher die Bash weiß, welche Eingaben du vorher einmal gemacht hast. Schließlich merkt sich die Bash auch alle Eingaben, die du gestern, vorgestern oder letz-te Woche gemacht hast � Wenn du jetzt denkst �Klar, das wird irgendwo im Programm gespeichert!�, hast du noch eine Menge über das Wesen von Linux zu lernen. Wie ein-gangs erwähnt versteckt sich Linux nicht in einer Black-Box. Stattdessen kannst du die meisten Vor-gänge wirklich sehr genau nachvollziehen. Zurück zur Ausgangsfrage: schau mal mit more oder less in die Datei ~/.bash_history in dei-nem Home-Verzeichnis.

Die Tilde (~) steht für das Home-Verzeichnis ei-nes jeden Users und kann bei der Pfadangabe

verwendet werden.

Wie du siehst, sind hier sämtliche Befehle, die du früher einmal eingegeben hast, gespeichert � ganz transparent und nachvollziehbar.

Da die Datei einen vorangestellten Punkt hat, kannst du sie nur mit ls –a im Verzeichnis sehen (-a für all).

Aliase � Ein X für ein U Vielleicht benötigst du ja den einen oder anderen Befehl immer wieder im Zusammenhang mit be-stimmten Optionen oder Argumenten. Hier ein Beispiel: Kennst du unter Windows die Option, nach der versteckte Dateien und Ordner grundsätzlich erst einmal nicht angezeigt werden? Du findest sie im Windows-Explorer unter EXTRAS|ORDNEROPTIO-NEN|ANSICHT.

Im Bild ist bereits die richtige Option angewählt. Schließlich sind wir mündige Bürger und wollen sehen, was um uns herum so abgeht. Unter Linux kannst du dazu ls –a eingeben. Gibst du auf der Konsole alias ls='ls –a'

ein, wird für die Dauer deiner Sitzung jedes Mal, wenn du ls eingibst, der Befehl ls –a ausgeführt. Möchtest du das dauerhaft so haben, kannst du die-se Befehlszeile in einer der Bash-Konfigurations-dateien (~/.bashrc oder ~/.profile) eintragen, am besten immer ganz unten nach allen anderen Anweisungen.

Auf die Konfigurationsdateien der Bash kommen wir gleich im nächsten Abschnitt zurück.

Unter SuSE funktioniert es auch, wenn du eine Da-tei ~/.alias erstellst (z. B. mit vim) und in diese Datei die entsprechende Befehlszeile schreibst. Du musst danach nur eine neue Konsole starten (bzw.



8

dich neu anmelden), damit die Änderungen wirk-sam werden.

Achte darauf, dass die Datei versteckt ist, also einen vorangestellten Punkt im Namen hat!

Dabei kannst du beliebig viele Aliase eingeben. Hier noch ein paar Anregungen: alias ps=’ps aux’

alias mcd=’mount /dev/cdrom’

alias umcd=’umount /dev/cdrom’

Wie du siehst, sind deiner Fantasie hier keine Grenzen gesetzt. Aber beachte:

Aliase werden immer vor gleichnamigen �ech-ten� Befehlen ausgeführt, damit diese Befehle

abgefangen und ersetzt werden können.

Also musst du aufpassen, dass du nicht aus Verse-hen ein existierendes Kommando durch einen selbst erstellten Alias ersetzt. Hätten wir im ersten Beispiel oben z. B. mc statt mcd gewählt, wären wir mit einem sehr nützlichen Dateimanager na-mens Midnight Commander in Konflikt geraten, der sich mit mc starten lässt. Über den Midnight Commander kannst du dich ab Seite 34 informie-ren.

Einstellungen für die Bash Je nachdem wie die Bash aufgerufen wird, werden verschiedene Konfigurationsdateien ausgewertet. Es gibt sowohl globale Konfigurationsdateien un-ter /etc als auch individuelle Dateien im Home-Verzeichnis des Benutzers. Wird die Bash als Login-Shell gestartet, also direkt nach dem Einloggen, so liest sie u.a. /etc/profile und ~/.profile ein. Die Bash kann auch als interaktive Shell gestartet werden, z. B. beim su-Befehl. Hierbei wird sozu-sagen eine Shell in einer Shell gestartet, damit die Benutzerumgebungen nicht durcheinander geraten. Als interaktive Shell liest die Bash /etc/bashrc,

/etc/bash.bashrc und ~/.bashrc

ein.

Achtung: nicht immer existieren alle Dateien; die Bash nimmt, was sie findet. Darüber hinaus verfolgt SuSE hier auch wieder ei-nen eigenen Weg: Die Datei /etc/bashrc exis-tiert nicht und /etc/bash.bashrc soll nicht von

Hand editiert werden (wird vom System erstellt). Stattdessen solltest du Anpassungen in einer ggf. von dir zu erstellenden Datei /etc/bash.bashrc.local vornehmen.

Wie du siehst, haben die Konfigurationsdateien im Home-Verzeichnis einen vorangestellten Punkt, sind also versteckt. Ansonsten gilt:

Konfigurationsdateien unter /etc gelten sys-temweit, Dateien im Home-Verzeichnis nur für

den jeweiligen Benutzer.

Um sicherzugehen, dass deine Aliase (siehe vori-ger Abschnitt) in jedem Fall greifen, kannst du sie sowohl in die profile-Dateien als auch in bashrc eintragen. Je nachdem, ob du globale Gültigkeit brauchst oder einen Alias nur für einen bestimmten Benutzer definieren möchtest, nutzt du die Dateien unter /etc oder unter ~/ (dem Home-Verzeichnis).

Benutzerdefinierte Farben Vielleicht gefällt dir das vorgegebene Farbschema für die Konsole nicht. Dieses ist in /etc/DIR_COLORS festgelegt.

Schau dir diese Datei einmal in Ruhe an. Sie ist selbsterklärend bzw. gut dokumentiert. Änderst du diese Datei direkt, gelten die Änderungen für alle Benutzer. Willst du eine Benutzer-individuelle Farb-Konfiguration einrichten, musst du diese Da-tei in das Home-Verzeichnis des betreffenden Be-nutzers kopieren und in.dir_colors umbenen-nen. Alle Änderungen, die du jetzt in ~/.dir_colors vornimmst, haben für den Benut-zer Vorrang vor globalen Einstellungen. Übung: Stelle die Verzeichnisse in grün dar. Dazu musst du die Zeile mit DIR abändern in DIR 01;32 # directory

Um die Farbdarstellung des Terminals zu verän-dern, benutzt du den Befehl setterm –background <Hintergrundfarbe> -foreground <Schriftfarbe>

Du kannst folgende Farben angeben: black, white, red, blue, green, yellow, magenta und cyan. Wei-



9

terhin kannst du mit dem Parameter –bold on die Schrift auf hell setzen. Mit –store wird die Ein-stellung gespeichert und steht dir zur Verfügung, solange der Rechner an ist. Ansonsten halten die Änderungen nur bis zur nächsten Abmeldung. Bei-spiel: setterm –background magenta –foreground cyan –bold on

� austesten auf eigene Gefahr� wir lehnen jegli-che Verantwortung für eventuelle Augenschäden aufgrund der grausamen Farbkombination ab ;-). Übung: Setze die Farben für die Konsole auf blue für Hintergrund und yellow bold für den Vorder-grund. Das kann man eigentlich ganz gut lesen, ist aber auch Geschmackssache � Mit setterm –default kannst du die Standard-einstellungen wiederherstellen. Willst du diese Einstellungen dauerhaft speichern, schreibe die Zeile in /etc/profile, wenn es für alle gelten soll, oder in ~/.profile für den ein-zelnen Benutzer.

Ein- und Ausgabeumleitungen Du kannst Ausgaben eines Befehls in verschiede-ner Weise weiterbearbeiten und Befehle miteinan-der kombinieren. Versuch folgenden Befehl: ls –la > inhalt.txt Damit wird die Bildschirmausgabe des angegebe-nen Befehls (ls –la) in eine Datei namens in-halt.txt im aktuellen Verzeichnis geschrieben. Dazu wird die schließende Spitzklammer (>) ver-wendet. Die Datei muss nicht existieren � ggf. wird sie erstellt. Existiert sie, wird ihr alter Inhalt überschrieben. Möchtest du den neuen Inhalt ledig-lich anhängen, benutzt du >>, also ls –la >> inhalt.txt

Dabei wird der alte Inhalt beibehalten und der neue nach der letzten Zeile angehängt.

Zur Wiederholung: Endungen wie z. B. *.txt sind unter Linux nicht notwendig, um den Dateityp zu kennzeichnen, werden aber aus Konventionsgrün-den oft benutzt. Sie dienen vor allem der Über-sichtlichkeit für die Benutzer.

Hast du einen längeren Prozess, der u.U. bestimm-te Meldungen auf dem Bildschirm ausgibt, kannst du diese ebenfalls in eine Datei umleiten. Dies wird gern bei Neu-Kompilierungen des Kernels gemacht. Wird der Kernel kompiliert (in Maschi-nensprache übersetzt), erzeugt der Compiler, also das Programm, das für diese Übersetzung zustän-

dig ist, jede Menge Meldungen. Darunter können auch Warn- und Fehlermeldungen sein, die aber für dich kaum erkennbar sind � der Bildschirmin-halt scrollt so schnell, dass du beim Lesen nicht hinterherkommst. Es gibt drei interne Verwaltungsvorgänge, die vom System und von Programmen genutzt werden kön-nen: 1. Standardeingabe: Zeichen werden von der Tas-

tatur gelesen. 2. Standardausgabe: Zeichen werden auf dem

Monitor (dem aktuellen Terminal) ausgegeben. 3. Standardfehler: werden normalerweise eben-

falls auf dem Monitor ausgegeben. Fehlermeldungen kannst du mittels 2> abfangen und in eine Datei umleiten, z. B. make 2> errors.txt

Der Befehl make erzeugt aus den Quellcode-Dateien im aktuellen Verzeichnis die Binärdateien, die der Computer lesen kann. Das nur zur Informa-tion. Genaueres erfährst du auf Seite 48. Mit >& kannst du Standardausgabe- und Fehler-meldungen zusammen umleiten. Möchtest du Daten aus einer Datei auslesen und weiterverarbeiten, nutzt du die öffnende Spitz-klammer (<). So sortiert sort < unsortiert.txt

den Inhalt der angegebenen Datei nach ASCII-Code Zeile für Zeile und gibt ihn auf dem Bild-schirm aus. Übung: Das ist zu abstrakt für dich? Dann erstelle eine Datei unsortiert.txt in deinem Home-Verzeichnis und fülle sie mit folgendem Inhalt, je-der Begriff in einer eigenen Zeile: tango

bravo

november

charlie

zulu

sierra

Nun rufe den Befehl wie im Beispiel angegeben auf. Das Ergebnis sollte so aussehen:



10

Der Inhalt ist fein sortiert. Den Befehl kann man oft gebrauchen; wir fassen die Syntax mit einigen zusätzlichen Beispielen noch einmal auf Seite 19 zusammen.

Pipes � Gib her, ich mach weiter Es wird oft vorkommen, dass du die Ausgabe eines Befehls in einem zweiten Kommando weiterver-wenden möchtest. Lass dir zur Übung den Inhalt des Verzeichnisses /dev mit ls -l anzeigen � das Ergebnis ist eine riesige Liste mit hunderten von Einträgen.

Pipes (engl. für Röhren) werden mit dem senk-rechten Strich ([Alt_Gr] + [<]) zwischen zwei Befehlen eingerichtet. Sie leiten die Ausgabe des ersten Befehls in den zweiten zur Weiter-

verarbeitung um.

Mit ls –l | less kannst du die Ausgabe von ls –l durch den Befehl less filtern lassen. Dieser Befehl lässt dich durch die Liste seiten- oder zei-lenweise vor- und zurückscrollen. Probiere es am besten gleich aus. Die Pipe ist eines der nützlichsten Hilfsmittel im täglichen Betrieb. Im Heft werden wir uns an der einen oder anderen Stelle noch einmal der Pipe be-dienen, um bestimmte Aufgaben zu bewältigen. Gleich im folgenden Abschnitt findest du das nächste Beispiel.

tee � Aus eins mach zwei � Du hast es wahrscheinlich schon bemerkt: Wenn du die Ausgabe eines Befehls in eine Datei umlei-test, siehst du auf dem Bildschirm gar nichts mehr. Möchtest du beides haben, nutzt du den Befehl tee. ls –l | tee inhalt.txt

liest den Inhalt des aktuellen Verzeichnisses und leitet die Ausgabe an tee weiter. Tee zeigt die Ausgabe ganz normal am Bildschirm an, leitet sie aber zusätzlich in eine Datei inhalt.txt um. Daraus lassen sich weitere Anwendungsmöglich-keiten ableiten. Schau dir die Ausgabe von ls –l an:

Zählen wir doch einfach einmal Spalten. In der 5. Spalte steht die Dateigröße. Mit sort +4 können wir nach der 5. Spalte sortieren lassen (es beginnt bei 0). Die Befehlszeile ls –l|tee inhalt.txt|sort +4 > sortiert.txt

erstellt eine Datei inhalt.txt, die die Ausgabe von ls –l enthält. Darüber hinaus wird die Aus-gabe in den Befehl sort geleitet, der die Liste nach der Dateigröße sortiert und in sortiert.txt schreibt. Wow, mit solch einer Befehlszeile kann man schon ganz schön Eindruck schinden, was? Aber wir ha-ben noch viel mehr für dich auf Lager � lies ein-fach weiter ☺.

Hintergrundprozesse Manchmal dauert die Ausführung eines Befehls sehr lange. Normalerweise wird die Konsole für diese Zeit von diesem Kommando geblockt. Um trotzdem weiterarbeiten zu können, ohne auf eine neue Konsole wechseln zu müssen, kannst du den Befehl als Hintergrundprozess starten. Dazu setzt du an das Ende der Befehlszeile ein kaufmänni-sches UND (&). grep 'Otto' logfile.log > otto.txt &

sucht in einem Logfile nach dem Begriff �Otto� und schreibt das Ergebnis in otto.txt.

Den Befehl grep stellen wir dir ausführlich auf Seite 17 vor. Nimm ihn an dieser Stelle bitte ein-fach zur Kenntnis.

Logfiles können hunderte von Megabyte groß werden, und die Suche dauert entsprechend lang. Also verbannen wir den Befehl in den Hintergrund mit & am Ende der Zeile. Anschließend zeigt dir die Bash die Prozessnummer des Hintergrundpro-zesses und gibt die Konsole wieder frei. Hast du gerade kein 100 MB-Logfile zur Verfügung, kannst du auch übungshalber folgenden Befehl eingeben:

Jetzt kannst du normal weiterarbeiten. Die Pro-zessnummer (PID) ist für dich wichtig, falls du den Befehl vorzeitig mit kill <PID> beenden möch-test. Der Befehl meldet sich im Übrigen nicht zu-rück, wenn er fertig ist. Bei Eingabe eines (belie-bigen) neuen Kommandos wird eine Meldung aus-gegeben, falls der Hintergrundprozess zwischen-zeitlich beendet wurde::



11

Mehrere Kommandos ausführen Du kannst Befehle miteinander kombinieren, aber auch nacheinander ausführen lassen. So kannst du z. B. ein Inhaltsverzeichnis in eine Datei umleiten und zu späteren Vergleichszwecken mit einem Da-tum versehen: date; ls führt zunächst date und anschließend ls aus. Der Befehl date zeigt Datum und aktuelle Uhrzeit an (siehe Seite 19).

Befehle, die mit einem Semikolon voneinander getrennt sind, werden nacheinander ausgeführt. Leerzeichen dazwischen sind nicht nötig, stören

aber auch nicht.

Möchtest du beide Ausgaben in eine Datei umlei-ten, benötigst du eine Klammer: (date;ls) > inhalt.txt

Die durch Semikolon getrennten Befehle werden in jedem Fall nacheinander ausgeführt. Du kannst auch bedingte Kommandoverknüpfungen erstellen. Mit make && make install && make clean

wird make install nur ausgeführt, wenn make erfolgreich war; andernfalls nicht. Der Befehl make clean wird anschließend nur dann ausgeführt, wenn make install erfolgreich war.

Die bedingte UND-Verknüpfung wird durch && erstellt und führt Befehle nacheinander nur dann aus, wenn der jeweils vorige Befehl erfolgreich

war.

Diese Kombination ist beim Kompilieren von Pro-grammen nützlich, da die Befehle sonst per Hand nacheinander eingegeben werden müssten. Da das Kompilieren manchmal lange dauern kann (teil-weise mehrere Stunden!), verlässt du deinen Ar-beitsplatz schon mal. Kommst du nicht zufällig in dem Augenblick zurück, wo einer der Prozesse fer-tig geworden ist, um das nächste Kommando ein-zugeben, verlierst du Zeit. Im Kapitel TarBalls in-stallieren auf Seite 48 kommen wir darauf zurück.

Bei diesem Beispiel handelt es sich um eine logi-sche UND-Verknüpfung, der nächste Befehl wird nur ausgeführt, wenn der vorige korrekt beendet wurde. Es gibt auch eine ODER-Verknüpfung, wobei der nächste Befehl nur dann zum Tragen kommt, wenn der vorige NICHT erfolgreich war. Dazu nutzen wir statt '&&' den senkrechten Strich doppelt: ls datei || touch ...

ls datei1 || touch datei1 testet, ob eine Datei datei1 existiert. Wenn ja, wird sie ange-zeigt, sonst tritt Befehl 2 (touch) an und erstellt die Datei.

Anschließend ist sie vorhanden und kann mit ls datei1 angezeigt werden. Ein einfaches Beispiel, zugegeben � aber es sollte reichen, dir die Funktion zu zeigen. Diese beding-ten Befehlsketten werden normalerweise erst bei fortgeschrittenen Anwendungen wichtig, aber es wird ja bei dir nicht mehr lange dauern, bis es so-weit ist � ;-)

Jokerzeichen � Das Ass im Ärmel Vermutlich kennst du schon zwei Jokerzeichen von Windows: • * für ein, kein oder beliebig viele Zeichen • ? für genau ein Zeichen. Nehmen wir an, du hast in einem Verzeichnis zehn Text-Dateien: datei1.txt bis datei10.txt. Hier zwei Beispiele für Jokerzeichen: • ls –l datei*.txt zeigt alle oben genannten

Dateien an. • ls –l datei?.txt zeigt datei1.txt,

datei2.txt usw. bis datei9.txt an, aber nicht datei10.txt, da hier zwei Zeichen fol-gen, der Fragezeichen-Joker aber nur eines er-laubt.

Das ist ja noch recht leicht. Aber unter Linux geht noch viel mehr. Das Zauberwort heißt Reguläre Ausdrücke. Mit diesen �Regular expressions� kannst du sehr genau filtern. Es gibt ganze Bücher darüber.

Regular Expressions � Teil 1 Reguläre Ausdrücke werden nicht nur von der Bash unterstützt sondern auch von verschiedenen Programmen und Programmiersprachen � so z. B. von Perl, der besten Skriptsprache zur Verarbei-tung von Textdateien. Natürlich unterstützt auch die Bash-Skriptsprache einen Teil dieser Ausdrücke.



12

Wir riskieren an dieser Stelle eine Ungenauigkeit: In Wirklichkeit unterstützt die Bash reguläre Aus-drücke nicht. Stattdessen nennen sich die Erset-zungen hier 'Patterns'. Sie funktionieren aber grundsätzlich so wie �Regu-lar Expressions�. Unterschiede lernst du im Kapitel grep und die Regular Expressions auf Seite 17 kennen.

Wenn du längere Bildschirmausgaben, Texte bzw. Text-Dateien anpassen, sortieren, verändern oder durchsuchen möchtest, werden diese Filteroptionen sehr nützlich für dich sein. Hier zeigen wir dir zu-nächst einmal ein paar recht einfache Dinge, Bei-spiele dazu folgen: [abc] eines der angegebenen Zeichen

[a-c], [1-5] ein Zeichen aus dem angegebenen Bereich des Alphabets bzw. des Zahlenbereichs

[!abc] keines der angegebenen Zeichen darf vorkommen

[^abc] genau das gleiche

[a,b,e-g, 3-7,9,0]

Kombination der bisherigen Filter, jeweils durch Komma getrennt

~ steht für das Home-Verzeichnis ei-nes Benutzers

Hier die versprochenen Beispiele: • ls –l datei[abc].txt zeigt dateia.txt,

dateib.txt und dateic.txt. • ls –l datei[1-9].txt zeigt datei1.txt,

datei2.txt, usw., nicht aber datei10.txt (weil 2 Zeichen folgen).

Willst du datei10.txt anzeigen lassen, kannst du ls –l datei[1-9][0].txt schreiben. Beachte: Das würde aber auch datei20.txt, datei30.txt, usw. bis datei90.txt anzeigen, dummerweise nur nicht mehr datei[1-9].txt Ein weiteres Beispiel: ls –l datei[a-d, 0-9].txt zeigt dateia.txt, dateib.txt, dateic.txt, dateid.txt, datei0.txt, datei1.txt,

datei2.txt usw. Um es noch einmal klarzustellen: jede eckige Klammer steht für genau ein Zeichen im Original! Mit ls –l datei[a-z][0-9].txt suchst du nach allen Namen, die mit datei anfangen, danach genau einen kleinen Buchstaben haben und an-schließend genau eine Ziffer enthalten, gefolgt von .txt, also z. B. dateiy8.txt.

Puh, starker Tobak, was? Eines ist klar: Wenn du diese Techniken nie oder zu selten benutzt, wirst du sie schnell vergessen! Also:

Üben, üben, üben! Und nicht aufgeben!

Du wirst ein wenig Geduld benötigen, bis du hinter die teilweise recht tückische Anwendung dieser mächtigen Substitutionstechnik (substituieren = er-setzen) gestiegen bist und sie ganz selbstverständ-lich verwendest. Zur Vertiefung machen wir jetzt eine schicke Übung ☺. Übung: Erstelle in deinem Home-Verzeichnis zu-nächst ein Unterverzeichnis ~/regex und an-schließend mit dem Befehl touch <Dateiname> folgende Dateien: datei1.txt – datei10.txt

logfile10.log

logfile10a.log

logfile11.log

logfile11a.log

logfile11b.log

Dein Verzeichnis regex sollte nun so aussehen:

Hier nun deine Aufgaben. Benutze den Befehl ls, um die gewünschten Filter zu testen: 1. Zeige alle Dateien an, die die Endung log ha-

ben. 2. Finde die Dateien datei4.txt, datei5.txt,

datei6.txt und datei7.txt.

3. Wie lässt du dir datei2.txt bis datei7.txt und datei9.txt anzeigen?

4. Zeige alle logfile-Dateien an, die einen Buch-staben am Ende des Namens haben: logfi-le10a.log, logfile11a.log und logfi-le11b.log. Denke an den Einsatz des Asterisk (*) als Jokerzeichen, er kann auch mitten im Namen verwendet werden.

Geschafft? Super! Damit erhältst du den ersten RegEx-Orden. Teil II folgt später �

Sonderzeichen ignorieren Wie du vielleicht schon bemerkt hast, haben wir bisher nur alphanumerische Zeichen verwendet, al-so a-z, A-Z und 0-9 (nebenbei: du könntest alle diese Zeichen mit [a-zA-Z0-9] erfassen �). Es gibt kaum ein Sonderzeichen, das keine spezielle Bedeutung für die Bash hat. Damit du diese Zei-chen auch �ganz normal� verwenden kannst, setzt



13

du den entsprechenden Ausdruck in einfache Anführungszeichen. Somit zeigt also z. B. ls 'd*tei' eine Datei an, die exakt d*tei heißt. Der Asterisk wird hier als Jokerzeichen ignoriert und steht sozusagen nur für sich selbst. Im Übrigen ist es unsauber, eine Datei in dieser Art zu benennen, auch wenn es funktioniert. Nutzt du doppelte Gänsefüßchen ("), werden be-stimmte Sonderzeichen ($, ' und \) weiterhin in-terpretiert: • Mit $ werden Variablen angegeben (z. B.

$PATH), • Die einfachen Hochkommas (') hast du bereits

kennen gelernt, • der Backslash (\) maskiert das folgende Zei-

chen, damit es als normales Zeichen und nicht als Sonderzeichen interpretiert wird.

Hier ein paar Beispiele:

Der Befehl echo schreibt das Folgende auf den Bildschirm. Für mehr als ein Wort muss der Text

in Anführungszeichen gesetzt werden.

Wird der Text in einfache Hochkommas gesetzt, so wird $PATH nicht interpretiert. Bei doppelten Hochkommas wird $PATH durch den Inhalt dieser Systemvariablen ersetzt. Das Maskierungszeichen \ kannst du z. B. für Da-teinamen verwenden, die ein Leerzeichen enthal-ten. Unter Linux solltest du solche Namen besser vermeiden, da viele Kommandos ein Leerzeichen als Trennung zwischen zwei Argumenten interpre-tieren. Hast du unter Linux deine Windows-Partition gemountet, findest du dort oft Datei- und Ordnernamen, die Leerzeichen enthalten, z. B. Ei-gene Dateien. Dies führt unter Linux zu Proble-men. Willst du z. B. Neue Textdatei.txt nach Sicherung Neue Textdatei.txt kopieren, sieht das eigentlich so aus: cp Neue Textdatei.txt Sicherung Neue Textdatei.txt

Woher soll aber der Copy-Befehl wissen, welche Teile zum gleichen Dateinamen gehören? Das Er-gebnis folgt entsprechend:

Die Lösung ist die Verwendung des Backslash (\). In der folgenden Übung kannst du das gut selbst überprüfen: Übung: Gib zunächst die folgende Zeile ein: touch Neue Textdatei.txt Überzeuge dich davon, dass du damit nicht eine, sondern zwei Dateien erstellt hast: Neue und Textdatei.txt. Das Leerzeichen wird als Trennzeichen zwischen zwei Argumenten interpretiert. Der Befehl touch erwartet die Namen der zu erstellenden Dateien, für ihn ist also Neue eine Datei und Textda-tei.txt eine zweite Datei. Hast du dies mit ls überprüft, kannst du die beiden Dateien mit rm Neue Textdatei.txt auch wie-der löschen. Nun erstellst du mit touch Neue\ Textdatei .txt tatsächlich genau eine Datei. Überprüfe es:

Versuche nun, die Datei folgendermaßen umzube-nennen: mv Neue Textdatei.txt Alte Textdatei.txt

Das Ergebnis ist klar:

Die einzelnen Komponenten desselben Namens werden als eigenständige Dateien interpretiert. Kann nicht klappen. Stattdessen gibst du nun fol-gendes ein: mv Neue\ Textdatei.txt Alte\ Textdatei.txt Schon ist alles in Butter:

Der Dateiname wird dir zwar ohne Backslash an-gegeben, wenn du aber die Autovervollständigen-Funktion [Tabulator] verwendest, wird er mit an-gezeigt.



14

Kommandosubstitution Wir greifen hier ein wenig vor, da diese Technik nur mit fortgeschrittenen Befehlen Sinn macht, die du erst später kennen lernst. Aber es genügt, wenn du an dieser Stelle das Prinzip verstehst. Nehmen wir an, du möchtest die Dateien eines Be-nutzers löschen. In diesem Falle benutzt du den find-Befehl, um die Dateien zu finden � siehe Seite 16. Nehmen wir an, es sind einige hundert über das gesamte Dateisystem verteilt. Da wird ein manuelles Löschen sehr aufwändig. Besser wäre es, das zu automatisieren. Leider kannst du das Ergebnis von find nicht ein-fach über die Pipe (|) an den Befehl rm (löschen) weiterleiten. Stattdessen musst du die Dateien über eine Kommandosubstitution übergeben. Dies ge-schieht durch: Befehl1 $(Befehl2)

Die spitzen Klammern haben wir der Übersicht-lichkeit halber weggelassen. Wir schreiben also: rm –f $(find / -user otto –type f)

Diese Konstruktion sieht abenteuerlich aus, ist aber ungemein hilfreich, um Befehle mit Argumenten zu versorgen, wenn die Pipe nicht funktioniert. Die Option –f nutzen wir, damit wir nicht jedes Mal eine Sicherheitsabfrage vom Befehl bekommen � sonst könntest du es ja gleich per Hand machen �

Du kannst die Kommandosubstitution immer dann benutzen, wenn jede einzelne Ausgabezei-

le eines Befehls (hier: find) als Argument für einen anderen Befehl (hier: rm) genutzt werden soll. Ist eine Liste als Ganzes der Übergabepa-

rameter, so nutzt du die Pipe.

So, jetzt aber erst mal Pause! Mann, das ist ganz schön anstrengend, nicht? Dafür aber sehr nützlich. Hier noch einmal eine Zusammenfassung > Ausgabe in Datei umleiten

>> Ausgabe an Datei anhängen

< Inhalt aus Datei lesen und entsprechend verarbei-ten

2> Fehlermeldungen in Datei umleiten

>& Fehler- und normale Meldungen umleiten

| Ausgabe in den nächsten Befehl weiterleiten

; unbedingte Befehlsverkettung

&& UND-Verkettung, Befehl wird nur ausgeführt, wenn der vorherige erfolgreich war

|| ODER-Verknüpfung, Befehl wird nur ausgeführt, wenn der vorherige NICHT erfolgreich war

<Befehl> $(Befehl)

Kommandosubstitution, <Befehl> nimmt als Argu-ment das Ergebnis des Befehls in der Klammer

Shellvariablen Wie bei Windows gibt es auch bei Linux System-variablen; sie werden als Shellvariablen bezeich-net. Du kannst Variablen auch selber definieren, ganz wie in einer Programmiersprache. Dazu kommen wir auf Seite 25 im Kapitel über die Bashskript-Programmierung. Hier stellen wir dir erst mal die beiden wichtigsten vor. So lässt du dir den Inhalt einer Variable anzeigen: echo $<Variable> Du musst vor den Variablen-Namen immer ein Dollarzeichen ($) setzen.

PATH � Der Pfad durch Linux Die wohl wichtigste Variable ist PATH. Sie enthält � wie bei Windows � alle Verzeichnisse, die nach ausführbaren Programmen durchsucht werden, wenn du auf der Konsole nur den Programmnamen ohne Pfad angibst. Schau dir den Inhalt von PATH an:

Jeder Pfad wird durch einen Doppelpunkt vom nächsten getrennt.

Variablenwerte ändern Jeder Benutzer hat ein Verzeichnis ~/bin, das für eigene Skripte vorgesehen ist. Dieses Verzeichnis ist in unserer PATH-Variablen noch nicht enthal-ten. Deswegen fügen wir es jetzt hinzu. Wenn du den Wert einer Variablen setzen möch-test, lässt du $ weg: Variable = Wert

Du kannst also mit wert1 = 'Dies ist eine Variable'

den Wert für die Variable wert1 setzen. echo $wert1 gibt Dies ist eine Variable aus.

Wenn Sonderzeichen im String (so nennt man eine zusammenhängende Zeichenkette) vor-

kommen, muss der String in Hochkommas ge-setzt werden. Das Leerzeichen ist auch ein

Sonderzeichen. Zurück zu unserer Aufgabenstellung. Mit folgen-dem Befehl erweiterst du die Variable PATH um ~/bin: PATH = $PATH':~/bin' Das ist ungefähr so wie x = x + y. Es handelt sich also nicht um eine Gleichung, sondern um ei-ne Zuweisung. x bekommt den Wert x + y zuge-wiesen, wird in diesem Fall also durch y ergänzt.



15

Jetzt kannst du beliebige Skripte und Programme in ~/bin, also z. B. /home/otto/bin ablegen und von überall her ohne Pfadangabe aufrufen. Wir werden das später noch brauchen.

Schreibe die Zeile oben in ~/.bashrc und ~/.profile, damit PATH dauerhaft (über eine

Sitzung hinaus) angepasst wird.

PS1 � Der Prompt Wenn du auf der Konsole arbeitest, siehst du vor deinem Cursor einen so genannten Prompt, z. B. otto@linux:~> Er kann ganz verschieden aussehen. Die dafür ver-antwortliche Variable ist PS1. Du lässt sie dir wie-der mit echo $PS1 anzeigen Sie gibt verschiedene Werte für normale Benutzer und root aus. Als root bekommst du z. B. \h:\w #

Bist du otto, sieht das so aus: \u@\h:\w>

Irgendwie ziemlich schlecht zu verstehen, oder �? Bringen wir also Licht in die Sache: Du kannst den Prompt grundsätzlich so aussehen lassen, wie du möchtest. Es stehen u.a. folgende Variablen zur Auswahl, die du einbinden kannst: \h Hostname

\w aktuelles Verzeichnis

\W letzter Teil des aktuellen Verzeichnisses (z. B. bin bei /usr/bin)

\u angemeldeter Benutzer

\$ das Promptzeichen ($ für normale User und # für root)

\t aktuelle Zeit

\d aktuelles Datum

Du kannst die Variablen durch normale Zeichen verbinden, also z. B. \u@\h \w> für otto@linux ~/bin> Übung: Baue dir nun deinen eigenen Prompt. Tra-ge die Variablenzuweisung für PS1 in ~/.profile ein, damit du den neuen Prompt bei der nächsten Anmeldung zugewiesen bekommst. Erzeuge einen Prompt, der so aussieht: Benutzer@Host - Datum, Uhrzeit - Aktuelles Verzeichnis $.

Dazu gibst du in der allerletzten Zeile von ~/.profile folgendes ein: PS1 = '\u@\h - \d, \t - \w \$'

Speichere deine Änderungen und melde dich ab und wieder an (natürlich mit demselben Benutzer).

Das Ergebnis sieht für otto folgendermaßen aus: otto@linux – So Sep 04, 12:01:25 – otto $

Über Sinn und Unsinn einer solchen Darstellung kann man nach Herzenslust streiten � wir wollten dir an dieser Stelle nur die Möglichkeiten demonst-rieren. Du kannst nun diese Zeile entweder nach eigenen Wünschen abändern oder ganz löschen. Damit wird wieder der Default-Prompt aktiv, der in den globalen Konfigurationsdateien festgelegt wird.

Wie du vielleicht schon bemerkt hast, sieht die Prompt-Variable PS1 in einer Shell unter KDE ganz anders aus:

Dies hängt damit zusammen, dass KDE die Shells selber verwaltet und daher auch eigene Mechanis-men greifen.

Es gibt noch viele weitere System- bzw. Umge-bungsvariablen, wie z. B. HOME (enthält den Pfad des Home-Verzeichnisses eines Benutzers) oder PWD (enthält den Pfad des aktuellen Verzeichnisses und wird vom gleichnamigen Befehl ausgelesen). Die meisten davon benötigst du nicht im täglichen Gebrauch, sie werden aber vom System und von verschiedenen Befehlen ausgewertet. Einen Über-blick gibt der Befehl export. Unsere Prompt-Variable PS1 nimmt eine Sonderstellung ein und wird in dieser Liste nicht angezeigt. Im Rahmen der Shellskript-Programmierung wer-den wir noch einmal auf Variablen der Shell zu-rückkommen. Bis dahin soll es hiermit genug sein.

Warum folgt jetzt nicht gleich das Kapitel über Shellprogrammierung? Klar, wir könnten an dieser Stelle das Pferd von hinten aufzäumen. Führen wir uns aber einmal den Sinn von Shellskripten vor Augen: Es geht darum, Routineaufgaben zu automatisieren. Dazu werden normalerweise verschiedene Befehle auf der Shell eingegeben. Befehle, die stattdessen im Shellskript verarbeitet werden � Befehle, die du vielleicht zu einem großen Teil noch gar nicht kennst! Daher werden wir in den nächsten Kapiteln erst einmal deine Werkzeugkiste füllen. Danach spre-chen wir dann gerne noch mal über Automatisie-rung �

Weitere nützliche Befehle


16

Weitere nützliche Befehle In diesem Kapitel lernst du ein paar sehr nützliche Befehle kennen, die du im täglichen Umgang mit Linux gut gebrauchen kannst. Wir werden dir in diesem Zusammenhang auch den einen oder ande-ren Trick zeigen, mit dem du dir das Leben einfa-cher machst. Und los!

find � Sherlock Homes Mit dem find-Kommando kannst du beliebige Da-teien und Verzeichnisse im Dateisystem auffinden. Der Befehl ist ein wenig kompliziert, so dass du dich eine Zeit lang eingewöhnen musst. Dafür ist er aber sehr mächtig und wird dir gute Dienste tun. Wir arbeiten praktisch täglich mit diesem Befehl. Er funktioniert folgendermaßen: find <Startverz> <Suchoptionen> -[Option]

Bevor wir zu einigen Beispielen kommen, hier zu-nächst ein Überblick über die Suchoptionen: -atime [+-]<Tage> letzter Zugriff in Tagen älter (+)

bzw. jünger (-) -mtime [+-]<Tage> letzte Änderung am Inhalt in Ta-

gen (sonst wie atime) -user <Name> gehört Benutzer -group <Name> gehört Gruppe -type <Datei-Typ> f = Datei

d = Verzeichnis l = Link

-name <Datei/Verz> Suche nach angegebenen Datei- oder Verzeichnisnamen

-size [+-]<Größe>k Größer (+) oder kleiner (-) als die angegebenen Kilobyte

-maxdepth <Level> maximale Verzeichnistiefe ab Startverzeichnis, bis zu der ge-sucht wird, Level wird in Ziffern angegeben.

Okay, hier die versprochenen Beispiele: find / -name gulugulu

findet ausgehend vom Root-Verzeichnis (/) alle Verzeichnisse oder Dateien, die exakt gulugulu heißen. find /home –group otto –type f

findet ausgehend von /home alle Dateien denen die Gruppe otto zugewiesen ist. find /home -user otto –mtime -3

findet alle Dateien des Benutzers otto unter /home, deren Inhalt innerhalb der letzten 3 Tage geändert wurde. Damit kannst du differenzielle Sicherungen durchführen, siehe Kapitel Cron � Der Taskplaner unter Linux, Seite 23. find / -user otto –size +3000k

findet alle Dateien des Benutzers otto, die größer als 3000 KB sind. Hiermit lassen sich Platzfresser finden. find /usr –type f –name gulugulu –maxdepth 3

Sucht unter /usr nach Dateien mit dem Namen gulugulu. Dabei wird bis maximal drei Unterver-zeichnisebenen hinabgestiegen. So, nun hast du einige Beispiele zu diesem Befehl bekommen. Du kannst dir leicht weitere Beispiele ausdenken. Erstelle einfach ein paar Dateien oder Verzeichnisse und teste, wie sie gefunden werden.

Das Trial and Error-Prinzip (ausprobieren und Fehler machen) nennen wir die Was-passiert-dann-Maschine. Sei neugierig und teste alles aus, überlege dir Szenarien und fahre Testrei-

hen. Teilweise mühsam, aber äußerst lehrreich. Dadurch lernst du am besten! Der Weg lohnt

sich �

Gut, aber damit sind wir noch nicht am Ende die-ses leistungsfähigen Befehls angelangt. Die Optionen hinter den Suchoptionen bestimmen, was mit dem Ergebnis der Suche geschieht. Solan-ge nichts weiter angegeben ist, gibt find sein Suchergebnis auf dem Bildschirm aus. Diese Opti-on entspricht –print und muss nicht angegeben werden. Darüber hinaus gibt es eigentlich nur noch eine Option, die für dich von Bedeutung ist: -exec <Befehl> {} \;

Also das ist nun wirklich erklärungsbedürftig! Wie du dir denken kannst, wird hier ein weiterer Befehl zur Ausführung (execution) gebracht. Er über-nimmt zeilenweise die Ausgabe von find. Das wird durch die geschweiften Klammern '{}' ausge-drückt. Der Passus '\;' folgt dahinter, da es sich um eine unbedingte Aneinanderreihung des ange-gebenen Befehls handelt (Befehle werden in der-selben Zeile durch Semikolons getrennt � siehe Seite 11) und das Semikolon daher maskiert wer-den muss (\), damit es nicht als zum Befehl selbst zugehörig interpretiert wird. Puh, ganz schön kompliziert! Hier ein Beispiel: find / -user gisela –type f –exec rm -f {} \;

findet alle Dateien der Benutzerin gisela und löscht diese ohne weitere Nachfrage (-f). Dies kann nützlich sein, wenn ein Benutzer (z. B. ein Mitar-beiter in einem Unternehmen) auf einem System nicht mehr arbeitet und seine Dateien nicht mehr benötigt werden.



17

Vorher solltest du aber in jedem Fall eine Siche-rung der Dateien vornehmen.

Dies zeigen wir dir im nächsten Kapitel ab S. 21.

locate � Dr. Watson Bei SuSE wird locate standardmäßig nicht mit installiert. Dies solltest du aber schleunigst nach-holen � dieser Befehl ist ein heißer Kandidat für den Olymp deiner Lieblingsbefehle. Mit locate gulugulu suchst du nach einer Datei oder einem Verzeichnis, die bzw. das gulugulu heißt oder im Namen enthält. Die Suche erfolgt erheblich schnel-ler als bei find, da hier eine vorher angelegte in-terne Datenbank durchsucht wird. Gibst du z. B. updatedb ein, aktualisierst du die Datenbank. Dies solltest du nach jeder Installation und jeder größe-ren Änderung an deinem System tun. Du kannst dies auch automatisieren, indem du ei-nen so genannten Cron-Job definierst. Details dazu bringt dir das Kapitel Cron � Der Taskplaner unter Linux auf Seite 23.

grep und die Regular Expressions Mit dem Befehl grep kannst du innerhalb von Textdateien nach Zeichenketten suchen: grep <Optionen> <Zeichenfolge> <Datei>

Findet grep das Gesuchte, wird die entsprechende Zeile angezeigt. Das Interessante ist, dass die Zei-chenfolge auch als regulärer Ausdruck (Regular Expression) angegeben werden kann. Das macht den Befehl sehr mächtig.

Der Ausdruck mächtig besagt, dass ein Kom-mando sehr viele Möglichkeiten bietet.

Stell dir vor, du möchtest in einer Textdatei (z. B. einer Logdatei wie /var/log/messages) nach be-stimmten Einträgen suchen. Dazu benötigen wir natürlich eine solche Datei. Um dieselben Ergeb-nisse zu bekommen, sollte diese bei dir genauso aussehen wie bei uns. Erstelle nun also eine Datei namens suchdatei.txt unter deinem Home-Verzeichnis (/home/otto) mit folgendem Inhalt � wobei jeder Satz in einem eigenen Absatz stehen sollte:

Eigentlich ist gulugulu alles und nichts!

Der perfekte Joker für alles, was man nicht speziell bezeichnen kann oder möchte:

- Dateien

- Textstellen

- Suchstrings Man braucht sich nicht ständig neue Fantasienamen auszudenken (z.B. datei123 oder $halleluja).

Das Wort 'Gulugulu' stammt eigentlich aus einem Donald-Duck-Comic, wo Onkel Dagobert unter der Dusche dieses Wort einfällt.

Es beschert "Bertel" später allerlei Ärger mit Gitta Gans ...

Fertig? Gut, dann lass uns einsteigen! Zunächst kennt auch grep wieder einige Optionen. Hier eine Übersicht über die wichtigsten: -i ignoriert Groß-/Kleinschreibung

-l gibt nur die Dateinamen an (wenn in mehreren Dateien gesucht wird)

-m gibt die Zeilennummer mit an

-w Ausdruck muss ein Wort sein (also nicht nur Be-standteil einer größeren Zeichenkette)

-x Ausdruck muss der ganzen Zeile entsprechen

-e ermöglicht fortgeschrittene reguläre Ausdrücke

Insbesondere die Option –i wirst du oft benötigen. Wenn du mit regulären Ausdrücken arbeitest, soll-test du bei komplizierten Ausdrücken vielleicht auch die Option –e nutzen, sonst kann es dir pas-sieren, dass dein Suchausdruck nicht oder falsch interpretiert wird. Statt –e kannst du i.d.R. auch egrep als Variante von grep nutzen. Für weitere Informationen kannst du auch mal www.heise.de/ix/artikel/2001/09/139/ besuchen. Der Artikel bietet einen guten Überblick.

Noch ein Wort zur Option –l: Du kannst statt einer einzelnen zu durchsuchenden Datei auch mehrere Dateien angeben. So würde z. B. *.txt alle Da-teien mit der Endung txt im aktuellen Verzeichnis durchsuchen � und nur dann macht die Option –l natürlich Sinn!

Doch testen wir nun ein paar Beispiele anhand un-serer selbst erstellten Datei. Lass uns folgenderma-ßen suchen: grep gulugulu suchdatei.txt Als Ergebnis wird Eigentlich ist gulugulu alles oder nichts! ausgegeben. Das ist die einfachste Anwendung. Die gesuchte Zeichenfolge kann auch nur ein Teil einer größeren Zeichenkette sein (es sei denn, du nutzt die Option –w). Im obigen Bei-spiel hätte die Suche nach �gulu� also den gleichen Effekt auf diese Zeile gehabt. Allerdings hätte diese Suche auch den Satz �Das Wort Gulugulu �� ausgegeben.



18

Wieder gilt:

Sind Sonderzeichen (auch Leerzeichen) im Suchstring enthalten, muss dieser mit einfachen

Hochkommas eingefasst werden.

Werfen wir nun einen Blick auf die regulären Aus-drücke. Einen Teil dieser Ersetzungen hast du ja schon auf Seite 11 kennen gelernt. Jetzt folgt also Teil 2. Hier zunächst der Überblick: . beliebiges Zeichen * vorheriges Zeichen beliebig oft \? vorheriges Zeichen ein- oder keinmal \+ vorheriges Zeichen ein- oder mehr-

mals ^<Ausdruck> Ausdruck am Zeilenanfang <Ausdruck>$ Ausdruck am Zeilenende [abc] Zeichen aus der Auswahl [a-z] Zeichen aus dem Bereich ! Negierung

Jetzt wird�s haarig! Die ersten Zeilen sind für dich wahrscheinlich erst einmal unverständlich, weil du doch im ersten Teil über reguläre Ausdrücke etwas anderes gelernt hast?!

Reguläre Ausdrücke werden leider nicht einheit-lich gehandhabt. Die Bash hat z.T. andere Er-setzungsregeln als bestimmte Programme wie z. B. grep, find oder die Skriptsprache perl.

Letztere folgen aber im Wesentlichen den RegEx-Konventionen.

Während du beliebige Zeichen in der Bash mit dem Asterisk (*) ausdrückst, verwendest du bei grep & Co. die Zeichenkette '.*'. Das ist verwir-rend? Finden wir auch, daher werden wir dir im Folgenden einige Beispiele geben, die die Funktio-nen der RegEx-Zeichen verdeutlichen. Du kannst sie anhand unserer Datei suchdatei.txt nach-vollziehen: grep –i eigentlich suchdatei.txt

findet beide Zeilen, die das Wort 'eigentlich' bein-halten. Hätten wir die Option –i weggelassen, wä-re die erste Zeile nicht angezeigt worden, da hier das 'E' groß geschrieben ist. Probiere es aus! grep –i ^eigentlich suchdatei.txt

findet nur die erste Zeile, da das zweite 'eigentlich' nicht am Anfang einer Zeile steht. grep s$ suchdatei.txt

dagegen findet nur die Zeile –Suchstrings, da nur sie mit �s� endet. grep e.*ch suchdatei.txt

findet alle Zeichenketten, die irgendwo ein 'e', da-nach beliebig viele Zeichen gefolgt von 'ch' enthal-

ten. Wenn du jetzt glaubst, du bekommst nur die Zeilen mit 'eigentlich', dann wirst du dich wun-dern, denn der Suchbegriff trifft auch auf 'bezeich-nen' und 'beschert' zu. grep \$.* suchdatei.txt

findet die Zeile mit '$halleluja='. Das Dollarzei-chen muss im Befehl maskiert werden, um nicht als Sonderzeichen erkannt zu werden. grep ".*[0-9]\+" suchdatei.txt

findet die Zeile mit datei123. Es wird nach belie-bigen Zeichen gesucht, gefolgt von einer beliebi-gen Ziffer, die ein- oder mehrmals auftaucht.

Nutzt du komplexe Ausdrücke dieser Art, solltest du immer doppelte Hochkommas benutzen, um

den Ausdruck einzuschließen. Er wird sonst oftmals nicht korrekt erkannt.

Regular Expressions (RegExe) haben die Eigen-schaft, manchmal ziemlich eigensinnig und uner-wartet zu reagieren. Wir empfehlen dir daher, den Gebrauch dieser Ausdrücke erst einmal intensiv zu üben! Spiel die Was-passiert-dann-Maschine und stell dir selbst Aufgaben. Hier noch ein paar Anre-gungen: Übung: Erstelle eine Datei suchdatei2.txt mit folgendem Inhalt:

9log

99log.txt

999logdatei

Aaa4711 alias für gelb

AAa4711 alias für blau

Hier die Aufgaben: 1. Suche nach einer Zeile, die mit einer Ziffer an-

fängt und anschließend einen oder mehrere Buchstaben hat (die erste Zeile sollte angezeigt werden)

2. Eine Zeile mit beliebig vielen 9en vorneweg, die nach einigen Buchstaben mit txt endet (zweite Zeile)

3. Eine Zeile, die mit einem großen A beginnt und danach mindestens zwei kleine a�s hat (vierte Zeile).

4. Eine Zeile, die drei A�s hintereinander hat, egal ob groß oder klein (vierte und fünfte Zeile).

Ganz schön heftig, was? Die RegExe haben es wirklich in sich. Aber eines können wir dir versi-chern: Kennst du dich damit aus, bist du King of the Castle! Es lohnt sich, in diesem Kapitel ein wenig länger zu verweilen und die Anwendung zu üben!



19

Der Befehl grep wird übrigens oft im Zusam-menhang mit anderen Befehlen genutzt. So kannst du die Ausgabe eines Befehls nach einem be-stimmten Suchstring durchsuchen lassen. ps ax | grep -i httpd

zeigt dir z. B. alle http-Prozesse an. Das sind die, die ein Webserver (vermutlich Apache) gestartet hat, der auf deinem System installiert ist. Keiner da? Dann läuft auch kein Webserver! Im Kapitel Der Systemstart und die Runlevels werden wir dir zeigen, wie du Kontrolle über die Dienste bekommst. Hast du KDE gestartet? Dann schau mal nach: ps ax | grep –i kde

� da dürfte dann schon einiges mehr angezeigt werden. Mit grep kannst du insbesondere Logfiles hervorragend durchsuchen. Diese sind oft sehr groß und damit unübersichtlich. Suchst du z. B. nach einer IP-Adresse oder einem Dienst, kannst du dies hier als Suchstring angeben.

wc � Kein Toilettenbefehl �! Es gibt einen kleinen, aber sehr nützlichen Befehl namens wc. Die Buchstaben stehen für word count, zu deutsch: Worte zählen. Die nützlichste Anwen-dung ist mit der Option –l möglich, da hier die Zeilen gezählt werden. Kombiniert mit einer Kon-struktion wie im vorigen Abschnitt ergibt dies z. B. die Anzahl der KDE-Prozesse: ps ax | grep –i kde | wc –l

18

Die Ausgabe (18) ist schlicht die Anzahl der Zei-len, die (von grep) übergeben werden, also die Anzahl der Fundzeilen. Schätzungsweise wird auch dieser Befehl für dich erst später an Bedeutung gewinnen, wenn du dein Linux-System richtig aufgebaut und etwas Erfah-rung gesammelt hast. Behalte ihn bis dahin einfach im Hinterkopf ☺.

cat � Von wegen Katze Der Befehl cat dient zum Anzeigen und Zusam-menfügen von Textdateien. Der Name des Befehls hat nämlich nichts mit dem englischen Wort für Katze zu tun sondern leitet sich aus concatenate (zusammenfügen) ab. Du kannst mit cat eine (Text-)Datei von Anfang bis Ende auf dem Bild-

schirm anzeigen lassen. Für längere Dateien bietet sich zum Betrachten allerdings eher less (oder more) an. Willst du jedoch eine Textdatei an eine andere, vorhandene anhängen, schreibst du Folgendes: cat teilx.txt >> komplett.txt

Achtung: Lässt du dir Binärdateien mit cat an-zeigen, kann es passieren, dass dein Zeichen-satz �verrutscht� und du nur noch Hieroglyphen angezeigt bekommst. Hier hilft ein blind einge-

gebenes reset.

sort � Der Ordnung halber Du hast den Befehl ja schon auf Seite 9 kennen ge-lernt. Hier noch einmal eine (ordentliche) Zusam-menfassung, was man sonst noch alles mit dem Befehl anstellen kann. Der Befehl kennt u.a. fol-gende Optionen: -c prüft, ob die Datei bereits sortiert ist -f behandelt Klein- und Großbuchstaben als

gleichwertig -m fügt zwei oder mehrere vorsortierte Dateien

zu einer großen sortierten Datei zusammen (geht schneller als erst zusammenfügen und dann sortieren)

-o <Datei> schreibt das Ergebnis in die angegebene Datei, die auch genauso wie die alte lauten kann

-r sortiert in umgekehrter Reihenfolge +n1 [-n2] berücksichtigt für die Sortierung nur die

Spalte n1 (Optional bis zur Spalte n2 - ex-klusive)

Beispiele: sort –m sortiert1 sortiert2 –o sortiert

fügt die beiden (vorsortierten!) Dateien sor-tiert1 und sortiert2 zusammen und schreibt sie in sortiert. ls –l | sort –r zeigt den Inhalt des Verzeichnisses in umgekehrter Reihenfolge an.

date � Wie spät ist es? Der Befehl zeigt dir alle Radiostationen im Sende-gebiet an � quatsch! Natürlich werden das Datum und die Uhrzeit ausgegeben:



20

Du kannst aber auch das Datum und die Uhrzeit über diesen Befehl setzen. Da das aber über KDE - analog zu Windows � sehr viel einfacher geht, empfehlen wir den neugierigen Lesern die Manpa-ge zu date. Unter KDE reicht ein Rechtsklick auf die Uhrzeit ganz rechts in der K-Leiste:

Hier findest du die Option DATUM & UHRZEIT EIN-STELLEN �

whoami � Wer bin ich? Für die Vergesslichen: Der Befehl whoami gibt den z.Z. aktuellen Benutzer aus, mit dem du arbeitest. Das klingt doof, kann aber ganz nützlich sein, wenn du mit su hantierst (siehe erstes Heft Seite 24) und verschiedene Benutzer bearbeitest. Da kommt man dann schon manchmal etwas durch-einander �

id � Wo bin ich Mitglied? Der Befehl id gibt dir sämtliche Mitgliedschaften deines gegenwärtigen Benutzers aus:

Insbesondere werden dir die IDs des Benutzers und der Gruppen, in denen er Mitglied ist, angezeigt.

who � Wer ist da? Das kleine Kommando gibt dir schlicht die Benut-zer aus, die sich an deinem System angemeldet ha-ben � Jede Konsole hat einen angemeldeten Benut-zer, du könntest dich also mehrfach entdecken �

Documents

Linux für Poweruser - download.knowware.de · KnowWare ' Amberg/Reeger: Linux für Poweruser Œ Probeseiten von 3 Inhaltsverzeichnis Willkommen zum Linux-Aufbaukurs!..... 5 Schleifen