Globenaut

Skripttipp #11: Kurz-URLs vor dem Besuch auflösen

#:~>curl -Is 'http://bit.ly/4LjZ1'
HTTP/1.1 301 Moved
Server: nginx/0.7.42
Date: Mon, 10 Aug 2009 19:55:09 GMT
Content-Type: text/html; charset=utf-8
Connection: keep-alive
Location: http://kinderpornos.info/
MIME-Version: 1.0
Content-Length: 287

#:~>

#!/usr/bin/env bash
#
if [ "$1" != '' ]; then
     curl -Is $1 | grep Location | cut -d ' ' -f2
else
     echo -e "\e[31mKeine URL an das Skript übergeben!\e[0m
fi

set Abbruch to false
set Ergebnis to ""
set Zeit to 30
set KurzURL to the clipboard
try
 set Verweis to (do shell script "curl -Is " & KurzURL & ¬
  "| grep Location | cut -d ' ' -f2")
 set Ergebnis to display dialog ¬
  "Die Ziel-URL von " & KurzURL & " lautet:" default answer Verweis ¬
  buttons {"abbrechen", "OK, ansehen..."} ¬
  with title "Kurz-URL auflösen" default button 2 cancel button 1 ¬
  giving up after Zeit
on error number -128
 set Abbruch to true
end try

if Abbruch then
else if button returned of Ergebnis is "OK, ansehen..." then
 open location text returned of Ergebnis
else if gave up of Ergebnis then
 display dialog "Mehr als " & Zeit & ¬
  " Sekunde keine Antwort." with title "Zeitüberschreitung"
end if

Labels: .bashrc, AppleSkript, Bash, cURL, grep, IT, Kurz-URL, MacOS X, Skripttipp, Terminal, Twitter

#  0 Kommentare

Skripttipp #10: Passwortgenerator für MacOS X und Linux

Für alle die öfter mal ein neues Passwort benötigen lohnt sich ein kleiner Passwortgenerator für die Kommandozeile. Unter Linux reicht hierfür ein kurzer Einzeiler, unter MacOS X Leopard sind ein paar Zeilen mehr notwendig (zumindest bis zur aktuellen Version 10.5.8), weil ein merkwürdiger Fehler von MacOS X Leopard umgangen werden muß.

Linux

Zunächst der grundlegende Teil am Beispiel Linux. Als Erstes wird mit urandom ein (pseudo)zufälliger Zeichenstrom erzeugt, der mit tr auf sinnvolle Zeichen (hier: auf der Tastatur leicht eingebbar) eingegrenzt und mittels head auf die gewollte Länge gestutzt wird.

tr -dc "[:graph:]" < /dev/urandom | head -c10

Der auszugebene Zeichensatz läßt sich dabei wie folgt steuern:

• [:alnum:] nur Buchstaben und Zahlen
• [:alpha:] nur Buchstaben
• [:digit:] nur Zahlen
• [:graph:] nur durckbare Zeichen, außer Leerzeichen
• [:lower:] nur Kleinbuchstaben
• [:upper:] nur Großbuchstaben
• [:xdigit:] nur hexadezimale Zeichen

Dies sind nur die für Passwörter sinnvollen Parameter. Wer Anderes benötigt, möge dies mit man tr nachlesen.

MacOS X

Benutzt man unter MacOS X Leopard den Einzeiler aus dem Linuxabschnitt, erhält man eine Fehlermeldung, die auf einen Fehler in Leopard zurückgeht:

#:~>tr -dc "[:graph:]" < /dev/urandom | head -c10
head: can't combine line and byte counts
tr: Illegal byte sequence

Diese Fehlermeldung taucht dann auf, wenn die LOCALE in LC_ALL einen anderen Wert als C hat (auf einem deuschen System ist dies mehrheitlich de_DE.UTF-8). Um diesen Fehler zu umgehen muß man also die Variable LC_ALL entsprechend anpassen und falls man in einem längeren Skript arbeitet nachher wieder auf den ursprünglichen Wert zurücksetzen:

#!/usr/bin/env bash
#
lc=$LC_ALL
LC_ALL=C
tr -dc "[:graph:]" < /dev/urandom | head -c10
LC_ALL=$lc

Dieses Skript liefert das gleiche Ergebnis wie der Einzeiler unter Linux, eine zehnstellige Zeichenfolge.

Gemischtes

Man kann dieses Skript aber noch aufhübschen. Ersetzt man head -c10 durch head -c ${1:-10} kann man die Passwortlänge einfach durch Übergabe eine Wertes steuern. Wird nichts übergeben, erfolgt standardmäßig eine zehnstellige Ausgabe. Eine weitere Verbesserung könnte sein, daß die Ausgabe gleich direkt in die Zwischenablage (vgl. Skripttipp #7: Datenaustausch zwischen Zwischenablage und Terminal) geschrieben wird. Dies ist praktisch, wenn man öfter Passwörter beim Surfen benötigt. Unter Linux erfolgt dies mit xclip, unter MacOS X mit pbcopy:

tr -dc "[:graph:]" < /dev/urandom | head -c ${1:-10} | xclip

tr -dc "[:graph:]" < /dev/urandom | head -c ${1:-10} | pbcopy

Zum Abschluss noch eine runde, komplette Lösung für MacOS X.

Für Macianer die gar nicht gerne mit dem Terminal arbeiten, gibt es die Möglichkeit den Passwortgenerator in die Menüleiste zu integrieren (vgl. Skripttipp #1: Bashskripte in die Menüzeile des Finders einbinden). Die einfachste Möglichkeit ist, ein Alias auf das Skript (oder auch das Skript selber) unter »~/Library/Scripts/« abzulegen. Bei dieser Variante können dem Skriptaufruf keine Parameter übergeben werden. Daher ist es besser, ein kleines AppleSkript zu schreiben, welches das Bashskript ggf. mit entsprechenden Parametern aufruft.
Eine Komplette Lösung, also Passwortgenerator in der Menüzeile und ein Alias in der .bashrc verweisen mit unterschiedlichen Parametern auf das Bashskript:

Das Skript

#!/usr/bin/env bash
#
# Dateiname     Passwortgenerator
# Autor         Globenaut
# erstellt      08.08.2009
# geändert      08.08.2009
# Beschreibung  Erzeugt pseudozufällige Zeichenfolgen für Passworte.
# Parameter     $1: Länge der Zeichenfolge 

pb=0
Zeichenvorrat='[:graph:]'
while getopts ':abcghkxz' Schalter
do
    case "$Schalter" in
        a ) Zeichenvorrat='[:alnum:]';;
        b ) Zeichenvorrat='[:alpha:]';;
        g ) Zeichenvorrat='[:upper:]';;
        k ) Zeichenvorrat='[:lower:]';;
        x ) Zeichenvorrat='[:xdigit:]';;
        z ) Zeichenvorrat='[:digit:]';;
        c ) pb=1;;
        \? ) echo 'Abbruch, da unbekannter Schalter: -'$OPTARG; exit;;
    esac
done
shift $((OPTIND - 1))

lc=$LC_ALL
LC_ALL=C
pw=`tr -dc "[:graph:]" < /dev/urandom | head -c ${1:-10}`
LC_ALL=$lc
if [ $pb == 1 ]; then
    echo -n $pw | pbcopy  
else
    echo $pw
fi  

exit 0
########## Weitere Erl?uterungen zum Skript ##########
# Schalter:
# -a Alphanumerische Zeichen [:alnum:].
# -b Nur Buchstaben [:alpha:].
# -c Wenn vorhanden wird die Zeichenfolge in die Zwischenablage geschrieben, ansonsten auf stdout ausgegeben.
# -g Nur Gro?buchstaben [:upper:].
# -h Ruft diese Hilfe auf.
# -k Nur Kleinbuchstaben '[:lower:].
# -x Nur hexadezimale Zeichen [:xdigit:].
# -z Nur Ziffern [:digit:].

Das AppleSkript

tell current application
 do shell script "~/bin/Passwortgenerator -c 10"
end tell

Der Pfad zum Skript muß ggf. angepasst werden und es muß in »~/Library/Scripts/« gespeichert werden. Jetzt steht der Passwortgenerator in allen Programmen in der Menüzeile zur Verfügung (sofern das Skriptmenü aktiviert ist, vgl. Skripttipp #1). Bei Anklicken der Menüzeile wird eine 10stellige pseudozufällige Zeichenfolge in die Zwischenablage geschrieben, gebrauchsfertig zum Einsetzen in Webformulare. Achtung: Die Zeichenfolge ggf. notieren, da Passwortfelder Selbige nicht anzeigen und sie nicht reproduzierbar ist!

Das Alias

alias pw='Passwortgenerator 20'

Bei Aufruf von pw im Terminal wird eine 20stellige Zeichenfolge auf der Kommandozeile ausgegeben.

Darüberhinaus hat man noch die Möglichkeit das Bashskript mit beliebigen Paramtern aufzurufen:

#:~>Passwortgenerator 35
#:~>S,/Eqzd)GDGHeSc%:]/#tQaUXr{&`~?rFgO
#:~>Passwortgenerator -c 40

Das Skript ist so eingestellt, daß nach der Zeichenfolge kein Umbruch ausgegeben wird, wenn sie in die Zwischenablage geschrieben wird (daher echo -n $pw), bei Ausgabe auf die Kommandozeile hingegen schon.

Labels: .bashrc, AppleSkript, IT, Linux, MacOS X, Passwort, pbcopy, Skripttipp, Terminal, xclip

#  0 Kommentare

Skripttipp #9: Farbige Textausgabe im Terminal

Werden Farben richtig eingesetzt, erleichtern sie die Erkennung durch ihre strukturierende Wirkung ungemein. Das gilt auch für das Terminal, leider sind dort die Farbkennungen weder leicht zu errinnern, noch erhöhen sie die Lesbarkeit des Skriptes. Um dieses Problem zu umgehen, kann man sich eine kleine Funktion schreiben, der man als Parameter einen Text und einen Farbnamen übergibt. Die Funktion erledigt den Rest und gibt den Text farbig auf dem Terminal aus.

function Farbige_Textausgabe ()
{
 local Farbe
 case "$2" in
  r* ) Farbe='31m' ;;            #rot
  ge* ) Farbe='1;33m' ;;         #gelb
  gr* ) Farbe='1;32m' ;;         #grün
  b* ) Farbe='34m' ;;            #blau
 esac
 echo -e "\e[$Farbe$1\e[0m"
}

Hier sind nur vier Farben definiert worden, aber jedem steht es frei weitere hinzuzufügen. Der Aufruf in einem Skript erfolgt dann ganz einfach:

#!/usr/bin/env bash
...
s='Es ist ein Fehler aufgetreten'
...
Farbige_Textausgabe $s rot
...

Bleibt noch die Frage zu klären, wohin mit der Funktion? Man kann sie in die .bashrc einfügen, aber wer öfter mit Skripten arbeitet sollte alle häufiger benutzten Funktionen in eine Datei (bspw. Funktionenbibliothek) schreiben, welche am Anfang eines jedes Skriptes „gesourced“ wird:

#!/usr/bin/env bash
# Autor         
# erstellt     
# geändert     
# Beschreibung  
# Parameter      
 
source $HOME/bin/Funktionenbibliothek
...
exit 0

So vorbereitet kann an jeder Stelle des Skriptes jetzt die Funktion Farbige_Textausgabe aufgerufen werden. Das Skript bleibt gut lesbar und übersichtlicher, genauso wie die Ausgabe. Jetzt muß man sich nur an ein Farbschema halten, bspw. Fehlermeldungen rot, Hinweise gelb und Erfolgsmeldungen grün.

Welche Farbkombinationen gibt es und wie sehen sie auf dem Bildschirm aus? Diese Frage beantwortet ein kleines Skript, welches alle Kombinationen aus Zeichen- und Hintergrundfarbe und ihre jeweilige Codierung ausgibt:

#!/usr/bin/env bash
#
# Dateiname  Farbtabelle
# Autor   Globenaut
# erstellt  15.11.2007
# geändert  03.08.2008
# Beschreibung Gibt eine Tabelle der ANSI-Farben aus.
# Parameter  $1: kurzer Probetext (3 Zeichen!), optional.

 t=${1:-gM8}
 echo -e "\n              40m   41m   42m   43m   44m   45m   46m   47m"
 for VGe in '    m' '   1m' '  30m' '1;30m' '  31m' '1;31m' '  32m' '1;32m' '  33m' '1;33m' '  34m' '1;34m' '  35m' '1;35m' '  36m' '1;36m' '  37m' '1;37m';
 do VG=${VGe// /}
  echo -en " $VGe \e[$VG $t "
  for HG in 40m 41m 42m 43m 44m 45m 46m 47m;
  do
   echo -en " \e[$VG\e[$HG $t \e[0m"
  done
  echo
 done
 echo

Wird beim Aufruf dem Skript kein Parameter übergeben, wird gM8 (ein Buchstabe mit Unterlänge, ein breiter Großbuchstabe und eine Ziffer) als Beispieltext verwendet, andernfalls der Text aus dem Parameter. Bei mehr als drei Zeichen gerät allerdings die Tabelle durcheinander. Das Endergebnis sollte in etwa so aussehen:

Ansi-Farben vor schwarzem Terminalhintergrund

Labels: Ansi-Farben, Bash, IT, Skripttipp, Terminal

#  0 Kommentare

Skripttipp #8: Notizen für jedes Verzeichnis anzeigen

Wohin mit Notizen und/oder Erledigungen? Benutzt man ein darauf spezialisiertes Programm und sammelt alle Notizen in einer Datei oder legt man einfach nur Textdateien an und wenn ja, wo legt man sie dann ab? Eine universelle Lösung habe ich auch nicht anzubieten, aber für Kleinigkeiten die in ein Verzeichnis gehören (etwa Erledigungen zu einem Projekt) kann man mit der Bash etwas Brauchbares basteln.

Zunächst wird die Variable PROMPT_COMMAND in der .bashrc so modifiziert, daß immer dann, wenn der Prompt angezeigt wird auch der Inhalt einer Datei ausgegeben wird. Jetzt kann man einfach immer wenn es etwas zu Notieren gibt mit seinem Texteditor eine (unsichtbare) Datei bspw. .Erledigungen anlegen und in diese seine Notizen hieninschreiben.

export PROMPT_COMMAND="if [ -a .Erledigungen ]; then echo 'Erledigungen zu diesem Verzeichnis:'; \ 
cat .Erledigungen; fi"

Diese Zeile in die .bashrc einfügen und die .bashrc neu einlesen. Befindet sich nun eine Datei .Erledigungen in dem aktuellen Vezeichnis, wird deren Inhalt jedesmal beim Aufruf des Promptes, nach einem Kommando angezeigt, andernfalls erscheint nichts:

#:~>cd Globenautblog/
Erledigungen zu diesem Verzeichnis:
    1 Skripttipp zur ToDo-Liste schreiben
    2 Kommentardarstellung überarbeiten
#:~>

Die Zeilennummerierung ist eine Funktion von cat, nämlich cat -n. Ich habe bei mir in der .bashrc ein Alias defniert, welches mir immer bei Verwendung von cat (ebenso bei grep) die Zeilennummern anzeigt:

alias cat='cat -n'
alias grep='grep -aEin --color'

Wer dieses Aliase nicht haben möchte, muss halt die PROMPT_COMMAND-Zeile anpassen und einfach ein -n nach dem cat einfügen.

Für meine Arbeitsweise hat es sich als praktisch erwiesen, zwei Dateien zu verwenden. Eine .Erledigungen und eine .Notizen:

export PROMPT_COMMAND="if [ -a .Erledigungen ]; then echo 'Erledigungen zu diesem Verzeichnis:'; \ 
cat .Erledigungen; fi; if [ -a .Notizen  ]; then echo 'Notizen zu diesem Verzeichnis:'; cat .Notizen; fi;"

Zu Erinnerung, die Lösung ist für Kleinigkeiten gedacht, werden die Listen zu groß wird es unpraktisch. Natürlich kann man auch wesentlich größere Programmabläufe an den PROMPT_COMMAND übergeben, aber da der Prompt so gut wie andauernd angesprochen wird, sollte man sich gut überlegen, wie groß solche Prgramme werden sollen. Es macht absolut keinen Sinn an dieser Stelle einen Ablauf zu integrieren, in dessen Folge man jedesmal sekundenlang auf das Erscheinen des Promptes warten muss.

Labels: .bashrc, Alias, Bash, IT, PROMPT_COMMAND, Skripttipp, Terminal

#  0 Kommentare

Skripttipp #7: Datenaustausch zwischen Zwischenablage und Terminal

Der erste Teil beschreibt das Verfahren für MacOS X, weiter unten folgen dann Hinweise für Linux.

Besonders hilfreich sind die nachfolgend beschriebenen Funktionen beim Schreiben von Dokumentationen (bspw. Verzeichnislisten, Dateiinhalte) zur Weiterverabritung von Suchergebnissen oder auch mal zur Übertragung eines längeren Passwortes ohne Intermediärdatei.

MacOS X

Mac-Benutzer sind es seit den Anfängen gewohnt mittels Einfügen und Einsetzen Daten über die Zwischenablage zwischen Programmen auszutauschen. Seit MacOS X hat auch das klassische UNIX-Terminal Einzug gehalten, mit dem auch dann und wann Daten von Programmen der grafischen Oberfläche ausgetauscht werden sollen. Die beiden klassischen Wege über Kopieren und Einsetzten bzw. Drag & Drop funktionieren wie gewohnt, aber es gibt noch eine dritte Möglichkeit, die mehr Funktionalität bietet und oft auch schneller ist. Daher heute ein paar Tipps zu einem meinem Eindruck nach wenig bekannten, aber äußerst nützlichen Befehlspaar unter MacOS X: pbpaste und pbcopy.[1] Sie sind Bestandteil von MacOS X, daher ist keinerlei Installation notwendig. Mittels dieser beiden Terminalprogramme kann man Daten vom Terminal direkt in die Zwischenablage (pbcopy) bzw. aus der Zwischenablage (pbpaste) in das Terminal — genauer nach stdin — schreiben:

#:~>cat Test.txt | pbcopy
#:~>

Alternativ läßt sich auch mit der Ausgabeumleitung arbeiten:

#:~>pbcopy < Test.txt
#:~>

Eine Kopie des Inhaltes der Datei Test.txt befindet sich jetzt in der Zwischenablage. Dies ist deutlich schneller als das Aktivieren der Ausgabe im Terminalfenster oder das Anlegen einer temporären Datei und Öffnen dieser im Programm der grafischen Oberfläche (sofern sich dort überhaupt eine Textdatei öffnen läßt). Dies funktioniert natürlich auch mit jedem anderem Terminalprogramm oder Skript, welches eine Ausgabe auf stdout liefert:

#:~>ls -Ghl | pbcopy
#:~>grep blabla Test.txt | pbcopy
#:~>Mein_Skript.sh | pbcopy
#:~>

Pbcopy bietet die wohl schnellste Möglichkeit die Ergebnisse von Terminalprogrammen in die grafische Oberfläche zu bekommen. Allerdings kann ein Fallstrick entstehen, wenn man fälschlicherweise anstelle der Pipeline (|), die Ausgabeumleitung (>) benutzt:

#:~>Mein_Skript.sh > pbcopy
#:~>

Das funktioniert zwar fehlerfrei, führt nicht zum gewünschten Ergebnis. Alle Ausgaben von Mein_Skript.sh werden durch die Ausgabeumleitung in eine neu angelegte Textdatei namens pbcopy geschrieben. Das Programm pbcopy wird weder ausgeführt, noch muss es überhaupt vorhanden sein! Ein einfaches ls im Terminal zeigt es.

Richtig interessant wird pbcopy aber erst im Netzwerk, denn es kann zum schnellen Datentransfer zwischen zwei Rechnern benutzt werden. Angenommen man möchte den Inhalt einer Textdatei von einem entfernten Rechner in die Zwischenablage des eigenen Rechners holen:

#:~>ssh User@Entfernter_Rechner "cat Test.txt" | pbcopy
User@Entfernter_Rechner password:
#:~>

Die Datei Test.txt wird auf dem entfernten Rechner ausgelesen, über das Netzwerk nach stdout auf dem eigenen Rechner transferiert und über die Pipeline direkt in die Zwischenablage geschrieben.

Das eigentlich bemerkenswerte an dieser Befehlsfolge ist aber, daß auf dem entfernten Rechner weder MacOS X, noch pbcopy vorhanden sein müssen! Es funktioniert mit jedem Rechner, sofern man sich dort mittels SSH einloggen kann. Etwas anders sieht der Fall aus, wenn man sich erst auf dem entfernten Rechner eingeloggt hat und dann versucht mit pbcopy zu arbeiten:

#:~>ssh User@Entfernter_Rechner
User@Entfernter_Rechner password:
User@Entfernter_Rechner:~>cat Test.txt | pbcopy
#:~>

In diesem Falle arbeitet man mit stdin und stdout auf dem entfernten Rechner, d.h. es wird pbcopy auf dem entfernten Rechner und somit i.d.R. MacOS X benötigt. Außerdem würde diese Befehlsfolge den Inhalt der Datei in Zwischenablage des entfernten Rechners schreiben (was unter bestimmten Bedingungen auch durchaus sinnvoll sein kann) und nicht über das Netzwerk auf den eigenen Rechner transferieren.

Ein weiteres Anwendungsgebiet von pbcopy und pbpaste kann in Kombination mit dem do shell-Befehl von AppleSkript liegen, auch wenn AppleSkript einen eigenen Befehl zum Zugriff auf die Zwischenablage (the clipboard) bietet.

Linux

Unter Linux und in X11-Umgebungen leisten xsel und xclip analoge Funktionalität. Ubuntu-Benutzer müssen xclip und xsel noch nachinstallieren, was auf der Kommandozeile mit einem einfachen sudo apt-get install xclip bzw. sudo apt-get install xsel gemacht wird. Der Ablauf sollte ungefähr wie folgt aussehen:

#:~>sudo apt-get install xclip
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut       
Lese Status-Informationen ein... Fertig
Die folgenden NEUEN Pakete werden installiert:
  xclip
0 aktualisiert, 1 neu installiert, 0 zu entfernen und 117 nicht aktualisiert.
Es müssen 16,6kB an Archiven heruntergeladen werden.
Nach dieser Operation werden 77,8kB Plattenplatz zusätzlich benutzt.
Hole:1 http://de.archive.ubuntu.com jaunty/universe xclip 0.08-8 [16,6kB]
Es wurden 16,6kB in 4s geholt (3403B/s)
Wähle vormals abgewähltes Paket xclip.
(Lese Datenbank ... 104291 Dateien und Verzeichnisse sind derzeit installiert.)
Entpacke xclip (aus .../archives/xclip_0.08-8_i386.deb) ...
Verarbeite Trigger für man-db ...
Richte xclip ein (0.08-8) ...

#:~>apt-get install xsel
[sudo] password for Globenaut:
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut       
Lese Status-Informationen ein... Fertig
Die folgenden NEUEN Pakete werden installiert:
  xsel
0 aktualisiert, 1 neu installiert, 0 zu entfernen und 117 nicht aktualisiert.
Es müssen 19,2kB an Archiven heruntergeladen werden.
Nach dieser Operation werden 86,0kB Plattenplatz zusätzlich benutzt.
Hole:1 http://de.archive.ubuntu.com jaunty/universe xsel 1.2.0-1 [19,2kB]
Es wurden 19,2kB in 0s geholt (39,3kB/s)
Wähle vormals abgewähltes Paket xsel.
(Lese Datenbank ... 104284 Dateien und Verzeichnisse sind derzeit installiert.)
Entpacke xsel (aus .../archives/xsel_1.2.0-1_i386.deb) ...
Verarbeite Trigger für man-db ...
Richte xsel ein (1.2.0-1) ...
#:~>

Wie fast immer unter Linux erhält man mit xclip -h oder man xclip Informationen zur Benutzung von xclip und analog für xsel.
Für das Schreiben der Daten in die Zwischenablage gibt es, wie meistens, mehrere Wege:

#:~>xclip Test.txt
#:~>

#:~>cat Test.txt | xclip
#:~>

Von der Zwischenablage ins Terminal kann man es so machen:

#:~>xclip -o
#:~>Ich bin Text aus der Zwischenablage von Ubuntu.

Wie schon im Abschnitt von MacOS X, kann man eine Datei direkt übers Netzwerk in die Zwischenablage einlesen, ohne daß auf dem entfernten Rechner die Terminalprogramme vorhanden sein müssen. Eine ssh-Verbindung reicht aus:

#:~>ssh User@Entfernter_Rechner "cat Test.txt" | xclip
User@Entfernter_Rechner password:
#:~>

Da UNIX im Grunde meherere Zwischenablagen [2] kennt, kann man diese auch gezielt ansprechen, wenn es notwendig sein sollte. Meist reicht aber die Voreinstellung aus.

#:~>ssh User@Entfernter_Rechner "cat Test.txt" | xclip -selection clipboard -i
User@Entfernter_Rechner password:
#:~>

Wer in diesem Falle öfter Daten vom Terminal in die Zwichenablage übertragen muß, sollte sich ein alias in der .bashrc anlegen, damit alles was an xclip geleitet wird, automatisch in der Zwischenablage landet:

alias xclip -selection clipboard

1. http://developer.apple.com/DOCUMENTATION/Darwin/Reference/ManPages/man1/pbcopy.1.html
2. http://standards.freedesktop.org/clipboards-spec/clipboards-latest.txt

Labels: .bashrc, Bash, Datenaustausch, IT, Linux, MacOS X, pbcopy, pbpaste, Skripttipp, ssh, Terminal, xclip, Zwischenablage

#  0 Kommentare

Skripttipp #6: Auf der Kommanozeile immer sicher löschen

Mit zu den ersten Kommandos die man lernt wenn man im Terminal arbeitet, heißt rm (remove) zum Löschen von Dateien. rm arbeitet sehr schnell und man kann in weniger als einer Sekunde das gesamte System ruinieren. Jedoch hat rm den Nachteil, nicht die Datei selbst zu löschen, sondern nur den Eintrag der Datei aus dem Index, mit der Folge, daß sich Daten im Zweifelsfall rekonstruieren lassen. Für das sichere Löschen der Datei gibt es srm (secure remove), welches vor dem Löschen des Indexeintrages die Datei überschreibt, umbenennt und abschneidet. Ein einmaliges Überschreiben der Datei ist hierbei vollkommen ausreichend.[1, 2] (Löschorgien wie die Empfehlung 35mal (!) zu überschreiben sind sowieso Unfug [3]). Damit man immer auf der sicheren Seite ist, sollte man rm grundsätzlich auf das sichere srm umleiten. Mit einem kurzen Alias-Eintrag in der .bashrc läßt sich dies leicht bewerkstelligen.

Mit einem beliebigen Texteditor die Datei .bashrc öffnen und folgende Aliase einfügen:

alias rm='echo "srm -srf"; srm -srf'
alias srm='srm -srf'

Eingentlich würde ein Eintrag alias rm='srm' vollkommen ausreichen, aber ich bevorzuge eine kurze Rückmeldung was umgeleitet worden ist. Daher füge ich immer ein echo Kommando dazwischen, welches kurz wiedergibt welcher Befehl ausgeführt wurde. Das zweite Alias dient nur dazu, gleich noch die Standardoptionen von srm festzulegen (-s simple, einmal überschreiben; -r rekursiv, Verzeichnisse löschen; -f force, nicht existente Dateien ignorieren, keine Rückfragen).

Die Datei sichern und auf der Kommanodzeile neu einlesen („sourcen“):

#:~>. .bashrc

Das Ergebnis sieht dann etwas so aus:

#:~>rm Regierung
srm -srf
#:~>

Soll jetzt wirklich mal das originale rm verwendet werden, bspw. weil eine große Datei schnell gelöscht werden muß, kennt die Bash den vorgesetzten \ als Umgehung definierter Aliase:

#:~>\rm Regierung

Hinweis: Wer sicherheitsbewußt ist und an fremden Rechnern arbeitet sollte kontrollieren, ob der Befehl srm auch tatsächlich das tut, von dem man annimmt das er es tun sollte: sicher löschen. Die beschriebene Methode mit dem Alias funktioniert nämlich auch andersherum, die Umleitung vom sicheren srm auf das einfache rm:

alias srm='rm'

1. http://www.heise.de/security/Sicheres-Loeschen-Einmal-ueberschreiben-genuegt--/news/meldung/121855
2. Overwriting Hard Drive Data: The Great Wiping Controversy
   Craig Wright, Dave Kleiman, Shyaam Sundhar R.S.
   In: Information Systems Security, Springer 2008, ISBN 978-3-540-89861-0, Seiten 243-257
   DOI 10.1007/978-3-540-89862-7
   http://www.springerlink.com/content/408263ql11460147/
3. http://www.computerwoche.de/knowledge_center/security/1884445/: In fünf Schritten zur sauberen Festplatte (Bild 3)

Labels: .bashrc, Alias, Bash, IT, rm, Skripttipp, srm, Terminal

#  0 Kommentare

Skripttipp #5: Download der Galeriebilder von www.imagefap.com

Heute Mal ein Tipp für Bildersammler. Wer keine Lust hat, die Bilder von http://www.imagefap.com/ einzeln herunterzuladen oder keine umfangreiche Software verwenden will kann dies, ggf. auch zeitgesteuert und unbeaufsichtigt, mit einem kleinen Bashskript erledigen (lassen). Das Skript erzeugt einen Ordner mit der Gallerienummer als Name und lädt alle Bilder in diesen Ordner herunter.

#!/usr/bin/env bash
# Skript       Imagefap-Download
# Beschreibung Lädt die Bilder einer Galerie von http://WWW.Imagefap.com herunter.
# Parameter    $1: URL der Gallerie (z. B.: http://www.imagefap.com/gallery/123456) 

Galerie_Nr=${1##*/}
Pfad=${2:-$HOME'/Downloads/'}$Galerie_Nr
URL_Inhalt=${1%/*}'.php?gid='$Galerie_Nr'&view=2'
Inhalt='Galerie.html'

cURL_Schalter='-A Anonymous'

mkdir $Pfad
cd $Pfad
curl $cURL_Schalter $URL_Inhalt -o $Inhalt
if [ -e $Inhalt ]; then
 for Bild in $(cat $Inhalt | grep -Eio "/thumb/([^']).*'")
 do
  Bild=$(basename ${Bild%%\'})
  curl $cURL_Schalter 'http://77.247.179.161/full/getimg.php?img='$Bild -o $Bild
 done
 srm -srf $Inhalt
fi

MacOS X Anwender können das Skript so verwenden, Linuxer müssen die Zeile „Pfad“ anpassen und ihren Download-Ordner angeben.

#:~>Imagefap-Download http://www.imagefap.com/gallery/123456

Labels: Bash, cURL, Download, IT, Skripttipp, Terminal

#  0 Kommentare

Skripttipp #4: E-Mail bei Mailinator automatisch abholen

Wer den Mailinator und seine Verwandten benutzt, hat unter Umständen das Problem, daß er einerseits nicht weiß wann die erwartete e-Mail eintrifft, andererseits aber Mailinator selbige nach ein paar Stunden löscht. Dies läßt sich durch ein kleines Bashskript beheben, welches die e-Mails abholt.

Was macht das Skript genau?

1. Für jeden Skriptaufruf wird ein eigener Ordner angelegt, wobei sich der Ordnername aus e-Mailadresse, Datum und Uhrzeit zusammensetzt: Test@Mailinator.com_2009.04.11-1351.
2. Die Liste mit den eingegangenen Mails wird heruntergeladen. Wenn es nicht erfolgreich war endet die Ausführung.
3. Jetzt wird jede e-Mail einzeln heruntergeladen und in einer eigenen Datei abgelegt, wobei als Dateiname der Betreff der jeweiligen e-Mail genommen wird.
4. Abschließend wird die Datei mit der Liste der Eingangsmails sicher gelöscht. Im Ordner verbleiben verbleiben nur die Dateien mit den e-Mails. Ist keine e-Mail eingetroffen, bleibt ein leerer Ordner zurück, um eine einfache Kontrolle der Skriptausführung zu haben.

#!/usr/bin/env bash
# Skript       Mailinatorabfrage
# Beschreibung Holt e-Mail von Mailinator.com ab.
# Parameter    $1: Die e-Mailadresse die abgefragt werden soll; optional.
#              $2: Der Pfad wo die Mail(s) gespeichert werden sollen; optional.

Mailadresse=${1:-'Test@mailinator.com'}
Pfad=${2:-$HOME'/Downloads/'}${Mailadresse}_$(date "+%Y.%m.%d-%H%M")
Domain='http://'${Mailadresse#*@}
URL_Fach=$Domain'/maildir.jsp?email='${Mailadresse%@*}'&x=0&y=0'
Inhalt='maildir.html'
mkdir $Pfad
cd $Pfad
curl -A "Anonymous" $URL_Fach -o $Inhalt
if [ -e $Inhalt ]; then
    for Zeile in $(cat $Inhalt | grep -Eio '/showmail.jsp([^>])*')
    do
        Betreff=$(grep -Eio "${Zeile#*&}.*</a>" < $Inhalt)
        Betreff=${Betreff#*>}
        Betreff=${Betreff%<*}
        curl -A 'Anonymous' ${Domain}${Zeile%>*} -o "$Betreff"'.html'
    done
    srm -srf $Inhalt
fi

Das Skript hat zwei optionale Parameter

1. $1: Die e-Mailadresse die abgefragt werden soll; wird keine angegeben wird 'Test@mailinator.com' genommen.
2. $2: Der Pfad wo die Mail(s) gespeichert werden sollen; wird kein Pfad angegeben, erfolgt die Speicherung in einem Ordner im Download-Ordner des jeweiligen Anwenders (Letzteres gilt für MacOS X, Linuxer müssen den Pfad ggf. anpassen).

Die regelmäßige Ausführung des Skriptes ist unter Linux ein cron-Job, unter MacOS X wird eine separate plist-Datei benötigt. Der Aufbau ist relativ einfach, zur Erstellung werden folgende Angaben benötigt:

1. Die abzufragende e-Mailadresse, bspw. Test@Mailinator.com
2. Ein sinnvoller Name des Jobs, bspw. Mailinator.Test
3. Name des Skriptes und sein Ablageort, bspw. /Users/Loginname/bin/Mailinatorabfrage
4. Der zeitliche Abstand in dem das Skript ausgeführt werden soll in Sekunden, bspw. 3600 (= stündlich)

Ausgehend von diesen Annahmen kann mit jedem beliebigen Texteditor die plist erstellt werden:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
 <key>KeepAlive</key>
 <false/>
 <key>Label</key>
 <string>Mailinator.Test</string>
 <key>ProgramArguments</key>
 <array>
  <string>/Users/Loginname/bin/Mailinatorabfrage</string>
  <string>Test@mailinator.com</string>
 </array>
 <key>RunAtLoad</key>
 <true/>
 <key>StartInterval</key>
 <integer>3600</integer>
</dict>
</plist>

Die Datei jetzt noch als reinen Text unter dem Namen »Mailinator.Test.plist« in »~/Librqary/LaunchAgents« speichern.

Die Angaben unter <array> sind übrigens nichts anderes als ein Skriptaufruf im Terminal mit Parameter:

#:~/bin>Mailinatorabfrage Test@mailinator.com

Ab dem nächsten Neustart wird dann jede Stunde dieses Skript ausgeführt. Eleganter steuert man es aber über die Kommandozeile. Jeweils eines der nachfolgenden (selbsterklärenden ?) Kommandos im Terminalfenster aufrufen:

#:~/Library/LaunchAgents>launchctl load Mailinator.Test.plist
#:~>launchctl start Mailinator.Test
#:~>launchctl list Mailinator.Test
#:~>launchctl stop Mailinator.Test
#:~/Library/LaunchAgents>launchctl unload Mailinator.Test.plist
#:~>launchctl help

Wie auch bei anderen Dingen, sollte man Fairness walten lassen und die automatishe Abfrage nicht unnötig und immerwährend laufen lassen. Der Zeitraum in dem Mails eintreffen können ist ja meist auf wenige Stunden beschränkt. Es ist aber gut geeingnet längere Arbeitspausen oder die Nacht abzudecken.

Wer seine eingehenden Mails nur so Abfragen und speichern will kann das Skript natürlich auch direkt im Terminal aufrufen oder in ein kleines AppleSkript einbetten und per Menü im Finder aufrufen:

tell application "Finder"
 activate
 do shell script "Mailinatorabfrage 'Test@mailinator.com'"
end tell

Labels: Bash, cURL, IT, MacOS X, Mailinator, plist, Skripttipp, Terminal

#  1 Kommentare

Skripttipp #3: Mehrere Dateinamen in die Zwischenablage kopieren

Der Finder hat keinen Befehl um nur die Dateinamen der aktuellen Auswahl in die Zwischenablage zu kopieren. Ein kleines AppleSkript erledigt diese Aufgabe:

tell application "Finder"
 set Liste to selection
 set Namen to ""
 repeat with i in Liste
  tell i
   set Namen to Namen & (name of i) & return
  end tell
 end repeat
end tell
set the clipboard to Namen

Skript in »~/Library/Scripts/Applications/Finder« speichern und schon erscheint im Script-Menü, sofern der Finder vorne ist, ein entsprechender Eintrag. Falls nicht, ist evtl. das Script-Menü deaktiviert, näheres dazu hier.

Das Skript kopiert die Dateinamen wie sie im Finder angezeigt werden! Also je nach Einstellung für jede Datei, mit oder ohne Erweiterung.

Labels: AppleSkript, Finder, IT, MacOS X, Skripttipp

#  0 Kommentare

Skripttipp #2: Mehrere Dateien unterschiedlichen Typs (text, .gz) durchsuchen

Um den Dateiinhalt zu durchsuchen ist grep das richtige Werkzeug, sofern es sich um Textdateien handelt. Sind die Dateien komprimiert (.gz) nimmt man zgrep (wobei zgrep die dekomprimierten Daten wiederum an grep weiterreicht). Was aber wenn in einem Verzeichnis eine bunte Mischung vorliegt und alle Dateien im Verzeichnis durchsucht werden sollen?

Eine kleine Funktion in der .bashrc erledigt genau diese Arbeit in einem Durchgang. Einfach mit einem beliebigen Texteditor die Datei .bashrc öffnen und folgende Funktion einfügen:

function durchsuche ()
{
   for Datei in ${2:-./*}
   do
       if [ ${Datei##*.} = 'gz' ]; then Greptyp='zgrep'; else Greptyp='grep'; fi
       echo -e "\e[1;33m$Datei:\e[0m"
       $Greptyp -aEin --color "$1" $Datei
   done
}

Die Datei sichern und auf der Kommanodzeile neu einlesen („sourcen“):

#:~>. .bashrc

Jetzt ruft man auf der Kommandozeile einfach durchsuche gefolgt von einem regulären Ausdruck und ggf. einem Dateipfad auf. Wird kein Pfad angegeben, werden die Dateien des aktuellen Verzeichnisses (also ./*) durchsucht. Lautet die Dateiendung .gz wird zgrep benutzt, andernfalls grep. Um den Überblick zu bewahren wird beim Beginn der Suche in einer jeden Datei deren Name in gelber Schrift ausgegeben. Dies erleichert auf der Konsole die Orientierung enorm. Zusätzlich sind die grep-Parameter so gewählt, daß jede Fundstelle die Zeillennummer in der jeweiligen Datei enthält, Groß- und Kleinschreibung bei der Suche ignoriert und die Fundstelle innerhalb einer Zeile farbig hervorgehoben wird. Die Funktion arbeitet nicht rekursiv, d.h. sie steigt nicht in möglicherweise vorhandene Unterverzeichnisse ab.

#:~>durchsuche a.*[0-9]
#:~>durchsuche a.*[0-9] ~/Downloads/*

Natürlich kann man auch ein separates Skript anlegen:

#!/usr/bin/env bash
# Skript       durchsuche
# Beschreibung Durchsucht die Dateien in einem Verzeichnis mittels grep oder zgrep
# Parameter    $1: Regulärer Ausdruck
#              $2: Verzeichnis in dem gesucht werden soll; optional.

for Datei in ${2:-./*}
do
    if [ ${Datei##*.} = 'gz' ]; then Greptyp='zgrep'; else Greptyp='grep'; fi
    echo -e "\e[1;33m$Datei:\e[0m"
    $Greptyp -aEin --color "$1" $Datei
done

Labels: .bashrc, Bash, grep, IT, Skripttipp, Terminal

#  0 Kommentare

Skripttipp #1: Bashskripte in die Menüzeile des Finders einbinden

Gleich vorneweg, dieser Tipp ist nur für Benutzer von MacOS X sinnvoll, da er erklärt wie man Shellskripte in die Menüs der grafischen Benutzeroberfläche („Finder“) einbinden kann.

Apple bietet zwar seit Jahren die hauseigene Skriptsprache AppleSkript an, aber deren Beliebtheit hält sich irgendwie in Grenzen. Für viele Dinge ist sie einfach zu unhandlich. Seit Erscheinen von MacOS X steht dem Anwender auch die Welt der Bash mit ihren unzähligen Skripten offen. Oftmals ist es einfacher, ein fertiges Bashskript anzupassen, als das gleiche Problem (noch einmal) mit AppleSkript zu lösen. Doch nicht jeder möchte oder kann im Terminal arbeiten. In solchen Fällen kann man mit Hilfe eines kleinen AppleSkriptes jedes beliebige Bashskript über die Menüzeile aufrufen, denn AppleSkript kennt folgenden praktischen Befehl: do shell script "Skriptname einfügen".[1] Das einfachste AppleSkript sieht damit wie folgt aus:

tell application "Finder"
 activate
 do shell script "Skriptname einfügen"
end tell

Erfodert das Bashskript Parameter in Anführungszeichen, müssen diese in einfache Anführungseichen gesetzt werden oder durch \" maskiert werden:

tell application "Finder"
 activate
 do shell script "Skriptname einfügen 'Parameter einfügen'"
end tell

Der Befehl eignet sich natürlich auch, um in AppleSkpriten Ergebnisse aus der Bash zu verwenden:

tell application "Finder"
 activate
 ...
 set Woche to (do shell script "date '+%V'")
 set Tag to (do shell script "date '+%u'")
 ...
end tell

Jetzt muß das AppleSkript noch in der Menüzeile erscheinen:

1. Sofern noch nicht geschehen, Script-Menü aktivieren:
   1. AppleScript-Dienstprogramm öffnen
   2. »Skriptmenü in der Menüleiste anzeigen« ankreuzen
2. AppleSkript ablegen in »~/Library/Scripts/«

Wurde alles richtig gemacht, erscheint jetzt im ScriptMenü in der Menüzeile ein Eintrag mit dem Namen des AppleSkriptes. Durch Anlegen von Unterordnern behält man im Scripts-Ordner die Übersicht (Unterordner werden automatisch als Untermenüs dargestellt). Besondere Bedeutung kommt hierbei dem Unterordner »Applications« zu. Legt man in diesem Ordner weitere Unterordner mit einem Programmnamen an, erscheinen die darin abgelegten Skripte nur dann, wenn das Programm läuft und sich vorne befindet.

Es gibt noch einen zweiten Weg um schnell BashSkriptaufrufe mit dem Finder zu verbinden:

1. Automator öffnen
2. »Bibliothek einblenden« wählen
3. Doppelklick auf »Shell-Skript« ausführen
4. Skriptname eingeben
5. »Sichern« aufrufen und dort Dateiformat »Programm« wählen und ebenfalls in »~/Library/Scripts/« an geeigneter Stelle ablegen.

Man könnte auch direkt ein Alias auf das Skript oder das Skript selber unter »~/Library/Scripts/« ablegen. Diese Variante hat aber den Nachteil, daß dem Aufruf keine Parameter für das Skript übergeben werden können. Daher ist es flexibler, die Möglichkeit mit dem AppleSkript zu benutzen.

Zum Abschluss ein kleines praktisches Anwendungsbeispiel der Verbidnung zwischen Bash, AppleSkript und grafischer Benutzoberfläche. Das Skript »Hole Wochenlog« holt mit dem Programm Interarchy von einem ftp-Server mittels sftp das jeweils aktuelle Wochenlog (z. B. access.log.08.gz) ab und legt es im richtigen Ordner ab:

tell application "Interarchy"
 activate
 show wTransfers
 
 set Jahr to year of (current date)
 set Woche to (do shell script "date '+%V'")
 set Tag to (do shell script "date '+%u'")
 if Woche < 10 then
  set Woche to "0" & Woche
 end if
 set Logdatei to "access.log." & Woche & "." & Tag
 
 set Ablageort to "Festplatte:Users:Anmibe:Homepage:Logs:access.logs "¬
  & Jahr & ":" & Logdatei
 fetch file Ablageort host "ftp.Domnain.xy" path "logs/" & Logdatei ¬
 user "xyz" protocol SFTPProtocol
end tell

1. Technical Note TN2065 do shell script in AppleScript
   http://developer.apple.com/technotes/tn2002/tn2065.html

Labels: AppleSkript, Bash, Finder, IT, MacOS X, Skripttipp, Terminal

#  0 Kommentare