Kommandozeilen verstehen und effizient nutzen

Axel Beckert

Debian / ETH Zürich

abe@debian.org
http://noone.org/abe/

Übersicht (1)

  • Was ist eine Shell?
  • Eine kleine Auswahl an gängigen Shells
  • Typische Funktionen heutiger Shells
  • Shell-Syntax: Eine kurze Übersicht
  • History Expansion und Completion
  • Tastenkürzel rund um die History
  • Directory Stack
  • Unbekanntere Wildcards und Ähnliches

Übersicht (2)

  • Job Control
  • Warum braucht man Quoting und wie funktioniert es?
  • Nützliche Shell Builtins
  • Nützliche Tools:
    • Editieren mit sed
    • Ausgaben und Abläufe mitprotokollieren
    • Umbenennen mehrerer Dateien
    • screen
  • Weitere Ressourcen / Links

Was ist eine Shell?

  • engl. für Muschelschale, Gehäuse
  • ugs. für Kommandozeileninterpreter/-schnittstelle (engl. command line interpreter/interface — CLI)
  • Mehr generell: Progamm zum interaktiven Aufrufen von Befehlen, z.B. Konqueror, Nautilus oder Midnight Commander.
  • Im folgenden wird der Begriff Shell mit einem Kommandozeileninterpreter gleichgesetzt.
  • Liest eine oder mehrere Zeilen Text ein, interpretiert diese als Kommando und führt sie aus.
  • Login-Shell: Wird automatisch aufgerufen wird, wenn sich der User im Text-Modu einloggt. Kann mit chsh geändert werden.

Kleine Übersicht über gängige Shells (1)

  • sh (Bourne Shell): UNIX V7, 1977/78
  • csh (C-Shell): 2BSD, 1979
  • ksh (Korn-Shell): UNIX System V; ksh88/ksh93 ist Grundlage des POSIX-Standards. Mittlerweile freie Software.
  • bash (GNU Bourne Again Shell): Ende der 80er entwickelt, steht unter der GPL, Standard-Shell unter vielen Linux-Distributionen und cygwin.
  • tcsh (TENEX-C-Shell): Standard-Shell auf vielen aktuellen BSD-Systemen, Autor ist NetBSD-Entwickler.
  • zsh (Z-Shell): 1989, Vereint viele Features von bash, tcsh und ksh. Lange Zeit Standard-Shell auf Macs.

Kleine Übersicht über gängige Shells (2)

  • pdksh/oksh (Public Domain/OpenBSD Korn-Shell): Freier, aber nicht vollständiger Rewrite der ksh; Standard-Shell unter OpenBSD. Entwicklung eingeschlafen.
  • mksh (MirBSD Korn-Shell): Performante, standard-konforme, portable Korn-Shell; Fork von pdksh/oksh; Standard-Shell unter MirBSD, FreeWRT, MidnightBSD und Android.
  • ash (Almquist Shell): Kompakte und schnelle Neuentwicklung der Bourne Shell; wird als Bestandteil von Busybox oft auf Embedded Systemen oder z.B. während der Installation verschiedener Linux-Distributionen eingesetzt.
  • dash (Debian Almquist Shell): Fork der ash, Stellt /bin/sh auf Debian (ab Squeeze 6.0) und Ubuntu (ab Edgy Eft 6.10).
  • sash (Stand-Alone Shell): Shell, die die wichtigsten Befehle eingebaut hat. (Rettungsshell)

Typische Funktionen heutiger Shells

  • Navigieren im Verzeichnisbaum
  • Umleitung von Ein- und Ausgabe von Programmen
  • Expansion von Wildcards (Ausnahme: DOS/Windows)
  • Job Control (Ausnahmen: ash, sh, DOS/Windows, ohne TTY)
  • Globale + benutzer-eigene Konfigurationsdateien, z.B. .bashrc, .cshrc, .tcshrc, .zshrc
  • History, "durchscrollbar" mit Cursortasten (Ausnahmen: sh, csh, command.com ohne doskey)
  • File-Completion mit der Tabulator-Taste (Ausnahmen: sh, csh, command.com, cmd.exe mit Defaultkonfig. bis WinXP)

Shell-Syntax (1/5): Befehle kombinieren

  • Direkt hintereinander ausführen:
    mkdir dir; mv foo dir; cd dir
  • Befehl2 ausführen, wenn Befehl1 erfolgreich:
    mv foo bar && head bar
  • Befehl2 ausführen, wenn Befehl1 nicht erfolgreich:
    grep foo bar || echo bar in foo nicht gefunden

Shell-Syntax (2/5): Ein- und Ausgabe umleiten

  • Ausgabe (STDOUT) in Datei umleiten:
    grep foo bar > foos-in-bar
  • Ausgabe (STDOUT) an Datei anhängen:
    grep foo2 bar >> foos-in-bar
  • Ausgabe in weiteren Befehl umleiten:
    tail -f foo | grep bar
  • Eingabe aus Datei lesen: ftp < ftp-kommandos.txt
    Alternativ auch: cat ftp-kommandos.txt | ftp

Shell-Syntax (3/5): Ausgabe als Argumente verwenden

  • ogg123 `find . -name '*.ogg'` (ohne Quoting nicht schachtelbar)
  • ogg123 $(find . -name '*.ogg') (nicht csh, tcsh)
  • find . -name '*.ogg' | xargs ogg123
  • find . -name '*.ogg' -print0 | xargs -0 ogg123
    (auch mit Leer- und Sonderzeichen in Dateinamen)

Shell-Syntax (4/5): Bourne-Shell Schleifen

while-Schleifen

$ while true; do echo -n .; sleep 1; done;
$ while :; do echo -n .; sleep 1; done;
$ until false; do echo -n .; sleep 1; done;

Schleife über Liste von Werten

$ for i in 1 2 3 4 5 6; do echo $i; sleep 1; done;
$ for i in `seq 1 6`; do echo $i; sleep 1; done;
$ for i in {1..6}; do echo $i; sleep 1; done # (nicht mksh, pdksh)
$ for ((i=1; i<=6; i++)); do echo $i; done # (nicht mksh, pdksh)

Shell-Syntax (5/5): C-Shell Schleifen

Die Schlüsselkommandos while (...), for (...), foreach (...) und end müssen jeweils in einer eigene Zeile stehen. In der History wird jeweils nur die erste Zeile des Kommandos gespeichert.

> while (1)
while? echo -n .; sleep 1;
while? end

> while ({true})
while? echo -n .; sleep 1;
while? end

> foreach i (1 2 3)
foreach? echo $i; sleep 1;
foreach? end

History Expansion und Completion

Übliche, aber oft ineffiziente Nutzung der History

  • Im Terminal hochscrollen und dann Cut & Paste (meist mit der Maus)
  • "Durchscrollen" per Cursortasten
  • history | grep foobar und dann Cut & Paste (meist mit der Maus)

History Expansion Completion

History Expansion: Die richtige Zeile

  !!        Letzte Kommandozeile
  !3        Dritte Kommandozeile
  !-2       Vorletzte Kommandozeile
  !foobar   Letzte Kommandozeile, die mit »foobar« begann
  !#        Alles, was bisher in dieser Zeile getippt wurde.
  !?foobar  Letzte Kommandozeile, die »foobar« beinhaltete

History Expansion: Der richtige Parameter

  :*    Alle Parameter, z.B. !!:*
  :^    Erster Parameter, z.B. !less:^
  :$    Letzter Parameter, z.B. !3:$
  :2    Zweiter Parameter, z.B. !-2:2
  :2-4  Zweiter bis vierter Parameter, z.B. !#:-2
  :0    Letztes Programm ohne Parameter, z.B. !:0

History Expansion: Ausschnitte, Quoting

  :h  (head) entfernt letzte Pfadkomponente, z.B. /foo/bar → /foo
  :t  (tail) entfernt Pfad von einer Datei, z.B. /foo/bar → bar
  :r  (root) entfernt letzte Dateiendung, z.B. foo.x.y → :r:r → foo
  :e  (extenstion) Dateiendung, z.B. foo.bar → .bar

  :u  Großbuchstaben (nur tcsh und zsh): tcsh erster, zsh alle
  :l  Kleinbuchstaben (nur tcsh und zsh): tcsh erster, zsh alle

  :p  Ergebnis nur ausgeben, nicht ausführen

  :q  Ergebnis quoten, keine weiteren Ersetzungen
  :x  Ergebnis quoten, keine weiteren Ersetzungen, Parameter an
      Leerzeichen aufsplitten

History Expansion: Ersetzen und Kurzformen

  :s/a/b/     »a« einmal durch »b« ersetzen
  :gs/a/b/    Alle »a« durch »b« ersetzen
  :as/xx/x/   Im ersten Wort solange wie möglich »xx« durch »x« ersetzen
              (nur tcsh und csh, Gefahr von Endlosschleifen!)
  :ags/xx/x/  Solange wie möglich »xx« durch »x« ersetzen (tcsh, csh)

  !^, !$, !:2, !*  Erster, letzter, zweiter bzw. alle Parameter des
                   letzten Befehls. Entspricht !!:^, !!:$, !!:2, !!:*
  ^a^b             Ersetze einmal »a« durch »b« im letzten Befehl.
                   Entspricht !!:s/a/b

History Expansion: Beispiele ohne und mit

  $ tar cvf foobar-1.2.3woody4_i386.tar foobar
  $ gzip -9v foobar-1.2.3woody4_i386.tar
  $ mv foobar-1.2.3woody4_i386.tar.gz foobar-1.2.3woody4_i386.tgz
  $ mkdir backup
  $ mv foobar-1.2.3woody4_i386.tgz backup
  $ mv backup Backup
  $ cd Backup

  $ tar cvf foobar-1.2.3woody4_i386.tar foobar
  $ gzip -9v !:2
  $ mv !$.gz !$:r.tgz
  $ mkdir backup
  $ mv !mv:$ !$
  $ mv !$ !$:s/b/B
  $ cd !$

Zeilen nicht in die History aufnehmen

Zeilen, die mit einem Leerzeichen beginnen, werden nicht in der History gespeichert. (Nur bash und zsh, optional.)

 bash $ HISTCONTROL=ignorespace
  zsh $ setopt HIST_IGNORE_SPACE
      $ echo foo
      foo
      $  echo bar
      bar
      $ !!
      echo foo
      foo

Kommandozeile in Editor editieren

Mit fc (für "Fix Command" — "Repariere Kommando") kann man bereits eingegebene Kommandozeilen editieren und erneut ausführen. (Nur bash, zsh und ksh.)

  • fc: Editiert letztes Kommando in $FCEDIT und führt es aus.
  • fc -l -10: Listet die letzten 10 Kommandos auf
  • fc -1 -2: Editiert die letzten beiden Kommandos in $FCEDIT und führt sie anschließend aus.

In der History interaktiv suchen (Think Emacs)

  • bash, zsh, ksh: Ctrl-R
  • tcsh: Ctrl-R möglich mit bindkey ^R i-search-back
  • tcsh, zsh: Nach Text auf Kommandozeile suchen mit Meta-P (rückwärts) und Meta-N (vorwärts), bei FreeBSD per Default auch mit "Cursor hoch" (erreichbar mit bindkey up history-search-backward)

Worte aus der History einfügen

  • tcsh, zsh: Letztes eingebenes Wort: Control-Meta-Minus (M-^-, funktioniert wie !#$ bei der History Expansion)
  • tcsh, zsh, bash, ksh: Letztes Wort des letzten Kommandos: Meta-_ (M-_, funktioniert wie !$ bei der History Expansion, bash auch Meta-. bzw. M-.)

(Zurück in) das letzte Verzeichnis

  • cd -
  • cd $owd / echo $owd (tcsh, csh)
  • cd $OLDPWD / echo $OLDPWD (bash, zsh, ksh, ash)

Der Directory Stack

Funktioniert unter bash, tcsh, zsh und z.T. auch in der cmd.exe.

  • pushd foobar: Schiebt das aktuelle Verzeichnis auf den Directory Stack und wechselt in das Verzeichnis »foobar«.
  • popd: Entfernt das oberste Verzeichnis vom Directory Stack und wechselt in dieses.
  • dirs: Listet die Verzeichnisse im Directory Stack auf.
  • pushd +1: Rotiert durch die Verzeichnisse im Directory Stack Analog dazu: pushd +2, pushd -1

Unbekanntere Wildcards und Ähnliches

  $ ls
  foo.a  foo.b  foo.b~  foo.c  foo.c~
  $ ls foo.[ab]
  foo.a  foo.b
  $ ls *[^~]
  foo.a   foo.b  foo.c
  $ unset nonomatch
  $ touch bar.[fg]
  touch: No match.
  $ set nonomatch
  $ touch bla.[fg]
  $ touch fnord.{f,g}
  $ ls
  bla.[fg]  fnord.f  fnord.g  foo.a  foo.b  foo.b~  foo.c  foo.c~

Job Control

  • Ctrl-Z: Hält den aktuell laufenden Job an und kehrt zur Shell zurück. (Sendet kill -SUSP an den Prozeß.)
  • abc &: Startet Befehl »abc« und schiebt ihn in den Hintergrund.
  • fg %2: Holt Job Nr. 2 wieder in den Vordergrund (engl. foreground)
  • bg %3: Schiebt den angehaltenen Job Nr. 3 in den Hintergrund (engl. background), damit er dort weiterlaufen kann.
  • jobs: Zeigt im Hintergrund laufende und angehaltene Jobs an.

Welcher Job?

  • %% und %+: Letzter Job
  • %-: Vorletzter Job
  • %2: Zweiter Job
  • %foo: Letzter Job, der mit »foo« beginnt
  • %?foo: Letzter Job, der »foo« beinhaltete (nicht ash)

Job Control abgekürzt

  • fg %, %%, %+, fg (jeweils als Befehl): Kurz für fg %%
  • %: Kurz für fg %% (Nur bash, tcsh und zsh)
  • %-: Kurz für fg %-
  • %2: Kurz für fg %2
  • bg: Kurz für bg %%
  • %foo, %?foo (jeweils als Befehl): Kurz für fg %foo bzw. fg %?foo

Was ist Quoting?

  • Quoting ist das Entfernen der besonderen Bedeutung bestimmter Zeichen in Zeichenketten, sodass diese literal verwendet werden.
  • Setzt man hierzu ein Zeichen vor das zu quotende Zeichen, wird gerne auch von Escaping gesprochen, obwohl dieser Begriff eigentlich eine umfangreichere Bedeutung hat.
  • Vermutlich am häufigsten gequotet wird das Leerzeichen.

Wozu brauche ich Quoting? (1)

  • mv Ein Lied.ogg Ein-Lied.ogg
    mv Ein\ Lied.ogg Ein-Lied.ogg oder
    mv 'Ein Lied.ogg' Ein-Lied.ogg oder
    mv "Ein Lied.ogg" Ein-Lied.ogg oder
    mv Ein' 'Lied.ogg Ein-Lied.ogg oder
    mv Ei'n L'ied.ogg Ein-Lied.ogg
  • fgrep -rc Changelog
    fgrep -- -rc Changelog

Wozu brauche ich Quoting? (2)

  • Wie lösche ich eine Datei mit Namen "-rf ."?
    Mit rm ./-rf\ . oder
    rm './-rf .' oder
    rm "./-rf ."
  • echo <Ctrl-C> muß man auch quoten können.
    echo <Ctrl-V><Ctrl-C> muß man auch quoten können.

Die drei Ebenen des Shell-Quotings

  • Terminal- und Schnittstellen-Quoting
  • Kommandozeilen-Quoting — das eigentliche Shell-Quoting
  • Anwendungsquoting

Terminal- und Schnittstellen-Quoting

  • Quoting von Zeichen oder Tastendrücke (z.B. Ctrl-C, Ctrl-Z, etc.), die von Terminal (z.B. VT52) oder Anwendung bzw. interaktiver Shell (z.B. Emacs, Bash/Readline, etc.) direkt interpretiert werden.
  • Quoting oft mit Ctrl-V oder Ctrl-Q.

Terminal- und Schnittstellen-Quoting (2)

Beispiele

  • Shell: echo <Ctrl-V><Ctrl-C> muss man auch irgendwie quoten.
  • Emacs und Konsorten: Ein <Ctrl-Q><Ctrl-C> muss man auch irgendwie quoten.
  • vim: <Ctrl-V><Ctrl-C> muss man auch im Insert-Modus irgendwie quoten.
  • Viele andere vi-Klone: Ein <Ctrl-C> muss man im Insert-Modus nicht extra quoten.

Terminal- und Schnittstellen-Quoting (3)

Umkonfigurieren

  • bash/readline via .inputrc: Control-v: quoted-insert
  • tcsh via .tcshrc: bindkey -b ^v quoted-insert
  • GNU Emacs via .emacs: (global-set-key "\C-q" 'quoted-insert)

Quoting zwischen Benutzer und Shell

  • telnet: ^] kann nicht gequotet werden, aber mit der Option -E ganz abgeschaltet werden.
  • ssh (und tlw. auch rsh/rlogin): ~ muss in einer ssh-Session am Zeilenanfang durch ~~ (bei toter Tilde mit ~<Leerzeichen>~<Leerzeichen>) gequotet werden, falls sie zusammen mit dem nächsten Tastendruck ein ssh-Kommando (z.B. ~? oder ~^Z) ergibt.
  • screen: Ein ^A muss in einem Screen durch <Ctrl-A> <A> gequotet werden.

Kommandozeilen-Quoting

  • Quoting von Zeichen, die die Shell zum Trennen von Parametern, als Wildcard, für Ein- und Ausgabe-Umleitung, als Variablen oder als Quoting-Zeichen interpretieren würde.
  • Umschließen mit Gänsefüßchen oder einfachen Anführungszeichen.
  • Escaping mit Backslash: Nimmt dem darauffolgenden Zeichen seine besondere Bedeutung (Ausnahmefall: Zeilenumbruch).
  • Expansion von Wildcards abschalten: set -f (bash/ksh/sh), set -F oder noglob kommando * (beides zsh) oder $noglob (tcsh)

Unterschied zwischen "…" und '…'

  • "…" verhindert die Interpretation von Wildcards, Ein- und Ausgabe-Umleitung, einfachen Anführungszeichen, Leerzeichen, Tab und Zeilenumbruch.
  • '…' verhindert die besondere Interpretation aller Zeichen (inkl. Backslash) ausser einfachen Anführungszeichen selbst, d.h. '\'' geht nicht. (Ausnahme: Quotet kein Ausrufezeichen in der tcsh → History-Expansion dort auch innerhalb von einfachen Anführungszeichen.)

Anwendungsquoting

  • Quoting von Parametern sodass die Anwendung diese nicht als Option oder sonstwie besonderen Parameter betrachtet.
  • Von Anwendung zu Anwendung verschieden, jedoch oft gleich oder ähnlich.
  • Kommen die gleichen Quoting-Zeichen wie beim Kommandozeilen-Quoting vor, muss tlw. doppelt gequotet werden.
  • Manchmal einfach nicht möglich → schlecht programmiert.

Oft benötigtes Anwendungsquoting

  • ./- statt - für Dateien, die mit Minus beginnen: mv ./-foo foo
  • -- als Abschluss der Optionen-Liste (u.a. GNU Utilities): fgrep -- -rc Changelog
  • ./ vor Dateinamen mit Doppelpunkt bei scp und tar: tar cvzf ./bla:fasel.tgz blafasel; scp ./bla:fasel.tgz host:bla:fasel.tgz
  • Shell-Sonderzeichen, die beim Remote-Aufruf per ssh/rsh auf dem anderen Rechner interpretiert werden sollen:
    ssh rechner cat bla '>' foo oder
    ssh rechner 'cat bla > foo'

Beispiel

Wir wollen eine Datei umbenennen, deren Name aus einem Minus (»-«), einer Pipe (»|«) und einem Ctrl-C (»^C«) besteht: mv -|^C foobar

  1. Parameter, die mit »-« beginnen, sieht mv als Optionen.
    Quoting mit vorangestelltem »./«: mv ./-|^C foobar
  2. »|« ist ein Sonderzeichen der Shell für die Umleitung von Ein- und Ausgabe. Quoting mit vorangestelltem Backslash »\«: mv ./-\|^C foobar
  3. Ctrl-C wird von der Shell abgefangen und bricht die Eingabe ab. Quoting mit vorangestelltem Ctrl-V: mv ./-\|^V^C foobar

Auswertungsreihenfolge am Bsp. der sh

  1. Syntax des Kommandos analysieren (Parsen): Aufsplitten in Parameter, Quoting, Umleitung von Ein- und Ausgabe, Erkennen (aber nicht Auswerten) von Variablen.
  2. Ersetzen von Variablen durch Inhalte und Backquoting (»`…`«, tlw. auch »$(…)«) durch Output.
  3. Nochmals Aufsplitten an Leerzeichen, Zeilenumbrüchen und Tabs, etc. (ausser bei "`…`" oder "$VAR")
  4. Globbing (Auswerten von Wildcards)
  5. Quoting (beim Parsen erkannte Anführungszeichen und Backslashes) entfernen.

Nützliche Shell-Builtins

  • type programm: Gibt aus, ob ein Befehl ein Builtin, Alias oder Programm ist (nicht tcsh, csh)
  • which programm: Gibt erste Fundstelle des Befehls aus. (Programm-Pfad/Builtin/Alias; nicht bash → /usr/bin/which)
  • where programm: Gibt alle Vorkommen des Programmes im Pfad aus bzw. ob es ein Alias oder Builtin ist. (tcsh, zsh; sonst: /usr/bin/whereis)
  • =ls: Kurz für `which ls` (zsh, opt., vgl. mutt -f =adam)
  • pwd -P, pwd -L: Akt. Verz. ohne/mit Symlink (bash, ksh, zsh)
  • kill %job: Job mit Bezeichnungen wie bei Job Control killen (nur tcsh, zsh), sonst PID notwendig.

Globale Aliasse der zsh

  $ alias -g T='| tail'
  $ fgrep bla /var/log/messages T

  $ alias -g SUS='| sort | uniq -c | sort -n'
  $ awk '{print $1}' /var/log/messages SUS

  $ alias -g ...='../..'
  $ cd ...

Achtung! Bei unvorsichtiger Verwendung gefährlich! → In den meisten Fällen lieber Funktionen oder Shellskripte machen.

Nützliche Tools (1): Dateien bearbeiten mit sed

Problem: sed -e 's/foo/bar/' datei > datei endet mit Datenverlust.

Lösung: Option Inline-Edit (bei Perl, ssed oder neuerem GNU sed):

     $ sed -e 's/foo/bar/' -i datei
     $ perl -pe 's/foo/bar/' -i datei

Nützliche Tools (2.1): Mitprotokollieren

Problem: Man will einerseits direkt die Ausgabe eines Befehls sehen, aber auch in eine Datei mitloggen.

Lösung: Output durch tee dateiname (Mnemonic: T-Kreuzung) pipen:

  • z.B. grep bla access.log | tee bla.log
  • Mit STDERR: grep bla access.log 2>&1 | tee bla.log (sh, bash, zsh, ksh, etc.)
  • bzw. grep bla access.log |& tee bla.log (tcsh, csh)

Nützliche Tools (2.2): Mitprotokollieren

Problem: Man macht umfangreiche Installations- oder Upgrade-Arbeiten in der Shell und will das alles mitprotokollieren.

Lösung: Das Tool script (Paket "bsdutils" bei Debian) startet eine Subshell und protokolliert jeden In- und Output in eine Logdatei. Erzeugtes Protokoll kann mit scriptreplay wieder abgespielt werden.

Nützliche Tools (3): Umbenennen vieler Dateien auf einmal

Problem: Da unter Unix die Shell die Wildcards auswertet, geht mv *.jpg *.jpeg im Gegensatz zu DOS nicht.

Lösung: Diverse Tools: (p)rename aus "perl"; rename.ul aus "util-linux"; qmv, qcp, imv, icp und deurlname aus "renameutils".

$ mmv '*.jpg' '#1.jpeg'            $ mmv '*---*' '#1 - #2'
$ prename 's/jpg$/jpeg/' *.jpg     $ prename 's/_/ /g' *.ogg
$ rename.ul jpg jpeg *.jpg         $ rename.ul Wierd Weird *.ogg
$ qmv *.ogg                        $ qcp *.jpg
$ for i in *.ogg; do imv $i; done  $ for i in *.jpg; do icp $i; done
$ deurlname bla%20foo → "bla foo"  $ convmv -f latin1 -t utf-8 *.ogg

$ mrename '*.jpg' prefix   # a.jpg b.jpg → prefix1a.jpg prefix2b.jpg

Nützliche Tools (3.1): screen

  • "Window-Manager" für Text-Modus
  • mehrere Shells in einem Textfenster, Vollbild oder geteilt
  • Rechner wechseln ohne Programme beenden zu müssen.
  • Interaktive Text-Modus-Programme (z.B. OGG-Player, IRC, ICQ, gdb) oder Compile-Jobs laufen lassen ohne permanent eingeloggt zu sein.
  • Von mehreren Shells aus gleichzeitig auf die gleichen Text-Anwendungen zugreifen (nur bei selbem Benutzer).
  • Copy & Paste sowie Zurückscrollen im Textmodus und ohne Maus

Nützliche Tools (3.2): screen

  • Screen starten: screen
  • Laufende und abgehängte ("detached") Screens auflisten: screen -ls
  • Wieder verbinden: screen -r
  • Wieder verbinden und andere Verbindung trennen: screen -r -d (… und ausloggen mit -D statt -d)
  • Verbinden oder starten, falls kein screen läuft: screen -R
  • Remote Power Detach: screen -R -D
  • Zusätzlich mit bestehender Session verbinden: screen -x

Nützliche Tools (3.3): screen

  • Ctrl-A a: "Ctrl-A" eingeben (z.B. zum Zeilenanfang gehen)
  • Ctrl-A ?: Hilfe / Anzeige der Tastaturkommandos
  • Ctrl-A c, Ctrl-A Ctrl-C: Neues Fenster mit Shell
  • Ctrl-A Ctrl-A: Zurück zu letztem Fenster
  • Ctrl-A ␣, Ctrl-A n, Ctrl-A Ctrl-N: Nächstes Fenster
  • Ctrl-A ↤, Ctrl-A p, Ctrl-A Ctrl-P: Vorheriges Fenster
  • Ctrl-A 0, Ctrl-A 1, etc.: Gehe zu Fenster 0, 1, etc.
  • Ctrl-A d, Ctrl-A Ctrl-D: Detach screen
  • Ctrl-A x, Ctrl-A Ctrl-X: Lock screen

Nützliche Tools (3.4): screen

  • Ctrl-A t, Ctrl-A Ctrl-T: Uhrzeit und Load anzeigen
  • Ctrl-A Shift-A: Fenstertitel setzen
  • Ctrl-A w / Ctrl-A ": Fensterliste anzeigen / zum auswählen
  • Ctrl-A Shift-S, Ctrl-A |: Fenster aufteilen
  • Ctrl-A Tab: Zwischen aufgeteilten Fenstern wechseln
  • Ctrl-A Shift-Q: Aktuelles Fenster als einziges anzeigen
  • Ctrl-A [, Ctrl-A Ctrl-[: Copy&Paste starten, Block mit c
  • Ctrl-A ], Ctrl-A Ctrl-]: Paste
  • Ctrl-A h: Screenshot ("Hardcopy")

Nützliche Tools (4): Sonstiges

  • ncdu, xdu, xdiskusage
  • buthead, since/logtail, multitail, inotail
  • loco/ccze/colortail, colordiff, colormake, colorgcc
  • cut -c-80 (textutils), gpm
  • less -S, less -N, less +G, less +F, less +/xyz

Danke

  • David Frey für Anregungen und Ideen.
  • Euch fürs Zuhören und Mitmachen.