SUCHE MIT Google
Web virtualuniversity.ch
HOME DIDAKTIK ECDL ELEKTRONIK GUIDES HR MANAGEMENT MATHEMATIK SOFTWARE TELEKOM
DIENSTE
Anmeldung
Newsletter abonnieren
Sag's einem Freund!
VirtualUniversity als Startseite
Zu den Favoriten hinzufügen
Feedback Formular
e-Learning für Lehrer
Spenden
Autoren login
KURSE SUCHEN
Kurse veröffentlichen

Suche nach Datum:

Suche mit Schlüsselwort:

Suche nach Land:

Suche nach Kategorie:
PARTNER
ausbildung24.ch - Ausbildungsportal, Seminare, Kursen... 

 
HTMLopen.de - Alles was ein Webmaster braucht

 
PCopen.de - PC LAN Netze und Netzwerke - alles was ein IT Profi und Systemtechnicker braucht

TELEKOM

Perl-Clients für Standard-Dienste

Client für Binärdaten

Das folgende Programm hat eine URL als Parameter. Diese URL wird in Host, Port und Dateipfad gesplittet. Dann öffnet das Programm eine Verbindungzum Host und versucht, per HTTP-Get die Datei zu erhalten. Im Erfolgsfall wirdder HTTP-Header ueberlesen und danach die Binärdaten in ein Programmgeleitet. Das Programm kann dann (hoffentlich) die mp3-Daten abspielen.Analog funktioniert das Programm auch mit anderen Dateien (z.B. Bilderoder Programme).

#!/usr/bin/perl# Ein einfacher TCP-Client zum Abspielen von mp3-Dateien# Verwendung: $0 URLuse strict;use IO::Socket;use constant TIMEOUT => 5;my $SOCK = '';my $reply = '';my $content = ''; my $header = '';my $handler = '/usr/bin/audioplay';# Abspielprogrammmy $url = shift @ARGV; # URL zerlegen$url=~m/http\:\/\/([^\:^\/]*)(?:\:(\d+))?\/(.*)/; my $host = $1; my $port = $2; $port = 80 unless($port); my $file = '/'.$3; $SOCK = new IO::Socket::INET(PeerAddr => $ARGV[0], PeerPort => $ARGV[1], Proto => 'tcp', Timeout => TIMEOUT) or die "can't connect to $ARGV[0]:$ARGV[1]: $@\n"; my $old_fh = select(SOCK); # Ungepufferte Ausgabe $|=1; # fuer SOCK einstellen select($old_fh); print "Requesting $file..\n"; print SOCK "GET $file HTTP/1.0\n"; print SOCK "Accept: */*\n"; print SOCK "User-Agent: webamp 007\n\n"; print "Waiting for reply..\n"; $header = <SOCK>; exit unless($header=~m/200|OK/); # Ende bei Fehlermeldung while($header = <SOCK>) # Header ueberlesen { chomp; last unless(m/\S/); } open(HANDLER, "|$handler") or die "Cannot pipe input to $handler: $!\n"; print "Redirecting HTTP filestream to $handler..\n"; while(read(SOCK, $content, 512)) { print HANDLER $content; # Perl-Strings sind } # "binaerfest" $sock->close() if defined $sock;

Portscanner

Das folgende Programm verwendet IO::Socket, um die TCP-Ports eines Rechners zu untersuchen. Dazu wird ein Socket eröffnet und ein Connect auf dem gewünschten Port versucht. Wenn auf dem entsprechenden Port kein Serverprozeß läuft, würde der Connect hängen bleiben. Dieser Fall wird über einen Timeout mit der Perl-Funktion alarm() abgefangen. Der Timeout löst einen Interrupt aus, der die Verbindung schließt. Per Schleife werden alle Ports zwischen zwei Parameterangaben abgefragt. Das Programm erlaubt die Angabe der zu untersuchenden Rechner (IP-Adresse) auf der Kommandozeile.

#!/usr/bin/perl -w use IO::Socket; use strict; my $pinghost = ''; $|=1; foreach $pinghost (@ARGV) { &port_scan($pinghost, 1, 1024); } exit; sub port_scan # ($hostip, $lowport, $highport) { my $port = 0; my $iaddr = 0; my $paddr = 0; my $connect_time = 1; my $protocol_name = "tcp"; my $protocol_id = getprotobyname($protocol_name); my $hostip = shift; my $lowport = shift; my $highport = shift; print "Portscan von $hostip.\n"; for ($port = $lowport; $port <= $highport; $port++) { $SIG{"ALRM"} = sub { close(SOCKET); }; alarm $connect_time; socket(SOCKET, PF_INET, SOCK_STREAM, $protocol_id); $iaddr = inet_aton($hostip); $paddr = sockaddr_in($port, $iaddr); print " Port $port offen.\n" if (connect(SOCKET, $paddr)); close(SOCKET); } }

FTP-Clients

Mit dem Modul Net::FTP von Graham Barr lassen sich Client-FTP-Methoden in Perl-Programmen einfach realisieren. Alle Methoden geben, soweit es nicht anders vermerkt ist, einen "wahren" Wert (ungleich Null) im Erfolgsfall zurück und "false" (gleich Null) bei Fehlern. Bei Methoden, die einen Wert zurückgeben, wird im Misserfolgsfall 'undef' oder eine leere Liste zurückgeben.
  • new (HOST [,OPTIONS])
    ist der Constructor für ein Net::FTP-Objekt. HOST spezifiziert den FTP-Server, mit Verbindung aufgenommen werden soll. Dieser Parameter muß angegeben werden. Optionen werden in einer Hash-ähnlichen Schreibweise in OPTIONS übergeben. Mögliche Werte sind u. a.:
    • Timeout: Die maximale Zeit in Sekunden, die gewartet wird, bis der Server antwortet (Voreinstellung: 120 Sekunden).
    • Port: Die Nummer des Ports des FTP-Servers, zu dem die Verbindung aufgenommen werden soll. Voreinstellung: 21.
    • Debug: Ermöglicht Diagnosemeldungen auf STDERR (Voreinstellung: false).
    • Passive: Falls true werden Datentransfers im "passive mode" ausgeführt. Einige Proxy-Konfigurationen erfordern diesen Modus. Dieser Wert wird durch die Umgebungsvariable FTP_PASSIVE überschrieben.
    • Hash: Falls true werden Doppelkreuze (#), sog. Hashmarks, während des Transfers auf STDERR ausgegeben.
    Im Fehlerfall wird undef zurückgegeben und eine Fehlermeldung in $@ gesetzt. Beispiel:

    #!/usr/bin/perl -w use Net::FTP; use strict; my $host = 'ftp.netzmafia.de'; my $ftp = Net::FTP->new ($host, Timeout => 360, Port => 21, Debug => 1, Hash => 0 ); unless (defined $ftp) { print "$@\n"; die "Can't create Net::FTP-Object\n"; } Erzeugen eines neuen FTP Objekts, das mit der Addresse des FTP Servers initialisiert wird. Gleichzeitig wird die Verbindung mit dem FTP Server hergestellt. Dieses "Verbindungsobjekt" wird nun über seinen Namen ($ftp) angesprochen. NNun kann es nun mittels passender Methoden manipuliert bzw. verwendet werden werden. Genau dies geschieht in den folgenden Skriptzeilen:
    Man loggt sich ein mittels Benutzernamen und Paßwort, lädt eine Datei herunter oder hinauf und loggt sich wieder aus.
  • login ([USER [,PASSWORD [, ACCOUNT] ] ])
    Führt den Login-Prozess auf dem FTP-Server mit den angegebenen Informationen (Username, Passwort, etc.) durch. Werden keine Argumente angegeben, verwendet Net::FTP das Modul Net::Netrc zur Ermittlung dieser Daten. Falls keine Information in der Datei .netrc gefunden wird, wird ein anonymer Login ausgeführt. In diesem Fall wird bei Fehlen des Passworts die E-Mail-Adresse des lokalen Users verwendet. Beispiel:

    $user = 'plate'; $password = 'geheim'; $ftp->login($user,$password) || die "Can't login $!"; oder unter Verwendung von .netrc:

    $ftp->login(); # Sucht einen passenden Eintrag in .netrc für HOST aus new() Anonymer Login:

    $ftp->login('anonym','webhamster@netzmafia.de');
  • site (ARGS)
    Sendet das FTP-Kommando SITE mit dem gegebenen Argument und wartet auf die Antwort des Servers. Zurückgegeben wird das erste Digit des Antwortcodes; zum Beispiel:

    $return_code = $ftp->site("chmod 755 $file"); Das erste Digit hat gemäss RFC 959 folgende Bedeutung
    • 1yz Positive Preliminary reply
    • 2yz Positive Completion reply
    • 3yz Positive Intermediate reply
    • 4yz Transient Negative Completion reply
    • 5yz Permanent Negative Completion reply

    Mögliche Fehlerbehandlung:

    print "Kommando O.K. - Datentransfer\n" if ($return_code == 1); print "Kommando erfolgreich\n" if ($return_code == 2); print "Kommando O.K. - Weiter!\n" if ($return_code == 3); print "Temporaerer Fehler\n" if ($return_code == 4); print "Fehler \n" if ($return_code == 5);

  • type (TYPE)
    Setzt den Typ der Datenübertragung. Zurückgegeben wird der vorherige Typ. Net::FTP verwendet folgende Synonyme um den Typ zu spezifzieren:

    ascii => A binary => I ebcdic => E byte => L Beispiel:

    # ascii-transfer $ftp->type("A"); # binaer-transfer $ftp->type("I"); ebcdic und byte werden nicht vollständig unterstützt.
  • rename (OLDNAME, NEWNAME)
    benennt die Datei OLDNAME in NEWNAME auf dem FTP-Server um. Zum Umbennen von Dateien auf dem lokalen Rechner steht Ihnen die Perlfunktion rename() zur Verfügung (rename($old_name,$new_name);) Beispiel (Datei auf dem FTP-Server umbenennen):

    $old_name = 'test.txt'; $new_name = 'Protokoll.txt'; $ftp->rename($old_name,$new_name) || die "Can't rename\n";

  • delete (FILENAME)
    Löscht die angegebene Datei auf dem FTP-Server. Zum Löschen von Dateien auf dem lokalen Rechner steht Ihnen die Perlfunktion unlink($file) zur Verfügung. Beispiel:

    $ftp->delete($file) || die "Can't unlink remote $file $!";
  • cwd ([DIR])
    change working directory. Wechselt in das angegebene Verzeichnis auf dem FTP-Server. Falls DIR nicht spezifiziert ist, wird ins Wurzelverzeichnis gewechselt. Beispiel:

    $dir = '/pub/perl/CPAN/'; $ftp->cwd($dir) || die "Can't change working directory $dir $!";
  • cdup ()
    change directory up. Wechselt in das übergeordnete Verzeichnis auf dem FTP-Server. Beispiel:

    $ftp->cdup();
  • pwd ()
    print working directory. Gibt den Namen des aktuellen Verzeichnisses auf dem FTP-Server zurück. Beispiel:

    print "Aktuelles Verzeichnis: ", $ftp->pwd() , "\n";
  • rmdir (DIR [,RECURSE])
    Löscht das Verzeichnis DIR auf dem FTP-Server. Zum Löschen von Verzeichnissen auf dem lokalen Server können Sie die Perlfunktion rmdir() verwenden. Falls RECURSE auf "wahr" gesetzt wird, werden alle angegebenen Verzeichnisse rekursiv gelöscht. Beispiel:

    $dir = 'temp_files'; $OK = $ftp->rmdir($dir,0);
  • mkdir (DIR [,RECURSE])
    Erstellt das Verzeichnis DIR auf dem FTP-Server und gibt den Pfad zum neu angelegten Verzeichnis zurück. Zum Erstellen von Verzeichnissen auf dem lokalen Server können Sie die Perlfunktion mkdir() verwenden. Beispiel:

    $dir = '/pub/foo'; $path = $ftp->mkdir($dir) || die "Can't create remote $dir $!"; print "$path\n"; Falls RECURSE auf "wahr" gesetzt wird, werden alle angegebenen Verzeichnisse rekursiv angelegt, zum Beispiel:

    $dir = '/pub/perl/new-files'; $ftp->mkdir($dir,1) || die "Can't create remote $dir recursively $!"; erzeugt die Verzeichnisse /pub und /pub/perl und /pub/perl/new-files.
  • ls ([DIR])
    Liefert das Directory-Listing für DIR oder (ohne Parameter) das aktuelle Verzichnis auf dem FTP-Server zurück. Je nach Kontext wird eine Liste oder eine Referenz auf eine Liste mit Dateinamen zurückgegeben. Beispiel für Listenkontext:

    @files = $ftp->ls(); foreach $file (@files) { print "$file\n"; } Beispiel für skalalen Kontext:

    $array_ref = $ftp->ls(); foreach $file (@$array_ref) { print "$file\n"; } Die meisten FTP-Server verwenden das Unix-Kommando ls oder etwas dazu analoges.
  • dir ([DIR])
    Wie ls(). Es wird jedoch das lange Format (Zugriffsrechte, Eigentümer, Datum, Dateigrösse, etc.) verwendet. Die meisten FTP-Server dafür das Unix-Kommando ls -l.
  • get (REMOTE_FILE [,LOCAL_FILE [,WHERE]])
    holt die Datei REMOTE_FILE vom FTP-Server. Falls keine Name für die lokale Datei angegeben wird, erhält sie dien Namen von REMOTE_FILE. WHERE spezifiziert die Anzahl Bytes der Datei, die beim Transfer übersprungen werden sollen. Dies ist sinnvoll, wenn ein unterbrochener Dateitransfer vervollständigt werden soll. Beispiel für das Holen eines kompletten Verzeichnisses:

    @files = $ftp->ls(); foreach $file (@files) { $ftp->get($file); } Hinweis: Falls die Datei(en) im ASCII-Modus übertragen wurden, können sich die Grössenangaben bzw. Startpunkte auf dem lokalen Server und dem FTP-Server unterscheiden (Unterschiede bei der Darstellung des Zeilenendes).
  • put (LOCAL_FILE [,REMOTE_FILE])
    Transferiert die Datei LOCAL_FILE zum FTP-Server. Falls es sich bei LOCAL_FILE um ein Dateihandle handelt, muß REMOTE_FILE angegeben werden. Ist REMOTE_FILE nicht spezifiziert, wird der Name der lokalen Datei verwendet. Zurückgeben wird der Name (ohne Verzeichnis) der Datei auf dem FTP-Server. Beispiel:

    $file = '/home/plate/foo.bar'; $remote_file_name = $ftp->put($file) || die "Can't put $file $!"; print "$remote_file_name\n"; # ergibt foo.bar
  • supported (CMD)
    Gibt "wahr" zurück, falls der FTP-Server das angegebene Kommando akzeptiert. Beispiel:

    $OK = $ftp->supported('STOU'); $OK ? print "STOU supported\n" : "STOU is not supported\n";
  • abort()
    Unterbricht den augenblicklichen Datentransfer. Beispiel:

    $OK = $ftp->abort();
  • quit()
    Sendet das Kommando QUIT an den FTP-Server und schliesst die Socketverbindung. Beispiel:

    $ftp->quit();
Beispiel: Automatisch Dateien holen

#!/bin/perl use Net::FTP; use strict; my $host = 'localhost'; my $user = 'plate'; my $password = 'geheim'; my $file = ''; my $array_ref = ''; # Neues Net::FTP-Objekt my $ftp = Net::FTP->new($host, Timeout => 360, Debug => 1 ); unless (defined $ftp) { print "$@\n"; die "Can't create Net::FTP-Object\n"; } $ftp->login($user,$password) || die "Can't login $!"; print "Aktuelles Verzeichnis: ", $ftp->pwd() , "\n"; $array_ref = $ftp->ls(); foreach $file (@$array_ref) { # Transfermodus in Abhängigkeit von der Dateiendung setzen if ($file =~ /(\.gif|\.jpg|\.tar|\.tar\.gz|\.tgz|\.zip)$/) { $ftp->type(I); } else { $ftp->type(A); } $ftp->get($file); } $ftp->quit();

Ping

Das Hilfsprogramm ping wird verwendet, um die Ereichbarkeit eines Rechners zu testen. Net::Ping ist eine Perl-Variante des Programms ping. Es hat zwar bei weitem nicht alle Features des Originals, läuft dafür aber überall wo Perl läuft. Falls Router oder Firewalls icmp-Pakete ausfiltern oder UDP- bzw. TCP-Echo abgeschaltet ist, meldet ping fälschlicherweise, daß die Maschine unerreichbar ist. Net::Ping kann mit drei Protokollen verwendet werden.
  1. UDP: Net::Ping schickt ein UDP-Packet an den echo-Port des gewünschten Rechners. Falls das gesendete Datagramm mit dem zurückgeliefertem übereinstimmt, gilt der Rechner als erreichbar.
  2. TCP: Net::Ping versucht eine TCP-Verbindung zum echo-Port des gewünschten Rechners aufzubauen. Im Erfolgsfall gilt der Rechner als erreichbar.
  3. icmp: Net::Ping sendet eine icmp-Nachricht an den gewünschten Rechner. Falls gesendete und empfangene Daten übereinstimmen gilt der Rechner als erreichbar. Das Programm muß in diesem Fall unter der von root laufen.
  • new([PROTO [,TIMEOUT [, BYTES]]])
    Der Constructor für ein neues Net::Ping-Objekt. Alle Parameter sind optional. PROTO spezifiziert das zu verwendende Protokoll. Mögliche Werte sind: tcp, udp (Voreinstellung) oder icmp. Net::Ping verwendet intern die Funktion alarm(), wenn das Protokoll tcpverwendet wird. Falls in Ihrem Programm bereits ein Alarm gesetzt ist, wird dieser überschrieben.
    TIMEOUT setzt die Timeoutzeitspanne in Sekunden. Voreinstellung: 5 Sekunden. Dieser Wert wird für die Methode ping() verwendet.
    BYTES spezifiziert die Anzahl Bytes, die für die ping-Anfrage verwendet werden sollen. Dieser Wert wird ignoriert, wenn TCP verwendet wird. Voreinstellung: UDP: 1, ICMP: 0.

  • ping(HOST [, TIMEOUT])
    pingt die entfernte Maschine HOST. Falls die Maschine erreichbar ist, wird "wahr" zurückgegeben. Falls der Host nicht gefunden werden kann, wird undef zurückgegeben. In der Praxis sollten Sie 'undef' und 'false' als identisch betrachten. Beispiel:

    if ( $p->ping($host) ) { print "$host is reachable\n"; } else { print "$host is unreachable\n"; }
  • close()
    Schließt die Netzwerkverbindung. Die Verbindung wird ebenfalls geschlossen, wenn der Scope verlassen wird. Beispiel:

    $p->close();
  • pingecho(HOST [, TIMEOUT])
    Veraltet. Existiert aus Kompatibilitätsgründen zu älteren Versionen.
Das folgende Unterprogramm pingt einen Host (IP-Nummer) mittels ICMP-Protokoll an. Aufruf beispielsweise pinger(192.168.23.1):

sub pinger # (Host) { # Parameter: Host-IP-Nummer my $host = shift; # zu pingender Host my $retval = 0; # Ergebnis: 0 nicht erreicht, 1 erreicht, 2 Fehler # Neues Net-Ping Objekt my $p = Net::Ping->new('icmp'); unless (defined $p) { die "*** can't create Net::Ping object $!";} # Exceptions auffangen eval { $retval = 1 if ($p->ping($host)); if ($@) { print "*** Ping failed\n*** $@\n"; $retval = 2; } $p->close; undef ($p); sleep(1); # avoid network flooding return $retval; } } Das Unterprogramm kann verwendet werden, um alle Rechner eines C-Netzes auf Erreichbarkeit zu testen:

#!/usr/bin/perl -w use Net::Ping; use strict; my $network = '192.168.33'; print "Scanning Network $network.0 \n"; for ($count = 1; $count <= 254; $count++) { $pinghost = $network . "." . $count; $ret = &pinger($pinghost); if ($ret == 1) { print "$pinghost reached\n"; } } exit; Das folgende Beispiel testet die Erreichbarkeit eines Rechners mit den drei zur Verfügung stehenden Protokollen.

#!/usr/bin/perl -w use Net::Ping; # Standardmodul use strict; my $host = '127.0.0.1'; # Protokoll TCP my $p = Net::Ping->new('tcp'); unless (defined $p) { die "can't create Net::Ping object $!";} if ($p->ping($host)) { print "$host reachable via TCP\n" ; } else { print "$host unreachable via TCP\n"; } $p->close; # avoid network flooding sleep(1); # Protokoll UDP $p = Net::Ping->new(); # UDP ist Voreinstellung unless (defined $p) { die "can't create Net::Ping object $!";} # Exceptions auffangen eval { if ($p->ping($host)) { print "$host reachable via UDP\n"; } else { print "$host unreachable via UDP\n"; } }; if ($@) { print "$@: UDP failed\n"; } undef $p; # avoid network flooding sleep(1); if ($> == 0) { # Falls das Skript als 'root' (UID 0) läuft # Protokoll 'icmp' verwenden $p = Net::Ping->new('icmp'); unless (defined $p) { die "can't create Net::Ping object $!";} if ($p->ping($host)) { print "$host reachable via icmp\n"; } else { print "$host unreachable via icmp\n"; } undef $p; } exit;

Webapplikationen

Die Programmierung von Webapplikationen setzt gute Kenntnisse des zugrundeliegenden Protokolls voraus. Sie finden hier eine kurze Einführung in den Umgang mit HTTP mit dem Modul LWP. LWPbehandelt zur Durchführung von Interaktionen mindestens folgende Variablen bzw. Objekte:
  1. UserAgent-Objekt
  2. URI
  3. Request-Objekt
  4. Response-Objekt
Beispiel:

# UserAgent use LWP::UserAgent; $ua = LWP::UserAgent->new(); # URI $url = 'http://www.netzmafia.de/'; # Request $Anfrage = HTTP::Request->new('GET', $url); # Response $Antwort = $ua->request($Anfrage); Zur Erfolgskontrolle bzw. Fehlerbehandlung stehen die beiden Methoden is_success() bzw. is_error() zur Verfügung, zum Beispiel:

unless ($Antwort->is_success() ) { print "Fehlernummer : ", $Antwort->code() , "\n"; print "Fehlermeldung: ", $Antwort->message(), "\n"; }

HTTP-Header

Häufig will man nur wissen, wie groß eine Datei ist, ob sie sich seit dem letzten Zugriff verändert hat oder ob die URI noch exisitert. HTTP stellt die Methode HEAD für derartige Anfragen zur Verfügung. Hier einige Beispiele zum Zugriff auf die HTTP-Header mit LWP-Methoden. Das erste Beispiel zeigt das Holen der HTTP-Header mit LWP::Simple:

use LWP::Simple; $url = "http://www.netzmafia.de/index.html"; # Header ermitteln ($content_type, $document_length, $modified_time, $expires, $server) = head($url); # Ergebnisse ausgeben print "Content-type: ", $content_type, "\n"; print "Document-Length: ", $document_length, "\n"; print "Modified-Time: ", $modified_time, "\n"; print "Expires: ", $expires, "\n"; print "Server: ", $server, "\n"; Falls man nur wissen will, ob die URI noch existiert:

$exists = head($url); if ($exists) { print "URI existiert\n"; } else { print "\a\a\aKein Anschluss unter dieser URI.\n"; }

LWP::Simple

LWP::Simple stellt drei Funktionen zur Verfügung:
  1. get zum Holen eines Dokuments, z. B.:

    use LWP::Simple; $url = 'http://www.netzmafia.de/index.html' $dokument = get($url); unless (defined $dokument) { print "ERROR\n"; exit };
  2. getprint, um das ganze Dokument zu holen und den Inhalt auszugeben:

    use LWP::Simple; $url = 'http://www.netzmafia.de/index.html' getprint($url);
  3. getstore, um das ganze Dokument zu holen und in einer Datei zu speichern:

    use LWP::Simple; $url = 'http://www.netzmafia.de/index.html' $localfile = '/home/plate/tmp/index.html'; getstore($url, $localfile);

LWP::UserAgent

Erweiterter Zugriff auf HTTP-Header mit LWP::UserAgent

#!/usr/bin/perl -w use LWP::UserAgent; use strict; my ($url, $ua, $request, $response); $url = "http://www.netzmafia.de/index.html"; # User Agent $ua = LWP::UserAgent->new(); # Anfrage mit Methode HEAD $request = HTTP::Request->new('HEAD', $url); # Antwort holen $response = $ua->request($request); if ($response->is_success()) { # Header als ASCII-Text ausgeben print $response->headers_as_string() , "\n" } else { # Fehlermeldung ausgeben print $response->message() , "\n"; } Falls man nur an bestimmten Feldern interessiert ist, kann man die Methode header(), etwa zum Bestimmen der Grösse der Datei, verwenden:

... $size = $response->header('Content-Length'); print "URL: $url Grösse: $size Bytes\n"; ... Den HTTP-Status-Antwort-Header erhält man mit:

#!/usr/bin/perl -w use LWP::UserAgent; use strict; my ($url, $ua, $request, $response); $url = "http://192.168.33.2/index.html"; # User Agent $ua = LWP::UserAgent->new(); $request = HTTP::Request->new('HEAD', $url); $response = $ua->request($request); print "HTTP-Status-Antwort-Header: ", $response->code , "\n"; Beispiel: Hat sich die URL seit gestern geändert? Der Request benötigt die Zeit in Unix-Sekunden, daher ein paar Umrechnungsfaktoren:
  • Tag: 86400 s
  • Woche: 604800 s
  • Monat (30,5 Tage): 2635200 s
  • Jahr (365 Tage): 31536000 s


use HTTP::Status; use HTTP::Date; use LWP::UserAgent; use strict; my ($url, $ua, $request, $response); $url = 'http://192.168.33.2/'; $request = HTTP::Request->new(HEAD, $url ); # Tag => 86400 s # Woche (7 Tage) => 604800 s # Monat (30.5 Tage) => 2635200 s # Jahr (365 Tage) => 31536000 s # Aktuelle Zeit in UnixSekunden - 1 Tag = gestern $mtime = time - 86400; # Request-Header setzen $request->header('If-Modified-Since' => time2str($mtime)); # User Agent $ua = LWP::UserAgent->new(); $response = $ua->request($req); # 304 --> Keine Aenderung seit der angefragten Zeitspanne if ( $response->code() == RC_NOT_MODIFIED) { print "$url wurde seit time2str($mtime) nicht geändert\n"; } else { print "\aWake up. $url changed\n"; }

Die Methode response() von LWP::UserAgent bietet einen komfortablen Zugriff auf Dokumente. Neben der verbesserten Möglichkeit zur Erfolgskontrolle stehen drei Varianten zur Verfügung.

  1. response($request)
    holt das angeforderte Dokument. Der Inhalt des Dokumentes ist über die Methode content() erreichbar.

    use LWP::UserAgent; $ua = LWP::UserAgent->new(); $url = 'http://www.netzmafia.de/' $request = HTTP::Request->new('GET', $url); $response = $ua->request($request); if ( $response->is_error() ) { print "Fehlernummer : ", $response->code() , "\n"; print "Fehlermeldung: ", $response->message() , "\n"; } else { print $response->content() , "\n"; }
  2. response($request, $file)
    holt das ageforderte Dokument und speichert den Inhalt in der angegeben lokalen Datei.

    use LWP::UserAgent; $file = 'local.html'; $ua = LWP::UserAgent->new(); $url = 'http://www.netzmafia.de/' $request = HTTP::Request->new('GET', $url); $response = $ua->request($request, $file); if ( $response->is_error() ) { print "Fehlernummer : ", $response->code() , "\n"; print "Fehlermeldung: ", $response->message() , "\n"; } else { print $response->content() , "\n"; }
  3. response($request, \&callback, $Chunk_Size)
    holt das angeforderte Dokument häppchenweise. Die Grösse der Happen wird mit $Chunk_Size festgelegt. Nach dem Erhalt eines jeden Pakets wird dieses Paket an eine Callbackroutine weitergereicht, die bereits während der Übertragung die angekommenen Daten verarbeiten kann.

    use LWP::UserAgent; $file = 'local.html'; $ua = LWP::UserAgent->new(); $url = 'http://www.netzmafia.de/' $request = HTTP::Request->new('GET', $url); $Chunk_Size = 5 * 1024; # Wie gross soll der Happen sein $response = $ua->request($request, \&Bearbeite, $Chunk_Size); sub Bearbeite { $Bereits_erhaltene_Daten = shift; ... ++$x; print "Happen Nummer $x\n\n"; print "$Bereits_erhaltene_Daten\n"; ... } Diese Vorgehensweise ist beispielsweise sinnvoll bei
    • langsamen Netzverbindungen
    • umfangreichen Downloads (Datei muß nicht in den Hauptspeicher passen)
    • Hintergrundverarbeitung des Inhalts
    • Parsen des Dokuments schon während der Übertragung
    • Extrahieren von Links
    • Verarbeitung des Inhaltes in einem separatem Prozess
    • Verarbeitung kontinuierlicher Datenströme

Zugriff auf WWW-Formulare mit GET

Die GET-Methode kann auch verwendet werden, um Daten an den Server (an ein CGI-Skript) zu senden. An die URI wird ein "?" angehängt, gefolgt vom QueryString. Ein Name-Wert-Paar wird durch ein '=' zusammengehalten, die Wertepaare werden jeweils durch '&' getrennt.

use LWP::UserAgent; $ua = LWP::UserAgent->new(); $url = http://www.netzmafia.de/cgi-bin/info.cgi?Category=Soft&Language=Perl $request = HTTP::Request->new('GET', $url); $response = $ua->request($request); if ( $response->is_error() ) { print "Fehlernummer : ", $response->code() , "\n"; print "Fehlermeldung: ", $response->message() , "\n"; } else { print $response->content() , "\n"; }

Falls die Daten des Query-Strings Leerzeichen, Sonderzeichen oder ähnliche kritische Zeichen enthalten, müssen diese entsprechend kodiert werden. Das Modul URI::Escape stellt die dafür notwendigen Methoden zur Verfügung:

use URI::Escape; $querystring = 'Name=Jürgen Plate&Strasse=Gänsemarkt 5'; $safe_querystring = uri_escape($querystring); print $safe_querystring , "\n"; Liefert Name=J%FCrgen%20Plate&Strasse=G%E4nsemarkt%205. Nun lässt sich der Request vollständig angeben:

$querystring = 'Name=Jürgen Plate&Strasse=Gänsemarkt 5'; $safe_querystring = uri_escape($querystring); $url = 'http://www.netzmafia.de/cgi-bin/info.cgi?'; $url .= "$safe_querystring"; ... $request = HTTP::Request->new('GET', $url); ...

DIPLOMARBEITEN UND BÜCHER

Diplomarbeiten zum Runterladen:

Suche im Katalog:
Architektur / Raumplanung
Betriebswirtschaft - Funktional
Erziehungswissenschaften
Geowissenschaften
Geschichtswissenschaften
Informatik
Kulturwissenschaften
Medien- und Kommunikationswissenschaften
Medizin
Psychologie
Physik
Rechtswissenschaft
Soziale Arbeit
Sozialwissenschaften


JOBS
HOME | E-LEARNING | SITEMAP | LOGIN AUTOREN | SUPPORT | FAQ | KONTAKT | IMPRESSUM
Virtual University in: Italiano - Français - English - Español
VirtualUniversity, WEB-SET Interactive GmbH, www.web-set.com, 6301 Zug

Partner:   Seminare7.de - PCopen.de - HTMLopen.de - WEB-SET.com - YesMMS.com - Ausbildung24.ch - Manager24.ch - Job und Karriere