JK-Wiki edv:os:unix:shell:example

edv:os:unix:shell:example:abfangen_von_signalen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:55+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Abfangen von Signalen ======

	+	Um das Skript vor vorschnellem Abbruch durch Signale zu schützen, müssen wir diese abfangen und behandeln. Unsere Reaktion wird beispielsweise sein, dass wir rasch alle temporären Dateien/Verzeichnisse löschen und anschließend das Skript verlassen. Bei den Signalen beschränken wir uns auf SIGINT (Nummer 2; Tastaturinterrupt) und SIGTERM (15). Ein trap-Aufruf zu Beginn unseres Skripts ist alles, was wir tun müssen.
	+
	+	<code bash>
	+	#!/bin/sh
	+	trap 'test -e /tmp/etc$$ && rm -r /tmp/etc$$; exit 0' 2 15
	+	</code>
	+
	+	Wann immer eines der beiden Signale (hier 2 und 15) auf den Prozess einherfällt, wird trap das temporäre Verzeichnis samt Inhalt entfernen (rm -r /tmp/etc$$) - falls es existiert (test -e /tmp/etc$$) - und das Skript beenden (exit 0).
	+
	+	Sie können trap ebenso verwenden, um bestimmte Signal zu ignorieren. Wählen Sie hierfür eine der beiden Syntaxvarianten:
	+
	+	<code bash>
	+	trap "" 2 3 15 19
	+	# Alternativ:
	+	trap : 2 3 15 19
	+	</code>
	+
	+	Weitere Beispiele:
	+
	+	<code bash>
	+	trap "echo SIGINT nicht erlaubt" INT
	+	trap "echo SIGTERM nicht erlaubt" TERM
	+	trap "echo SIGTSTP nicht erlaubt" TSTP
	+	</code>
	+
	+	Um in einem Skript die Behandlung von Signalen wieder zuzulassen, ist ein Aufruf von trap ohne Argumente erforderlich.
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:abschnitt_einer_datei_lesen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:50+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Abschnitt einer Datei lesen ======

	+	Datei prg.cfg, Inhalt:
	+
	+	<code>
	+	[blatt]
	+	B 210
	+	H 297
	+	name A4
	+
	+	[rand]
	+	links 20
	+	rechts 10
	+	vorlage 16
	+
	+	[farbe]
	+	rot FF0000
	+	gruen 00FF00
	+	blau 0000FF
	+	hintergrund
	+	</code>
	+
	+	Aus der Datei prg.cfg den Abschnitt von "rand" bis "vorlage" ausgeben:
	+
	+	<code bash>
	+	cat prg.cfg \| sed -n -e "/rand/,/vorlage/p"
	+	</code>
	+
	+	Ergebnis:
	+
	+	<code>
	+	[rand]
	+	links 20
	+	rechts 10
	+	vorlage 16
	+	</code>
	+
	+	...oder nur einen Wert davon, z.B. "vorlage" (mit Zeilennummer):
	+
	+	<code bash>
	+	cat prg.cfg \| sed -n -e "/rand/,/vorlage/p" \| fgrep -n vorlage
	+	</code>
	+
	+	Ergebnis:
	+
	+	<code>
	+	4:vorlage 16
	+	</code>
	+
	+	...oder ohne Zeilennummer:
	+
	+	<code bash>
	+	cat prg.cfg \| sed -n -e "/rand/,/vorlage/p" \| fgrep vorlage
	+	</code>
	+
	+	Ergebnis:
	+
	+	<code>
	+	vorlage 16
	+	</code>
	+
	+	----
	+	Stand: 04.11.2009
	+
	+	EOF

edv:os:unix:shell:example:array_funktionen_in_der_shell

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:54+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Array Funktionen in der Shell ======

	+	(Vielen Dank an Axel Sander!)
	+
	+	<code bash>
	+	# Datenelement setzen
	+	# $1 = Array Grundname
	+	# $2 = Position
	+	# $3 = Wert
	+	set_array()
	+	{
	+	ARRINT=$(( $2 / $MAXARR ))
	+	ARRMOD=$(( $2 % $MAXARR ))
	+	ARRNAME=${1}_${ARRINT}
	+	ARRTMP="$ARRNAME[$ARRMOD]=$3"
	+	eval $ARRTMP
	+	}
	+
	+	# Datenelement lesen
	+	# $1 = Array Grundname
	+	# $2 = Position
	+	get_array()
	+	{
	+	ARRINT=$(( $2 / $MAXARR ))
	+	ARRMOD=$(( $2 % $MAXARR ))
	+	ARRNAME=${1}_${ARRINT}
	+	ARRTMP='${'"$ARRNAME[$ARRMOD]"'}'
	+	eval print $ARRTMP
	+	}
	+
	+	# Maximale Größe fuer einzelnen Array
	+	MAXARR=4000
	+	</code>
	+
	+	Einen Wert im Array GV1ARR speichern:
	+
	+	<code bash>
	+	POS1=20
	+	WERT1=123
	+
	+	set_array GV1ARR $POS1 $WERT1
	+	</code>
	+
	+	Den Wert lesen:
	+
	+	<code bash>
	+	TMP_WERT1=`get_array GV1ARR $POS1`
	+
	+	echo $TMP_WERT1
	+	123
	+	</code>
	+
	+	----
	+	Stand: 04.11.2009
	+
	+	EOF

edv:os:unix:shell:example:awk

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:53+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== awk ======

	+	Das supermächtige Tool awk:
	+
	+	* Beispiel 1: 2 Dateien mergen:
	+
	+	Erste Datei:
	+
	+	<code>
	+	/home/user123/test001/ cat datei_1.unl
	+	111\|1234567\|0\|2005-10-25\|1963-11-16\|
	+	111\|2345678\|0\|2006-03-27\|1990-04-21\|
	+	111\|3456789\|4\|2005-09-26\|1963-06-04\|
	+	111\|4567890\|0\|2005-09-26\|1979-08-07\|
	+	222\|5678901\|0\|2005-09-26\|1973-02-18\|
	+	222\|6789012\|1\|2005-09-26\|1950-01-01\|
	+	222\|7890123\|0\|2006-03-27\|1953-08-23\|
	+	222\|8901234\|0\|2005-09-26\|1972-04-13\|
	+	222\|9012345\|3\|2005-09-26\|1971-03-15\|
	+	333\|0123456\|0\|2005-09-26\|1950-01-01\|
	+	</code>
	+
	+	Zweite Datei:
	+
	+	<code>
	+	/home/user123/test001/ head datei_2.txt
	+	A\|200\|1000004\|5\|20019\|\|0\|0\|
	+	B\|200\|1001000\|5\|20019\|\|0\|0\|
	+	C\|200\|1003009\|5\|20019\|\|0\|0\|
	+	D\|200\|1004003\|5\|20019\|\|0\|0\|
	+	E\|200\|1006000\|5\|20019\|\|0\|0\|
	+	F\|200\|1007006\|5\|20019\|\|0\|0\|
	+	G\|200\|1008006\|7\|20019\|\|0\|0\|
	+	H\|200\|1009003\|5\|20019\|\|0\|0\|
	+	I\|200\|1011004\|4\|20019\|\|0\|0\|
	+	J\|200\|1012000\|5\|20019\|\|0\|0\|
	+	</code>
	+
	+	Die 1. Datei wird in ein Array geladen (Teil "if (NR == FNR)").
	+	Die Variable NR ist die über alle Files übergreifende laufende Zeilennummer.
	+	Die Variable FNR ist die laufende Zeilennummer innerhalb des aktuell gelesenen Files.
	+	Solange sie gleich sind, befindet sich das Skript innnerhalb der ersten Datei.
	+
	+	<code>
	+	awk -F"\|" '{
	+	if (NR == FNR)
	+	{
	+	zaehler = $3
	+	anmeldedatum = $4
	+	geburtsdatum = $5
	+	if (zaehler >= 4)
	+	aktiv_kz = "R"
	+	else
	+	aktiv_kz = "-"
	+
	+	grp_kennung = $1 $2
	+	arr_gk[grp_kennung] = aktiv_kz FS anmeldedatum FS geburtsdatum
	+	next
	+	}
	+
	+	grp_kennung = $2 $3
	+	print $0 arr_gk[grp_kennung]
	+	}' datei_1.unl datei_2.txt
	+	</code>
	+
	+	:!: Wichtig dabei ist, daß beide Quell-Dateien nicht unbedingt identisch aufgebaut werden müssen, weil sie im Skript auf unterschiedliche Weise und unabhängig von einander (durch den Teil "if (NR == FNR)") behandelt werden.
	+
	+	----
	+
	+	* Beispiel 2: Eine Spalte aus mehreren Files extrahieren:
	+
	+	__Aufgabe:__\\ Es gibt eine Menge von Logfiles, deren Inhalt eine Spalten-Struktur hat. Zum Beispiel, aus den Logfiles von dem WebServer aus dem Jahr 2010 soll (nur) die Spalte mit den IP-Adressen in eine separate Datei aufsteigend sortiert (ohne Dubletten) extrahiert werden.
	+
	+	__Wir nehmen an:__\\
	+	Die Log-Files heißen nach dem Muster "log-<6-stellige Nummer>.JJJJ-MM-TT".\\
	+	Die IP-Adressen stehen in der Position 25 (beginnt mit 1) und haben die Länge von 15 Zeichen.
	+
	+	<code bash>
	+	for i in log-??????.2010-??-??; do
	+	cat $i \| nawk '{printf("%s\n", substr($0, 25, 15));}'
	+	done \| sort -u
	+	</code>
	+
	+	Sollen die Files bereits mit gzip komprimiert worden sein - kein Problem:
	+
	+	<code bash>
	+	for i in log-??????.2010-??-??.gz; do
	+	gzcat $i \| nawk '{printf("%s\n", substr($0, 25, 15));}'
	+	done \| sort -u
	+	</code>
	+
	+	----
	+	Stand: 17.11.2011
	+
	+	EOF

edv:os:unix:shell:example:dd

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:55+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== dd ======

	+	Allgemeine Infos: [[https://de.wikipedia.org/wiki/Dd_(Unix)]]
	+
	+	Etwas detaillierter und mit zahlreichen Beispielen: [[https://wiki.ubuntuusers.de/dd/]]
	+
	+	Hier ein paar Beispiele:
	+
	+	===== Image von der Partition erstellen und zurückspielen =====
	+
	+	Die Partition sda1 in der Datei image_sda1.img sichern:
	+
	+	<code bash>
	+	sudo dd if=/dev/sda1 of=~/image_sda1.img
	+	</code>
	+
	+	Das gleiche mit dem on-the-fly Komprimieren:
	+
	+	<code bash>
	+	sudo dd if=/dev/sda1 \| gzip > ~/image_sda1.img.gz
	+	</code>
	+
	+	Damit das komprimierte File kleiner wird, vorher den gesamten freien Platz der Festplatte mit Nullen überschreiben:
	+
	+	<code bash>
	+	sudo dd if=/dev/zero of=FileZumEntfernen
	+	</code>
	+
	+	Zurückspielen:
	+
	+	<code bash>
	+	gzip -cd ~/image_sda1.img.gz \| sudo dd of=/dev/sda1
	+	</code>
	+
	+
	+	===== Festplatte im HEX-Format lesen =====
	+
	+	<code bash>
	+	dd if=/dev/sdh \| xxd \| head
	+	</code>
	+
	+	----
	+	Stand: 27.07.2018
	+
	+	EOF

edv:os:unix:shell:example:dirname_und_basename

Anonymous (anonymous@undisclosed.example.com) — 2020-09-01T17:52:56+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== dirname und basename ======

	+	Das Kommando dirname gibt von einem Dateinamen den Pfadanteil aus und das basename (das Gegenstück zu "dirname") gibt den reinen Dateinamen ohne Pfadanteil aus.
	+
	+	Ein Beispiel:
	+
	+	<code bash>
	+	echo "Scriptname : $0"
	+	echo "basename : `basename $0`"
	+	echo "dirname : `dirname $0`"
	+	</code>
	+
	+	Weitere nützliche Infos unter:\\ [[https://stackoverflow.com/questions/23162299/how-to-get-the-last-part-of-dirname-in-bash]]
	+
	+	----
	+	Stand: 01.09.2020
	+
	+	EOF

edv:os:unix:shell:example:einen_textabschnitt_in_mehreren_files_gleichzeitig_ersetzen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:55+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Einen Textabschnitt in mehreren Files gleichzeitig ersetzen ======

	+	Ein Beispiel: ein Programm, das ursprünglich für Windows geschrieben wurde, beinhaltet in den #include-Direktiven gelegentlich auch die (relativen) Pfad-Angaben, die unter Windows i.d.R. Backslashes '\' beinhalten. Bei der Portierung auf Unix führt das zu Problemen.
	+
	+	Um nicht per Hand hunderte Quelltexte anpassen zu müssen, hier ist ein Skript, welches dises Vorhaben automatisch erledigt.
	+
	+	Das Skript sucht im aktuellen Verzeichnis und rekursiv in allen Unterverzeichnissen in allen .h-, .c- und .cpp-Files Zeilen, die #include beinhalten und ersetzt (nur in diesen Zeilen) alle Vorkomnisse von '\' durch '/'. Vor dem Editieren legt das Skript eine Sicherungskopie des betroffenen Files an.
	+
	+	Danach sehen etwa die Zeilen:
	+
	+	<code c>
	+	#include "..\..\defines_global.h"
	+	</code>
	+
	+	...wie folgt aus:
	+
	+	<code c>
	+	#include "../../defines_global.h"
	+	</code>
	+
	+	Das einfache Find+Replace ist dafür eher ungeeignet, weil ein '\' häufig auch an vielen anderen Stellen vorkommt, wie z.B. in '\n' oder '\0', etc.
	+
	+	Skript:
	+
	+	<code bash>
	+	juergen@develop:/prj/beispiel/cpp_projekt> cat backslash2slash.sh
	+	# Replaces all occurrences of '\' by '/' in the directories in the "#include"-lines.
	+
	+	# For the backups:
	+	SAVE_DATUM=`date +%Y%m%d`
	+	# Counter of replaced files:
	+	COUNTER_FILES=0
	+
	+	#echo SAVE_DATUM = ${SAVE_DATUM}
	+	#echo COUNTER_FILES = ${COUNTER_FILES}
	+
	+	for FILE in `find . -name ".h" -o -name ".c" -o -name "*.cpp"`
	+	do
	+	# echo Test of file: ${FILE}
	+	grep '#include' ${FILE} \| grep '\\' > /dev/null
	+	if [ $? -eq 0 ]
	+	then
	+	echo Replacing: ${FILE}
	+	cp ${FILE} ${FILE}.${SAVE_DATUM}
	+	sed '/#include/s/\\/\//g' ${FILE} > ${FILE}.changed
	+	mv ${FILE}.changed ${FILE}
	+	COUNTER_FILES=$((${COUNTER_FILES}+1))
	+	fi
	+	done
	+
	+	echo
	+	echo ${COUNTER_FILES} Files are replaced.
	+
	+	# EOF
	+	juergen@develop:/prj/beispiel/cpp_projekt>
	+	</code>
	+
	+	----
	+	Stand: 11.12.2015
	+
	+	EOF

edv:os:unix:shell:example:einen_wert_in_einem_abschnitt_ersetzen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:55+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Einen Wert in einem Abschnitt ersetzen ======

	+	Eine Textdatei namens datei.ext:
	+
	+	Zeile\\
	+	Zeile\\
	+	\\
	+	[Abschnitt1.begin]\\
	+	Bez1 Wert1\\
	+	Bez2 Wert2\\
	+	Bez3 Wert3\\
	+	Bez4 Wert4\\
	+	[Abschnitt1.end]\\
	+	\\
	+	Zeile\\
	+	Zeile\\
	+
	+	Aufgabe: Im Abschnitt1 den Wert Bez3 auf ABC123 setzen:
	+
	+	<code bash>
	+	mv datei.ext datei.tmp
	+	substitution="Bez3"
	+	wert="ABC123"
	+	newline="$substitution $wert"
	+	sed -e "/Abschnitt1.begin/,/Abschnitt1.end/ s/$substitution/$newline/" datei.tmp > datei.ext
	+	rm datei.tmp
	+	</code>
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:einfache_emails_verschicken

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:52+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Einfache eMails verschicken ======

	+	Am besten legt man alle für den eMail-Versand benötigten Informationen in den Variablen:
	+
	+	<code bash>
	+	MESSAGE="Test Message 1. Zeile\n2. Zeile"
	+	USER="newsletter"
	+	BETREFF="Test Betreff"
	+	EMAIL_ADRESSE="empfaenger@domain.tld"
	+	</code>
	+
	+	Um diese zu kontrollieren:
	+
	+	<code bash>
	+	echo "${MESSAGE}"
	+	echo "${USER}"
	+	echo "${BETREFF}"
	+	echo "${EMAIL_ADRESSE}"
	+	</code>
	+
	+	Anschließend wird die Meldung abgeschickt:
	+
	+	<code bash>
	+	echo "${MESSAGE}" \| mailx -r "${USER}" -s "${BETREFF}" "${EMAIL_ADRESSE}"
	+	</code>
	+
	+	:!: Die Variable $USER findet dann Verwendung, wenn der eMail-Versand nur für bestimmte User freigeschaltet ist. Dann wird die eMail durch mailx im Namen dieses Users versendet.
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:encfs

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:49+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== encfs ======

	+	Einzelne Verzeichnisse schnell und einfach verschlüsseln.
	+
	+	Neues verschlüsseltes Verzeichnis anlegen bzw. einhängen:
	+
	+	<code bash>
	+	encfs -f -v ~/.crypt ~/crypt
	+	</code>
	+
	+	:!: Wobei das erste Verzeichnis die Verschlüsselte Dateien beinhalten wird und das zweite die im Klartext. Das zweite Verzeichnis wird durch "encfs" als MountPoint benutzt und soll i.d.R. leer bleiben.
	+
	+	Der Paranoia-Modus bietet eine etwas stärkere Verschlüsselung und einige zusätzliche Sicherheitsfeatures.
	+
	+	Parameter:
	+
	+	"-f": Der Prozess soll nicht als Dienst, sondern als normaler Prozess in der Shell laufen.
	+	"-v": = "verbose"
	+
	+
	+	Erfolgsüberprüfung:
	+
	+	<code bash>
	+	mount \| grep "encfs"
	+	</code>
	+
	+	Es sollte in etwa folgende Zeile zu sehen sein:
	+
	+	encfs on /home/USER/crypt type fuse.encfs (rw,nosuid,nodev,default_permissions,user=USER)
	+
	+	Verzeichnis aushängen:
	+
	+	<code bash>
	+	fusermount -u ~/crypt
	+	</code>
	+
	+	Weitere Infos unter [[http://wiki.ubuntuusers.de/EncFS]]
	+
	+	----
	+	Stand: 20.10.2014
	+
	+	EOF

edv:os:unix:shell:example:find

Anonymous (anonymous@undisclosed.example.com) — 2024-04-09T12:06:46+00:00

1712577502		aktuell
Zeile 95:		Zeile 95:
	</code>		</code>

-	Alle Files ab dem aktuellen Verzeichnis finden, die keine gültige Gruppe besitzen:	+	Alle Files/Verzeichnisse/Sonstiges ab dem aktuellen Verzeichnis finden, die keinem gültigen User gehören:
		+	<code bash>
		+	find . -nouser -ls 2>/dev/null
		+	</code>
		+
		+	Alle Files/Verzeichnisse/Sonstiges ab dem aktuellen Verzeichnis finden, die keine gültige Gruppe besitzen:
	<code bash>		<code bash>
	find . -nogroup -ls 2>/dev/null		find . -nogroup -ls 2>/dev/null
	</code>		</code>

-	Alle Files ab dem aktuellen Verzeichnis finden, die keine gültige Gruppe besitzen, und die Gruppenzugehörigkeit auf "zielgruppe" ändern:	+	Alle Files/Verzeichnisse ab dem aktuellen Verzeichnis finden, die keinen gültigen User besitzen, und den Owner auf "zieluser" ändern:
		+	<code bash>
		+	find . -nouser -type f -exec chown --changes zieluser {} \; 2>/dev/null
		+	find . -nouser -type d -exec chown --changes zieluser {} \; 2>/dev/null
		+	</code>
		+
		+	Alle Files/Verzeichnisse ab dem aktuellen Verzeichnis finden, die keine gültige Gruppe besitzen, und die Gruppenzugehörigkeit auf "zielgruppe" ändern:
	<code bash>		<code bash>
-	find . -nogroup -exec chgrp --changes zielgruppe {} \; 2>/dev/null	+	find . -nogroup -type f -exec chgrp --changes zielgruppe {} \; 2>/dev/null
		+	find . -nogroup -type d -exec chgrp --changes zielgruppe {} \; 2>/dev/null
	</code>		</code>

edv:os:unix:shell:example:gcp

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:56+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== gcp ======

	+	gcp ist GNU cp - Kommandozeilenprogramm zum Kopieren von Dateien mit Fortschrittsanzeige. Es verwendet ein Journal, um das erfolgreiche Kopieren festzuhalten. "gcp" hat weitgehend dieselben Optionen wie "cp".
	+
	+	Homepage: [[http://wiki.goffi.org/wiki/Gcp]]
	+
	+	----
	+	Stand: 26.09.2013
	+
	+	EOF

edv:os:unix:shell:example:getfacl_und_setfacl

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:57+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== getfacl und setfacl ======

	+	Beispiel: ACLs einer Datei in eine andere übernehmen:
	+
	+	<code bash>
	+	getfacl xyz \| setfacl -f - abc
	+	</code>
	+
	+	Die Datei abc bekommt die selben ACLs, wie die xyz.
	+
	+	----
	+	Stand: 04.11.2009
	+
	+	EOF

edv:os:unix:shell:example:grep

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:51+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== grep ======

	+	Es gibt unterschiedliche "grep"s, z.B.:
	+
	+	/usr/bin/grep
	+	/usr/xpg4/bin/grep
	+
	+	Die 2. Variante hat Begrenzung des Eingabestrings auf 2048 Zeichen.
	+
	+	Beispiel:
	+
	+	<code bash>
	+	# printf "%2047s" 1 \| egrep -s 1; print $?
	+	0
	+
	+	# printf "%2048s" 1 \| egrep -s 1; print $?
	+	1
	+	</code>
	+
	+	Eine Fehlermeldung kommt leider nicht...
	+
	+	:!: NOTES
	+	/usr/bin/grep
	+	Lines are limited only by the size of the available virtual
	+	memory. If there is a line with embedded nulls, grep will
	+	only match up to the first null; if it matches, it will
	+	print the entire line.
	+
	+	/usr/xpg4/bin/grep
	+	The results are unspecified if input files contain lines
	+	longer than LINE_MAX bytes or contain binary data. LINE_MAX
	+	is defined in /usr/include/limits.h.
	+
	+	<code c>
	+	grep LINE_MAX /usr/include/limits.h
	+	#define _POSIX2_LINE_MAX 2048
	+	#define LINE_MAX _POSIX2_LINE_MAX
	+	</code>
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:gzip

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:50+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== gzip ======

	+	Mehrere komprimierte Dateien können zusammengeführt werden. In diesem Fall wird "gunzip" alle enthaltenen Komponenten gemeinsam entpacken.
	+
	+	Zum Beispiel:
	+
	+	<code bash>
	+	gzip -c file1 > foo.gz
	+	gzip -c file2 >> foo.gz
	+	</code>
	+
	+	In diesem Fall führt folgender Aufruf:
	+
	+	<code bash>
	+	gunzip -c foo
	+	</code>
	+
	+	...zum gleichen Ergebnis wie der:
	+
	+	<code bash>
	+	cat file1 file2
	+	</code>
	+
	+	:!: Aber, man erreicht eine bessere Komprimierung, wenn alle Komponenten in einem Rutsch komprimiert werden:
	+
	+	<code bash>
	+	cat file1 file2 \| gzip > foo.gz
	+	</code>
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:html-mails_verschicken

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:56+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== HTML-Mails von der Kommandozeile verschicken ======

	+	So schickt man eine HTML-Mail von einem %%***X%%-Rechner von der Kommandozeile:
	+
	+	<code bash>
	+	cat << __EOF \| /usr/lib/sendmail -t
	+	To: vorname.name@domain.tld
	+	Subject: HTML-TestMail
	+	Content-type: text/html
	+
	+	<html>
	+	<head>
	+	</head>
	+	<body>
	+	Dies ist eine HTML-Mail mit <B>fetten</B> und <I>kursiven</I> Worten.
	+	</body>
	+	</html>
	+	__EOF
	+	</code>
	+
	+	EOF

edv:os:unix:shell:example:iterationen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:52+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Iterationen ======

	+	<code bash>
	+	COUNTER=0
	+	COUNTER_MAX=1000
	+	while true
	+	do
	+	COUNTER=$(($COUNTER + 1))
	+	...
	+	if [ ${COUNTER} -gt ${COUNTER_MAX} ]
	+	then
	+	...
	+	else
	+	break
	+	fi
	+	...
	+	done
	+	</code>
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:listenfile-bearbeitung

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:51+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== ListenFile-Bearbeitung (Listen als Files) ======

	+	Folgende Aufgabe:\\
	+	Man muß alle Elemente einer Liste (als Textfile mit einem Element pro Zeile) separat aber auf die gleiche Weise bearbeiten.
	+
	+	Mal angenommen, wir wollen alle im File files-to-gzip.lst aufgelisteten Files mit gzip komprimieren.
	+
	+	Inhalt des Files files-to-gzip.lst:
	+
	+	<code bash>
	+	user@linux> cat files-to-gzip.lst
	+	file_1.txt
	+	file_2.jpg
	+	file_3.mp3
	+	user@linux>
	+	</code>
	+
	+	Skript:
	+
	+	<code bash>
	+	LIST_FILE="files-to-gzip.lst"
	+	OUT_FILE="files-to-gzip.sh"
	+	CMD="gzip"
	+
	+	while read LINE_FROM_LIST
	+	do
	+	echo "${CMD} ${LINE_FROM_LIST}"
	+	done < ${LIST_FILE} > ${OUT_FILE}
	+	</code>
	+
	+	Ergebnis: das File files-to-gzip.sh:
	+
	+	<code bash>
	+	user@linux> cat files-to-gzip.sh
	+	gzip file_1.txt
	+	gzip file_2.jpg
	+	gzip file_3.mp3
	+	user@linux>
	+	</code>
	+
	+	Nachdem die Zugriffsrechte am files-to-gzip.sh entsprechend angepaßt sind, kann man es ausführen.
	+
	+	----
	+	Stand: 28.01.2010
	+
	+	EOF

edv:os:unix:shell:example:od

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:54+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== od ======

	+	<code bash>
	+	SunOS> echo '{' > xx
	+
	+	SunOS> od xx
	+	0000000 075412
	+	0000002
	+
	+	SunOS> od -x xx
	+	0000000 7b0a
	+	0000002
	+
	+	SunOS>
	+	</code>
	+
	+	----
	+	Stand: 04.11.2009
	+
	+	EOF

edv:os:unix:shell:example:parallel

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:51+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== parallel ======

	+	Die Linux-Shell läuft normalerweise im sequentiellen Betrieb: Ein Befehl wird nach dem anderen abgearbeitet. Man kann natürlich einige Befehle in Hintergrund (durch abschließendes &-Zeichen) ausführen.
	+
	+	Das Werkzeug Parallel (Perl-Skript) erlaubt mehrere CPU-Kerne für die Parallelisierung auf der Shell nutzen.
	+
	+	Hier einige Beispiele:
	+
	+	<code bash>
	+	$ ls \| parallel gzip {}
	+	</code>
	+
	+	Dieser Befehl komprimiert mehrere Dateien in einem Verzeichnis gleichzeitig. (Die Ausgabe von ls lässt sich hierbei beliebig einschränken oder durch ein anderes Werkzeug wie z.B. find ersetzen.)
	+
	+	Alternative Schreibweise:
	+
	+	<code bash>
	+	$ parallel gzip ::: datei1 datei2 datei3
	+	</code>
	+
	+	Das Argument "-j" definiert die Anzahl der nebenläufig auszuführenden Jobs. Beispielsweise führt die Angabe von "-j 150%" dazu, dass jede CPU mit 1,5 Jobs versorgt wird.
	+
	+	Quelle und weitere Infos unter: [[http://www.admin-magazin.de/News/Tipps/ADMIN-Tipp-Parallele-Linux-Shell]]
	+
	+	----
	+	Stand: 06.12.2013
	+
	+	EOF

edv:os:unix:shell:example:prips

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:53+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== prips ======

	+	IP-Adressen eines IP-Bereichs auflisten.
	+
	+	<code bash>
	+	$ prips 192.168.1.0 192.168.1.15
	+	192.168.1.0
	+	192.168.1.1
	+	192.168.1.2
	+	192.168.1.3
	+	192.168.1.4
	+	192.168.1.5
	+	192.168.1.6
	+	192.168.1.7
	+	192.168.1.8
	+	192.168.1.9
	+	192.168.1.10
	+	192.168.1.11
	+	192.168.1.12
	+	192.168.1.13
	+	192.168.1.14
	+	192.168.1.15
	+	$
	+	</code>
	+
	+	Installieren (Debian):
	+
	+	<code bash>
	+	$ sudo apt-get install prips
	+	</code>
	+
	+	Quelle: c't 8/2014, S.138-139
	+
	+	----
	+	Stand: 24.03.2014
	+
	+	EOF

edv:os:unix:shell:example:read-funktion

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:52+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== read-Funktion ======
	+
	+	read wartet, bis der Benutzer seine Eingabe mit einem Zeilenumbruch ([Enter]) abgeschlossen hat. Wird read kein Argument (Variablenname) mitgegeben, so wird die gelesene Zeile der Shellvariablen REPLY zugewiesen. Folgen dem Kommando ein oder mehrere Variablennamen, so wird der Reihe nach das erste Token der Eingabe der ersten Variable zugewiesen, das zweite Token der zweiten Variable usw. Stehen mehr Token als Variablen zur Verfügung, erhält die letzte Variable alle noch nicht zugewiesenen Token. Sind es weniger Token, bleiben die überschüssigen Variablen unbelegt.
	+
	+	Ein read-Aufruf blockiert, es sei denn mit der Option "-t Sekunden" (:!: erst ab Bash 2.04!) wurde eine Zeitspanne vereinbart, nach der das Kommando spätestens zurück kehrt, selbst wenn noch keine Eingabe durch den Benutzer erfolgte. Anhand des Rückgabestatus kann entschieden werden, ob der Timeout die Rückkehr bedingte.
	+
	+	Im folgenden Skriptfragment wird zur Eingabe einer Zahl aufgefordert. Solange die Eingabe nicht dem erwarteten Typ entspricht, springt der Cursor an die Eingabeposition zurück:
	+
	+	<code bash>
	+	function writeln()
	+	{
	+	tput cup $1 $2 # Cursor positionieren
	+	tput el # Rest der Zeile löschen
	+	shift 2 # Parameter für die Koordinaten entfernen
	+	echo -n $*" " # Rest der Parameterliste ausgeben
	+	}
	+
	+	tput clear
	+	writeln 3 5 "Beliebige Zahl eingeben:"
	+
	+	while :; do
	+	writeln 3 30
	+	read wert
	+	echo $wert \| egrep -q '[[:digit:]]+' && break
	+	tput bel
	+	done
	+
	+	echo "Eingabe war: $wert"
	+	</code>
	+
	+	Möchten Sie die Eingaben am Bildschirm verbergen (Passworteingabe etc.), so hilft die Terminalsteuerung über das Kommando stty weiter. Der folgende Programmausschnitt schaltet die Anzeige der eingegebenen Zeichen ab:
	+
	+	<code bash>
	+	echo -n "Passwort :"
	+	stty -echo
	+	read $password
	+	stty echo
	+	</code>
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:schnelles_kopieren

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:50+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Schnelles kopieren ======

	+	Aus Gentoo Linux Wiki.\\
	+	Der Inhalt stammt ursprünglich von [[http://de.gentoo-wiki.com/Schnelles_kopieren]]. Da die Datenbank des Gentoo Linux Wikis im Oktober 2009 verloren gegangen war (Meldung von dem Hauptadmin "Mikevalstar" vom 27.10.2009 auf [[http://de.gentoo-wiki.com/wiki/Hauptseite]], mehr dazu unter [[http://gentoo-wiki.com/outage-10-08.html]]), kann ich die ursprüngliche Seite nicht mehr verlinken.
	+
	+	Durch Zufall habe ich aber eine lokale Kopie davon. Hier ist sie (wegen des anderen Wikis leicht umformatiert):
	+
	+	===== Der Normale Weg =====
	+
	+	Um Dateien rekursiv von quelle1/ und quelle2/ nach ziel/ zu kopieren, benutzt man folgende Anweisung:
	+
	+	<code>
	+	cp -Rv quelle1/ quelle2/ ziel/
	+	</code>
	+
	+	===== Der "piped way" =====
	+
	+	cp kopiert Zeichen für Zeichen. Mit den Kernel-Pipes können Daten Block für Block kopiert werden. tar konvertiert Verzeichnisse und Dateien rekursiv in einen einzigen Datenstrom (stream). An einem Ende der Pipe werden Dateien und Verzeichnisse in einen Stream gepackt und am anderen entpackt.
	+
	+	<code>
	+	# Kopieren mit tar:
	+
	+	tar -c quelle1/ quelle2/ \| tar -C ziel/ -xv
	+	</code>
	+
	+	Das ist nicht unbedingt schneller aber flexibler. Das geht natürlich auch über ein Script:
	+
	+
	+	<code bash>
	+	# tcp (tar copy):
	+
	+	#!/bin/bash
	+	tar -c $1 \| tar -C $2 -xv
	+	</code>
	+
	+	Man sollte beachten, dass ext2, ext3 und die meisten modernen Linux-Dateisysteme sog. sparse files besitzen. Diese Funktion wird benutzt, um große Dateien, deren Inhalt aus vielen Nullen besteht auf effiziente Weise zu speichern. Im Normalfall ist das nicht von Interesse, aber manche Programme nutzen die Funktion ausgiebig (z.B. net-p2p/mldonkey). Man sollte vorsichtig sein, wenn man solche Dateien mit dieser Methode kopiert, weil dies den verfügbaren Speicherplatz sprengen könnte. Während das Hilfsmittel cp 'sparse files' automatisch erkennt, tut tar dies nicht. 'Sparse files' aus dem Quellverzeichnis werden im Quellverzeichnis vollständig dargestellt, solange nicht das Flag -S auf der linken Seite der Pipe gesetzt wird.
	+
	+	===== Der Netzwerk-"Way over SSH" =====
	+
	+	Dateien werden gestreamt durch die Pipe an ssh geschickt, welches eine Verbindung aufbaut und dann entfernt einen Befehl ausführt der die Daten verarbeitet, in diesem Fall den Stream entpackt.
	+
	+	<code>
	+	# Lokal zu entfernt:
	+
	+	tar cv Dateiliste \| ssh -C entfernter.rechner.de "tar x -C /home/user/Zielpfad"
	+	</code>
	+
	+	<code>
	+	# Lokal zu entfernt, mit schnellerer Verschlüsselung:
	+
	+	tar cv Dateiliste \| ssh -C -c blowfish entfernter.rechner.de "tar x -C /home/user/Zielpfad"
	+	</code>
	+
	+	<code>
	+	# Entfernt zu lokal:
	+
	+	ssh -C entfernter.rechner.de "tar c -C Quellverzeichnis" \|tar x -C Zielverzeichnis
	+	</code>
	+
	+	Der ssh-Parameter -C ist schaltet dabei die Kompression des Datenstroms an und ist nicht in jedem Fall sinnvoll.
	+
	+	Zum einfachen kopieren von Files über SSH nutzt man scp:
	+
	+	<code>
	+	# Entfernt zu lokal:
	+
	+	scp -C entfernter_rechner:pfad/zur/quelldatei .
	+	</code>
	+
	+	<code>
	+	# Lokal zu entfernt:
	+
	+	scp -C lokal1 lokal2 ... entfernter_rechner:pfad/zum/ziel/
	+	</code>
	+
	+	Auch hier ist der Komprimierungsparameter -C wieder optional.
	+
	+	===== Der Netzwerk-"Way with netcat" =====
	+
	+	Datentransfer mit Netcat verursacht nur minimale CPU-Auslastungen gegenüber ssh. Das liegt daran, dass die Daten nicht verschlüsselt werden. Es findet auch keine Authentifizierung statt. Es wird einfach nur ein Port geöffnet und auf eine Verbindung gewartet.
	+
	+	Nachteile:\\
	+	- man muss am Quell- und Zielrechner einen Befehl eingeben
	+	- die Daten werden unverschlüsselt übertragen
	+	- auf der Firewall des Zielrechners muss ein Port geöffnet und hinterher wieder geschlossen werden
	+
	+	Beispiel:
	+
	+	- Öffnet den Port 2342 (-p 2342) und wartet (-l).
	+	- Die ankommenden Daten werden dann tar über eine Pipe übergeben(tar -C /ziel/verz -xz).
	+
	+	<code>
	+	# Ziel:
	+
	+	user@zielrechner# nc -l -p 2342 \| tar -C /ziel/verz –xz
	+	</code>
	+
	+	- Stellt die Daten mit tar zu einem Stream zusammen (tar -cz /quelle/verz).
	+	- Verbindet sich mit zielrechner (192.168.0.2) auf Port 2342.
	+
	+	<code>
	+	# Quelle:
	+
	+	user@quellrechner# tar -cz /quelle/verz \| nc 192.168.0.2 2342
	+	</code>
	+
	+	Um die CPU-Last weiter zu reduzieren, kann lzop anstelle der tar-Option z verwendet werden. lzop komprimiert wesentlich schneller aber weniger effizient:
	+
	+	Zielrechner: nc -l -p 2342 \| lzop -d \| tar -C /ziel/verz -x
	+
	+	Quellrechner: tar -c /quelle/verz \| lzop \| nc zielrechner 2342
	+
	+	===== Der Netzwerk-"Way with socat" =====
	+
	+	Selbe Idee wie bei Netcat.
	+
	+	Zielrechner: socat -u - tcp4-listen:2342 \| tar x -C /ziel/verz
	+
	+	Quellrechner: tar c /quelle/verz \| socat -u - tcp4:zielrechner:2342
	+
	+	Wir können eine ganze Reihe von Kompressionsmethoden durch einen allgemeinen Aufruf verwenden:
	+
	+	Zielrechner: socat -u - tcp4-listen:2342 \| ${UNZIP} \| tar x -C /ziel/verz
	+
	+	Quellrechner: tar c /quelle/verz \| ${ZIP} \| socat -u - tcp4:zielrechner:2342
	+
	+	Wir definieren schließlich ZIP als einen der folgenden Befehle:
	+
	+	* cat
	+	* lzop
	+	* gzip
	+	* bzip2
	+
	+	und UNZIP als:
	+
	+	* cat
	+	* lzop -d
	+	* gunzip
	+	* bunzip2
	+
	+	Wo liegen die Unterschiede?
	+
	+	<code>
	+	# Messvorrichtung:
	+
	+	time -p tar /usr/src/linux-2.6.3 \| ${ZIP} \| cat > /dev/null
	+	</code>
	+
	+	^Programm ^Daten ^Laufzeit ^
	+	\|cat \|182 MB \|1.1 sec \|
	+	\|lzop \|64 MB \|4 sec \|
	+	\|gzip --fast \|51 MB \|9 sec \|
	+	\|gzip \|41 MB \|18 sec \|
	+	\|gzip --best \|41 MB \|49 sec \|
	+	\|bzip2 \|32 MB \|134 sec \|
	+
	+	Diese Einsparungen beim Komprimieren (bzw. beim Nicht-Komprimieren) sollten jedoch mit der vorhanden Bandbreite abgewogen werden. So macht es wenig Sinn, große Datenmengen unkomprimiert über eine DSL Leitung zu schicken - andererseits macht es aber wenig Sinn, nicht weiter komprimierbare Daten (z.B. JPEG/PNG-Bilder, AVIs, MP3s, zips, ...) mit lzop/gzip/bzip2 nochmal zu "komprimieren". Hierdurch wird nur Rechenleistung verschwendet und somit u.U. ein geringerer Durchsatz erreicht.
	+
	+	===== Externe Links zum Thema: =====
	+
	+	Quelle: [[http://de.gentoo-wiki.com/]] - Gentoo Linux Wiki\\
	+
	+	----
	+	Stand: 19.11.2009
	+
	+	EOF

edv:os:unix:shell:example:spezielle_werte

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:54+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Spezielle Werte ======

	+	Eigene PID:
	+
	+	<code bash>
	+	PID=$$
	+	</code>
	+
	+	ReturnCode der letzten Operation:
	+
	+	<code bash>
	+	RC=$?
	+	</code>
	+
	+	:!: Die Abfrage des ReturnCodes soll unmittelbar nach der Operation stattfinden!
	+
	+	Die Länge des String-Wertes einer Variable:
	+
	+	<code bash>
	+	LNG=${#VARNAME}
	+	</code>
	+
	+	Der eigene Skript-Name beim Aufruf (Programmaufruf ohne Parameter), eventuel vorhandener Pfad ist mit dabei:
	+
	+	<code bash>
	+	MY_FULL_NAME=${0}
	+	</code>
	+
	+	Programmname (inklusive evtl. Extension) ohne Pfad und ohne Parameter:
	+
	+	<code bash>
	+	SELF_FILENAME=${0##*/}
	+	</code>
	+
	+	Reiner Programmname (ohne evtl. Extension und ebenfalls ohne Pfad):
	+
	+	<code bash>
	+	SELF_PRG_NAME=${SELF_FILENAME%.*}
	+	</code>
	+
	+	Relativer Pfad (aus dem aktuellen Verzeichnis $PWD heraus) ohne Dateiname und Parameter:
	+
	+	<code bash>
	+	PFAD=${0%/*}
	+	</code>
	+
	+	Extension ersetzen:
	+
	+	<code bash>
	+	CFG_FILE_EXT="cfg"
	+	CFG_FILE=${PWD}/${SELF_PRG_NAME}.${CFG_FILE_EXT}
	+	</code>
	+
	+	Anzahl der Parameter beim Aufruf ermitteln:
	+
	+	<code bash>
	+	ANZAHL=$#
	+	</code>
	+
	+	Die Parameter beim Aufruf:
	+
	+	<code bash>
	+	ALL_PARAM=${@}
	+	</code>
	+
	+	PID des Tochterprozesses:
	+
	+	<code bash>
	+	PID=${!}
	+	</code>
	+
	+	Warten bis der Tochterprozess zu Ende ist:
	+
	+	<code bash>
	+	wait ${PID}
	+	</code>
	+
	+	Kurze Zusammenfassung:
	+
	+	<code bash>
	+	# Expression # Result
	+	${path##/*/} long.file.name
	+	${path#/*/} billr/mem/long.file.name
	+	$path /home/billr/mem/long.file.name
	+	${path%.*} /home/billr/mem/long.file
	+	${path%%.*} /home/billr/mem/long
	+	${path%/*} /home/billr/mem
	+	</code>
	+
	+	default-Werte für Variablen setzen:
	+
	+	<code bash>
	+	# String-Werte:
	+	VAR_STR=${VAR_STR:="ALL"}
	+
	+	# Numerische Werte:
	+	VAR_NUM=${VAR_NUM:=0}
	+	</code>
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:split

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:49+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== split ======

	+	Wie teilt man Files (oder stdout) auf kleinere Portionen?
	+
	+	Wenn Sie eine große DB exportieren, oder ein TAR-Archiv Ihres Filesystems erstellen müssen, kann es oft zu Dateien führen, die größer als 2GB sind. Auf einigen UNIX-Filesystemen ist es die maximal mögliche Größe für die Dateien. Oder wenn Sie Ihre Software über das Internet übertragen müssen, ist es einfacher, kleinere TAR-Files hoch/runter zu laden. Für diese Aufgabe sind split und named pipes oft sehr nützlich.
	+
	+	1. Ein named pipe erzeugen:
	+
	+	<code bash>
	+	mknod tar_pipe p
	+	</code>
	+
	+	2. Der erste Prozeß (tar) schreibt (als Hintergrundprozeß) auf named pipe:
	+
	+	<code bash>
	+	tar cvf tar_pipe <tar_directory> &
	+	</code>
	+
	+	3. Der zweite Prozeß (split) liest aus dem named pipe und erzeugt mehrere kleine Portionen:
	+
	+	<code bash>
	+	split -b 100k tar_pipe tar_split_
	+	</code>
	+
	+	Das ergibt in etwa folgendes:
	+
	+	<code>
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_aa
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ab
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ac
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ad
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ae
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_af
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ag
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ah
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ai
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_aj
	+	-rw-r--r-- 1 root root 102400 Apr 24 12:10 tar_split_ak
	+	</code>
	+
	+	4. Nach der Übertragung zum Zielhost werden alle Teile wieder zusammen geführt und der Inhalt von "tar_directory" wiederhergestellt:
	+
	+	<code bash>
	+	cat tar_split_* \| tar xvf -
	+	</code>
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:string_matching

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:52+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== String Matching ======

	+	Beispiel:
	+
	+	Alle Zeichen, die nicht Ziffer oder '-' sind, werden aus dem String entfernt:
	+
	+	<code bash>
	+	# Matching: Zeitraum darf nur Zeichen '0' bis '9' und '-' enthalten
	+	ZEITRAUM_PARAM=$(echo $3 \| $SED 's/[^0-9,\-]//g')
	+	</code>
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:tail_und_head

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:56+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== tail und head ======

	+	2 Beispiele:
	+
	+	<code bash>
	+	# Nur die ersten 10 Zeilen einer Textdatei ausgeben:
	+	cat eine_datei.txt \| head -10
	+
	+	# Nur die letzten 10 Zeilen einer Textdatei ausgeben:
	+	cat eine_datei.txt \| tail -10
	+	</code>
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:tar

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:50+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== tar ======

	+	===== Aufruf: =====
	+
	+	Folgende Beispiele:
	+
	+	Archive mit Inhalt von /etc und /home erstellen:
	+
	+	<code bash>
	+	tar -cvf test.tar /etc/ /home/
	+	tar -cvf - /etc /home \| gzip > test.tar.gz
	+	tar -czvf test.tar.gz /etc/ /home/ # GNU tar Kurzform
	+	</code>
	+
	+	Archive entpacken:
	+
	+	<code bash>
	+	tar -xvf test.tar
	+	gunzip < test.tar.gz \| tar -xvf -
	+	tar -xzvf test.tar.gz # GNU tar Kurzform
	+	</code>
	+
	+	Archivinhalt ansehen:
	+
	+	<code bash>
	+	tar -tvf test.tar
	+	gunzip < test.tar.gz \| tar -tf -
	+	tar -tzvf test.tar.gz # GNU tar Kurzform
	+	</code>
	+
	+	===== GNU TAR =====
	+
	+	:!: GNU-tar entspricht nicht ganz dem POSIX-Standard. Es fehlt das Speichern von ACLs.
	+
	+	===== TAR auf Solaris 8 =====
	+
	+	<code bash>
	+	tar cvf ArchivDatei.tar Source1 Source2 Source3 u.s.w.
	+	</code>
	+
	+	- Erstellt die "ArchivDatei.tar" neu.
	+
	+	<code bash>
	+	tar r....
	+	</code>
	+
	+	- Fügt die "Source1 Source2 Source3 u.s.w." komplett am Ende der "ArchivDatei.tar" hinzu. Alle überschriebenen Dateien bleiben in der "ArchivDatei.tar" als "Leichen" erhalten.
	+
	+	<code bash>
	+	tar u....
	+	</code>
	+
	+	- Fügt die neu dazugekommene und geänderte aus der "Source1 Source2 Source3 u.s.w." der "ArchivDatei.tar" hinzu. Alle überschriebenen Dateien bleiben in der "ArchivDatei.tar" als "Leichen" erhalten.
	+
	+	Beispiel:
	+
	+	Zum Packen (alle Dateien aus dem aktuellen Verzeichnis):
	+
	+	<code bash>
	+	tar cvf /trace/prg123/prg123_err.tar .
	+	</code>
	+
	+	Zum Entpacken (im aktuellen Verzeichnis):
	+
	+	<code bash>
	+	tar xvf /trace/prg123/prg123_err.tar
	+	</code>
	+
	+	:!: Keine absoluten Pfade für die Quelle beim Packen angeben, da beim Entpacken dieselben Pfade benutzt werden. Es ist nicht möglich nachhinein ein anderes Zielverzeichnis anzugeben.
	+
	+	Komprimierung:
	+
	+	Da das TAR auf Solaris nicht selbständig komprimieren kann, ist eine Verkettung mit "gzip" sinnvoll:
	+
	+	Das aktuelle Verzeichnis (komplett) archivieren:
	+
	+	<code bash>
	+	tar cvf - . \| gzip -c > /Pfad/ArchivName.gz
	+	</code>
	+
	+	Das Archiv im aktuellen Verzeichnis entpacken:
	+
	+	<code bash>
	+	gunzip -c < /Pfad/ArchivName.gz \| tar xvf -
	+	</code>
	+
	+	----
	+	Weitere Infos zum Thema:
	+
	+	* Über tar in [[http://de.wikipedia.org/wiki/Tar\|Wikipedia]] lesen.
	+	* Doku zu tar in [[http://linuxwiki.de/tar\|LinuxWiki]] (mit Beschreibung eines Backups des kompletten Systems)
	+	* Sehr gute Anleitung für ein KomplettBackup eines Linux-Systems in LinuxUser: [[http://www.linux-user.de/ausgabe/2006/07/078-recovery/index.html\|Linux retten]] - Mit Tar eine Linux-Installation für den Notfall präparieren.
	+	* tar-Files unter Windows werden von dem OpenSource-Programm [[http://7-zip.de/\|7-Zip]] unterstützt.
	+
	+	----
	+	Stand: 28.01.2010
	+
	+	EOF

edv:os:unix:shell:example:tee

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:52+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== tee ======

	+	Der Befehl tee leitet den Input seiner Standard-Eingabe weiter an die Standard-Ausgabe und gleichzeitig in eine Datei. Damit ist es möglich, die Standard-Ausgabe gleichzeitig auf dem Bildschirm zu betrachten und in eine Datei zu senden.
	+
	+	Ein Beispiel:
	+
	+	<code bash>
	+	ls -l \| tee ls_ausgabe.txt
	+	</code>
	+
	+	Die Ausgabe von "ls -l" wird zur Standard-Eingabe von "tee" geleitet. "tee" wiederum leitet die Ausgabe um in die Datei "ls_ausgabe.txt" und auf die Standard-Ausgabe (hier Bildschirm).
	+
	+	Das ganze lässt sich auch verketten:
	+
	+	<code bash>
	+	ls -l \| tee ls_ausgabe.txt \| grep root \| tee ls_gefiltert.txt
	+	</code>
	+
	+	Die Standard-Ausgabe von dem ersten "tee" wird per Pipe zum "grep" weitergeleitet und die Standard-Ausgabe von "grep" zu dem zweiten "tee".
	+
	+	----
	+	Stand: 25.08.2010
	+
	+	EOF

edv:os:unix:shell:example:textfile_im_skript_bearbeiten

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:56+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Textfile im Skript bearbeiten ======

	+	Hier ist eine mögliche Lösung, daß eine Datei in den Speicher gelesen wird und die eigentliche Arbeit dann auf diesem Speicher erfolgt.
	+
	+	<code bash>
	+	function readfile()
	+	{
	+	local File=$1
	+	local SaveTo=$2
	+	local -i counter=0
	+	while read line; do
	+	eval "$2[$counter]"=\'$line\'
	+	counter=$(($counter+1))
	+	done < $File
	+	eval "$3"=$counter
	+	}
	+	</code>
	+
	+	Die Funktion readfile() wird mit dem Dateinamen als ersten und der Variable, die die Datei aufnehmen soll als zweitem Parameter gerufen. Als Rückgabewert liefert sie im dritten Argument die Anzahl gelesener Zeilen. Dies ist wichtig, da zu einer Feldvariablen nicht entschieden werden kann, wie viele Elemente sie enthält.
	+
	+	Auf die einzelnen Zeilen der Datei können Sie nun mittels Variable[Zeilenummer] zugreifen und irgendwann, wenn die Bearbeitung abgeschlossen ist, möchten Sie die Daten auch wieder zurück schreiben. Hierzu verhilft Ihnen die Funktion writefile(), die als Argumente die Variable mit den Zeilen sowie die Anzahl der Zeilen übergeben bekommt:
	+
	+	<code bash>
	+	function writefile()
	+	{
	+	local Array=$1
	+	for ((i=0; i<${!2}; i++)); do
	+	eval echo "\${$Array[$i]}"
	+	done
	+	}
	+	</code>
	+
	+	Angenommen, obige Funktionen stünden in einer Datei mit dem Namen filehandling.sh, dann könnte in einem Programm so vorgegangen werden:
	+
	+	<code bash>
	+	#!/bin/sh
	+	# Laden der "Bibliotheksdatei"
	+	. filehandling.sh
	+
	+	# Datei einlesen
	+	readfile zu_bearbeitende_Datei FeldVariable Anzahl
	+
	+	# Inhalt bearbeiten
	+	for ((i=0; i<$Anzahl; i++)); do
	+	# Bearbeiten von FeldVariable[$i]...
	+	done
	+
	+	# Datei schreiben
	+	writefile FeldVariable Anzahl > zu_bearbeitende_Datei
	+	</code>
	+
	+	Quelle: LinWiki, zu finden unter http://www.de.linwiki.org/wiki/Linuxfibel_-_Shells_-_Bashprogrammierung
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:touch

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:50+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== touch ======

	+	Einen neuen Timestamp setzen:
	+
	+	<code bash>
	+	touch -t <time> <file>
	+	</code>
	+
	+	Wobei <time> nach dem Muster %%YYMMDDhhmm%% bzw. %%[[CC]YY]MMDDhhmm[.ss]%% zusammengesetzt sein sollte.
	+
	+	Den Timestamp einer Datei für eine andere übernehmen:
	+
	+	<code bash>
	+	touch -r <ref_file> <target_file>
	+	</code>
	+
	+	----
	+	Stand: 05.10.2017
	+
	+	EOF

edv:os:unix:shell:example:tput

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:51+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== tput ======

	+	Terminal Steuerung:
	+
	+	^Kommando ^Reaktion ^
	+	\|tput bel \|Alarmton ausgeben \|
	+	\|tput clear \|Löscht den Bildschirm \|
	+	\|tput cols \|Gibt die Anzahl Spalten des Terminals zurück \|
	+	\|tput cup x y\|Setzt den Cursor auf Zeile x, Spalte y \|
	+	\|tput home \|Entspricht "tput cup 0 0" \|
	+	\|tput el \|Zeile ab Cursorposition löschen \|
	+	\|tput ed \|Bildschirm ab Cursorposition löschen \|
	+
	+	Weitere Infos: man tput.
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:umleitung_von_stdout_und_stderr

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:53+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Umleitung von stdout und stderr ======

	+	Man kann die Ausgabe von stdout und stderr gebündelt in ein File umleiten. Dabei sollte man den Umleite-Befehl an richtiger Stelle platzieren.
	+
	+	Falsch:
	+
	+	<code bash>
	+	jcb@hercules:~$ ps aux 2>&1 > testfile
	+	</code>
	+
	+	Korrekt:
	+
	+	<code bash>
	+	jcb@hercules:~$ ps aux > testfile 2>&1
	+	</code>
	+
	+	Die Erklärung dafür findet man im ADMIN-Magazin unter [[http://www.admin-magazin.de/News/Tipps/ADMIN-Tipp-Achtung-Umleitung?utm_source=ADMIN+Newsletter&utm_campaign=ADMIN-Newsletter-2013-38&utm_medium=email\|ADMIN-Tipp: Achtung, Umleitung]]
	+
	+	----
	+	Stand: 26.09.2013
	+
	+	EOF

edv:os:unix:shell:example:unterschied_zwischen_den_hochkommas

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:51+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Unterschied zwischen ' und " ======

	+	Es gibt mindestens drei Varianten der Interpretation des Inhalts der Shell-Variable. Ein Beispiel:
	+
	+	<code bash>
	+	> ls
	+	file1 file2 file3 file4 file5 file6 file7
	+	> var1="ls -l *"
	+	> echo "${var1}"
	+	ls -l *
	+	> echo '${var1}'
	+	${var1}
	+	> echo ${var1}
	+	ls -l file1 file2 file3 file4 file5 file6 file7
	+	>
	+	</code>
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:verkettung_und_zusammenfassung_von_kommandos

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:53+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Verkettung und Zusammenfassung von Kommandos ======

	+	Hintereinanderausführung:
	+
	+	Will man mehrere Kommandos ausführen lassen, braucht man nicht jedes Kommando einzeln einzugeben und mit der Eingabe des nächsten Kommandos auf die Beendigung des vorhergehenden warten. Die Kommandos werden, getrennt durch Strichpunkt, hintereinander geschrieben:
	+
	+	<code bash>
	+	kommando1 ; kommando2; kommando3
	+	</code>
	+
	+	Sequentielles UND:
	+
	+	Das zweite Kommando wird nur dann ausgeführt, wenn das erste erfolgreich war.
	+
	+	<code bash>
	+	Kommando1 && Kommando2
	+	</code>
	+
	+	Sequentielles EXOR:
	+
	+	(EXOR gleich Exklusives ODER) Das zweite Kommando wird nur dann ausgeführt, wenn das erste erfolglos war.
	+
	+	<code bash>
	+	Kommando1 \|\| Kommando2
	+	</code>
	+
	+	Zusammenfassung von Kommandos:
	+
	+	Kommandos lassen sich zur gemeinsamen E/A-Umleitung mit {...} klammern:
	+
	+	<code bash>
	+	{ Kommando1 ; Kommando2 ; Kommando3 ; ... ; }
	+	</code>
	+
	+	:!: Die geschweiften Klammern müssen von Leerzeichen eingeschlossen werden!
	+
	+	Die Ausführung der Kommandos erfolgt nacheinander innerhalb der aktuellen Shell, die Ausgabe kann gemeinsam umgelenkt werden, z. B.:
	+
	+	<code bash>
	+	{ pwd ; who ; ls ; } > out
	+	</code>
	+
	+	Die schließende Klammer muß entweder durch einen Strichpunkt vom letzen Kommando getrennt werden oder am Beginn einer neuen Zeile stehen. Die geschweiften Klammern sind ein ideales Mittel, die Ausgabe aller Programme eines Shell-Skripts gemeinsam umzuleiten, wenn das Skript beispielsweise mit nohup oder über cron gestartet wird. Man fügt lediglich am Anfang eine Zeile mit der öffnenden Klammer ein und am Schluß die gewünschte Umleitung, z. B.:
	+
	+	<code bash>
	+	{
	+	...
	+	...
	+	...
	+	...
	+	} \| mailx -s "Output from Foo" $LOGNAME
	+	</code>
	+
	+	Eine Folge von Kommandos kann aber auch in einer eigenen Subshell ausgeführt werden:
	+
	+	<code bash>
	+	( Kommando1 ; Kommando2 ; Kommando3 ; ... )
	+	</code>
	+
	+	:!: Achtung: das sind die runden Klammern!
	+
	+	Noch ein Beispiel:
	+
	+	Angenommen wir wollen das Verzeichnis /usr/local nach /mnt kopieren:
	+
	+	<code bash>
	+	( cd /usr/local ; tar cf - . ) \| ( cd /mnt ; tar xvf - )
	+	</code>
	+
	+	Der Parameter f weist tar an, auf eine Datei zu schreiben oder von einer Datei zu lesen. Hat die Datei wie oben den Namen '-', handelt es sich um stdout bzw. stdin.
	+
	+	----
	+	Stand: 26.08.2010
	+
	+	EOF

edv:os:unix:shell:example:verschluesselter_filetransfer_uebers_netz

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:56+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Verschlüsseltes Filetransfer übers Netz ======

	+	Das verschlüsselte Filetransfer von mehreren Dateien erfolgt am besten über SSH oder SCP (was wiederum SSH benötigt).
	+
	+	===== TAR + SSH =====
	+
	+	<code bash>
	+	tar -c FileMaske \| ssh RemoteServer "cat - > /Pfad/ZielDatei.tar";
	+	</code>
	+
	+	Damit werden alle Dateien, die der "FileMaske" entsprechen (das kann auch ein '*' sein) verschlüsselt über SSH zum Zielrechner "RemoteServer" übertragen und dort im Verzeichnis "/Pfad" unter dem Namen "ZielDatei.tar" abgelegt.
	+
	+	Sollte die Komprimierung durch SSH nicht bereits aktiviert sein, kann tar veranlaßt werden, die Daten vor der Übertragung zusätzlich (mit gzip) zu komprimieren:
	+
	+	<code bash>
	+	tar -cz FileMaske \| ssh RemoteServer "cat - > /Pfad/ZielDatei.tgz";
	+	</code>
	+
	+	:!: Interne Komprimierung durch SSH:
	+
	+	Die Komprimierung kann im Client auch dauerhaft eingeschaltet werden. Die Konfigurationsdatei heißt ~/.ssh/config (für benutzerspezifische Konfiguration) oder /etc/ssh/ssh_config (für systemweite Konfiguration) und soll um folgende Parameter ergänzt werden:
	+
	+	<code>
	+	# Einstellungen gelten für den Host RemoteServer
	+	Host RemoteServer
	+	Compression yes
	+	# CompressionLevel ist eine Ganzzahl zwischen 1 (schnell) und 9 (langsam). 6 ist default.
	+	CompressionLevel 9
	+	</code>
	+
	+	...wobei durch den Parameter "Compressionlevel 9" die maximale Kompressionsstufe eingestellt wird.
	+
	+	===== SCP =====
	+
	+	Eine andere Variante ist SCP. Bei SCP geht man ähnlich wie bei einem lokalen Kopieren (mit cp) vor, mit dem Unterschied, daß man vor dem Zielpfad den Zielhost gefolgt von Semikolon angibt:
	+
	+	<code bash>
	+	scp /LokalerPfad/FileName RemoteServer:/ZielPfad
	+	</code>
	+
	+	Anstelle "FileName" darf selbstverständlich ein '' oder ein anderes Muster* stehen.
	+
	+	----
	+
	+	Detaillierte Informationen findet man unter folgenden Adressen:\\
	+	[[http://linux.die.net/man/5/ssh_config\|ssh_config(5) - Linux man page]] (englisch)
	+
	+	----
	+	Stand: 22.10.2009
	+
	+	EOF

edv:os:unix:shell:example:vordefinierte_shell-variablen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:54+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Vordefinierte Shell-Variablen ======

	+	:!: Hier geht es um die Bash-Variablen.
	+
	+	PPID - Prozessnummer des Bash-Vorgänger-Prozesses.
	+
	+	PWD - Aktuelles Arbeitsverzeichnis.
	+
	+	BASH - Vollständiger Pfad der aktuellen Bash. In dem Zusammenhang gibt BASH_VERSION die Programmversion preis und BASH_VERSINFO ist ein Feld (5 Einträge) mit genaueren Angaben.
	+
	+	RANDOM - Erzeugt eine Zufallszahl bei jedem Zugriff.
	+
	+	HOSTNAME - Rechnername ohne Domain.
	+
	+	HOSTTYPE - Architekturtyp des Rechners.
	+
	+	OSTYPE - Typ des Betriebssystems.
	+
	+	PATH - Enthält die Suchpfade, in denen die Bash nach Kommandos sucht. Beachten Sie die Reihenfolge der Suche - bevor die Bash PATH betrachtet, durchsucht sie zunächst die Aliasse, die Funktionen und die eingebauten Kommandos nach dem Namen.
	+
	+	HOME - Enthält das Heimverzeichnis des Benutzers.
	+
	+	TMOUT - Ist dieser Wert gesetzt, beendet sich die Bash, wenn innerhalb der angegebenen Zeitspanne (in Sekunden) keine Eingabe erfolgt. Hiermit kann auf einfache Art und Weise ein Auto-Logout realisiert werden.
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF

edv:os:unix:shell:example:whoami

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:57+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== whoami ======

	+	whoami steht für "Who am I?" Mit diesem Kommando kann man ermitteln, unter welcher Benutzer-Kennung die aktuelle Shell läuft:
	+
	+	<code bash>
	+	juergen@dataserver12:~$ whoami
	+	juergen
	+	juergen@dataserver12:~$
	+	</code>
	+
	+	----
	+	Stand: 29.08.2014
	+
	+	EOF

edv:os:unix:shell:example:zeilenfilter

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:54+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Zeilenfilter ======

	+	In Textfiles/Zeilen Zeichen ersetzen/aufbereiten.
	+
	+	Nehmen wir als Beispiel ein Unload-File, das mehrere DTAUS-Dateien beinhaltet, durch Zeilenende-Zeichen getrennt. Ein zusätzliches '\|'-Trennzeichen am Ende jeder Zeile (z.B. von dbaccess als Feldtrenner beim Unload hinzugefügt).
	+
	+	Bevor die DTAUS-Dateien nach dem Entladen aus der DB bearbeitet werden können, müssen diese aufbereitet werden, beispielsweise wie folgt:
	+
	+	* Sonderzeichen, die vom dbaccess durch '\'-Zeichen "escaped" werden ('\' selbst und '\|'), bereinigen;
	+	* Nicht DTAUS konforme Zeichen durch Blanks ersetzen;
	+	* Kleinbuchstaben zu Großbuchstaben konvertieren;
	+
	+	All diese Aufgaben erledigt folgendes perl-Aufruf:
	+
	+	<code bash>
	+	/usr/bin/perl -e 'while( <STDIN> ) {
	+	chomp ;
	+	$outBuf = $_ ;
	+	$outBuf =~ s/\\\\/ /g;
	+	$outBuf =~ s/\\\\|/ /g;
	+	$outBuf =~ s/[^ A-Za-z0-9\.\,\-\+\*\%\/\$\&]/ /g;
	+	$outBuf =~ s/ $/\|/g;
	+	$outBuf = uc($outBuf);
	+	print STDOUT "$outBuf\n";
	+	}' < ${INPUT_UNLOADS_DTAUS_FILES} 1>${OUTPUT_DTAUS_FILE} 2>${OUTPUT_ERROR_MELDUNGEN}
	+	</code>
	+
	+	Erläuterung:
	+
	+	* Das Kommando ''$outBuf = $_ ;'' liest eine Zeile aus dem Input-Stream ''<STDIN>''
	+	* Kommandos ''$outBuf =~ s/\\\\/ /g;'' und ''$outBuf =~ s/\\\\|/ /g;'' ersetzen das doppelte '\'-Zeichen ('\\') bzw. das escaped '\|'-Zeichen ('\\|') durch Blanks
	+	* Das Kommando *''$outBuf =~ s/[^ A-Za-z0-9\.\,\-\+\\%\/\$\&]/ /g;'' ersetzt alle Zeichen, die in diesem Kommando nicht** erwähnt sind (Invertierung durch das '^'-Zeichen vorne) durch Blanks
	+	* Das Kommando ''$outBuf =~ s/ $/\|/g;'' fügt am Ende jeder Zeile wieder ein '\|'-Zeichen hinzu
	+	* Das Kommando ''$outBuf = uc($outBuf);'' konvertiert alle Kleinbuchstaben zu Großbuchstaben
	+	* Das Kommando ''print STDOUT "$outBuf\n";'' schreibt die fertige Zeile gefolgt vom Zeilentrenner auf 'stdout' raus
	+
	+	----
	+	Stand: 01.04.2011
	+
	+	EOF

	aktuell
Zeile 1:	Zeile 1:
	+	====== Vordefinierte Shell-Variablen ======

	+	:!: Hier geht es um die Bash-Variablen.
	+
	+	PPID - Prozessnummer des Bash-Vorgänger-Prozesses.
	+
	+	PWD - Aktuelles Arbeitsverzeichnis.
	+
	+	BASH - Vollständiger Pfad der aktuellen Bash. In dem Zusammenhang gibt BASH_VERSION die Programmversion preis und BASH_VERSINFO ist ein Feld (5 Einträge) mit genaueren Angaben.
	+
	+	RANDOM - Erzeugt eine Zufallszahl bei jedem Zugriff.
	+
	+	HOSTNAME - Rechnername ohne Domain.
	+
	+	HOSTTYPE - Architekturtyp des Rechners.
	+
	+	OSTYPE - Typ des Betriebssystems.
	+
	+	PATH - Enthält die Suchpfade, in denen die Bash nach Kommandos sucht. Beachten Sie die Reihenfolge der Suche - bevor die Bash PATH betrachtet, durchsucht sie zunächst die Aliasse, die Funktionen und die eingebauten Kommandos nach dem Namen.
	+
	+	HOME - Enthält das Heimverzeichnis des Benutzers.
	+
	+	TMOUT - Ist dieser Wert gesetzt, beendet sich die Bash, wenn innerhalb der angegebenen Zeitspanne (in Sekunden) keine Eingabe erfolgt. Hiermit kann auf einfache Art und Weise ein Auto-Logout realisiert werden.
	+
	+	----
	+	Stand: 05.11.2009
	+
	+	EOF