Bearbeiten von „Wissen/Bourne Shell“

= Bourne-Shell: Geschichte und Grundlagen =

* Datum: 5. Februar 2021
* Referent: Tilman Kranz [mailto:tilt@linuxfoo.de tilt@linuxfoo.de]
* Ca. 120 Minuten

== Teil 1: Geschichte ==

=== Thompson-Shell ===

* Erste Shell für AT&amp;T UNIX (“UNICS”) Version 1 bis 6
* Name des Programms: “sh” (liegt im Verzeichnis “/bin”). Also lautet der absolute Pfadname <code>/bin/sh</code>,
* Aufgaben:
** Starten von Programmen
** Umleiten von Ausgaben (“Redirection”) in andere Programme (“Filter”) oder in Dateien.
* Siehe auch Manpage https://www.in-ulm.de/~mascheck/bourne/v3/

=== Bourne-Shell ===

* Nachfolger der Thompson-Shell ab AT&amp;T UNIX Version 7.
* Hauptaugenmerk auf “Command Language” (mit Bedingunge, Schleifen u.v.a.m.).
** Syntax der Sprache inspiriert von ALGOL68.
* Außerdem können Shell-Skripten selbst Filter sein (ging bei Thompson Shell nicht).
* Seit 1989 quasi quasi unverändert, vergleiche auch: https://en.wikipedia.org/wiki/Bourne_shell#Features_introduced_after_1979
* Code der Bourne Shell war die Inspiration für den International Obfuscated C Code Contest&quot;.

=== C-Shell ===

* Entwickelt von der “Berkeley Group” (BSD) als Alternative zu Bourne Shell.
* Inspiriert von C-Syntax.
* Komfortabler als die Bourne Shell für interaktive Benutzung.
* Gilt inzwischen als veraltet (“C Shell Programming considered harmful”).

=== Korn-Shell ===

* Kompatibel zur Bourne-Shell.
* Mehr Funktionen.
* Sehr viel besser für interaktive Benutzung:
** History,
** Commandline editing,
** Job-Kontrolle.
* Wichtige Versionen:
** 88: Grundlage für POSIX:
*** https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html
** 93: Kompletter Rewrite, viel mächtiger, verbraucht aber viel mehr Speicher und CPU.

=== Bourne-Again-Shell ===

* Autragsarbeit eines Festangestellten der Free Software Foundation für das GNU-Projekt.
** Auf BSD nicht standardmäßig installiert bzw. oft in <code>/usr/local/bin</code> o.ä.
* Kompatibel zu Bourne Shell:
** Spezieller Kompatibilitätsmodus wenn als “sh” aufgerufen
* Arrays.
* “shopt” statt “set” für Bash-spezifische Optionen
* Stark erweiterte Parameter-Expansion
** z.B. Substitution,
** Siehe Manpage.
* Verbesserte Arithmetik.
* Erweiterte Redirection.
* Sehr stark verbesserter interaktiver Modus ähnlich Korn Shell.

=== Almquist-Shell (“ash” bzw. “dash”) ===

* Reimplementation der Bourne Shell unter anderer Lizenz.
* Zuerst für BSD, später portiert auf Debian (dort “dash”).

=== Z-Shell ===

* Reimplementation der Bourne Shell mit stark erweiterten Features.
* Empfohlen als interaktive, nicht aber als nicht-interaktive Shell.
** Grund: Shell-Skripten in zsh setzen installierte zsh voraus.

=== Kompatibilität ===

* Kern: Bourne Shell.
* Aber Vorsicht: Auch in Bourne-kompatinlen Shells (also allen ausser C-Shell) kann man Code schreiben, der in Bourne ''nicht'' geht.

== Teil 2: Grundlagen ==

=== Funktionsweise ===

* Betriebsmodus “interaktiv”.
** Spezialfall “Login-Shell”.
** Zeilenweise Ein- und Ausgabe über ein tty (“Teletype”, Printer, serielle Schnittstelle, Terminal, Terminal Emulator).
* Betriebsmodus “non-interaktiv”
* “Shebang”-Konvention in Skripten (erste Zeile <code>#!/bin/sh</code>).
* Kommentare
* Line Continuation
* Shell-Optionen, die den Betriebsmodus verändern (z.B. <code>-e</code>, <code>-x</code>)
* Zeilenbasierter Parser
* Expansionen
** Siehe dazu z.B. die Manpage von “dash”, Abschnitt “Word Expansions”
* Kontrollstrukturen
* Redirection und Pipes

=== Grundsätzliche Features ===

* “Strings are first-class citizens and the only citizens” – Stephen Bourne
* Es gibt kein “goto” (Bourne ist ALGOL-Fan)
* Hauptaufgaben:
** Zuweisungen
*** Spezialfall: “export”
** Kommandos ausführen
*** builtins vs. executables
* Variablen:
** Einfach: “foo=bar”
** Export an Subprozesse: “export FOO=bar”
** Zugriff auf den Wert der Variable:
*** <code>echo &quot;$foo&quot;</code> (“verkürzte Syntax”)
*** <code>echo &quot;${foo}&quot;</code> (“vollständige Syntax”)
** Variablen mit Bedeutung für die Shell selbst (Beispiele): PATH, PS1, IFS, …
** “Interessante” Umgebungsvariablen: PATH, USER, SHELL, PPID, …
* Expansion:
** Gute Übersicht:

https://www.gnu.org/software/bash/manual/html_node/Shell-Expansions.html
** Besonders wichtig: Parameter-Expansion:
*** Kommandozeilen-Argumente <code>$*</code>, <code>$@</code> und <code>$0</code>, <code>$1</code>, …
*** Spezial-Features mit “ausführlicher Syntax”:
**** <code>config=${1:-config.inc}</code>:

“Der Wert der Variable”config&quot; ist der Wert des ersten Kommandozeilen-Arguments, es sei denn, dieses wäre leer oder nicht gesetzt, dann soll der Wert ‘config.inc’ lauten.&quot;
*** Bourne Shell hat noch andere interessante Parameter-Exansion-Tricks, und Bourne Again Shell noch viel mehr.
** Wichtig: Command Substitution:
** Mit Backticks:

   output=`ls | grep foo`

** <em>oder</em> mit Klammerung:

   output=$(ls | grep foo)

*** Die geklammerte Syntax hat u.a. den Vorteil, dass sie einfacher verschachtelt werden kann.
** Nützlich: Arithmetik (nur Ganzzahlen): <code>a=0 ; a=$((a+2)) ; echo $a</code>

* Arbeiten mit Rückgabewerten
** Abgespeichert in <code>$?</code>
** Konvention: 0: Erfolg; Sonst: Fehler.

* Quotierung
** Klassisch mit <code>&quot;</code>, desweiteren auch mit <code>'</code>
** Spezialfall: Here-Documents

   sed -e 's/foo/bar/g' << EOF
   Ein foo kam daher
   zum foo und danach noch zu einem anderen foo. 
   EOF

** <em>Hinweis:</em> Here-Documents kamen im Vortrag aus Zeitgründen nicht dran.
** Herausforderung: Escaping:
** Beispiel 1: <code>echo &quot;\&quot;Doppelte\&quot; Anführungszeichen&quot;</code>
** Beispiel 2: <code>echo '\'Einfache\' Anführungszeichen'</code>

* Kontrollstrukturen:
** <code>if true ; then echo &quot;passt.&quot; ; else echo &quot;komisch&quot; ; fi</code>
** bzw. auf mehreren Zeilen:

   if true ; then
      echo "passt"
   else
      echo "komisch"
   fi

* <code>while true ; do echo &quot;idle ...&quot; ; sleep 1 ; done</code>
* bzw.

   while true ; do
      echo "idle ..."
   done

* Generell:
** Interaktiver Modus: Einzeiler-Syntax.
** Non-Interaktiver Modus/Skript: Mehrzeilige Syntax.

* Funktionen definieren
** Bourne und Bourne Again Shell: <code>xxx() { echo &quot;xxx&quot; ; }</code>
** Nur Bourne Again Shell: <code>function xxx() { echo &quot;xxx&quot; ; }</code>
** Empfehlung: Bourne Syntax verwenden, da vorwärtskompatibel.

* Source Files
** <em>Hinweis:</em> Kam im Vortrag aus Zeitgrpnden nicht dran.
** Inhalt einer anderen Datei an dieser Stelle komplett als Shellcode laden und ausführen.
** Beispiel: <code>. /usr/local/lib/shell-stuff/config.sh</code>
** Problem (u.a.): <code>. ./config.sh</code> (Welcher Speicherort von “config.sh” wird hier erwartet?)

== Interessante Links ==

=== Geschichliches ===

* Die (vereinfachte) Evolution der UNIXe und UNIX-artigen Betriebssysteme: https://upload.wikimedia.org/wikipedia/commons/7/77/Unix_history-simple.svg
* Grundsätzliche Funktionsweise (Diagramm): https://developer.ibm.com/developer/default/tutorials/l-linux-shells/images/figure2.gif
* Ken Thompson, Entwickler der ersten UNIX-Shell: https://de.wikipedia.org/wiki/Ken_Thompson
* Handbuch für “sh” (Thompson-Shell) in UNIX Version 3 (1973): https://www.in-ulm.de/~mascheck/bourne/v3/
* Vortrag von Stephen Bourne, Entwickler der Bourne-Shell: https://www.youtube.com/watch?v=2kEJoWfobpA
* “Csh Programming Considered Harmful”: https://www-uxsup.csx.cam.ac.uk/misc/csh.html
* Historische Shells praktisch ausprobieren: https://unix50.org/

=== Technische Dokumentation ===

* POSIX, Abschnitt “Shell Command Language” (aka “POSIX-Shell”): https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html
* Manual der Bourne Shell, Abschnitt “Expansions”: https://www.gnu.org/software/bash/manual/html_node/Shell-Expansions.html
* Manpage der “Debian Almquist Shell”: https://linux.die.net/man/1/dash
* Abschnitt “Pipeline Subprocesses” auf meinem privaten Blog: https://tk-sls.de/wp/5591/7

[[Kategorie:FIXME]]