Externe Dateien prüfen

[Gustl]

Hi all !

Wie kann ich mit externen Pfadangaben "http://www" Dateien prüfen ?

-e -f etc ist nicht anwendbar.

Grüsse Gustl

[Siechfred]

Wie kann ich mit externen Pfadangaben "http://www" Dateien prüfen ?

Mache einen HTTP-Request auf die Ressource, LWP::Simple bietet sich an. Siehe bspw. http://forum.de.selfhtml.org/archiv/2007/1/t145106/#m941694

Siechfred

[Gustl]

LWP::Simple bietet sich an.

Hallo Siechfred, habs mal durchgelesen. Exist kann ich leicht damit prüfen, ein Stein weniger.

Wenn ich die Kantenlänge eines Bildes lesen will muss ich die Datei zwischenspeichern, dann lesen, dann wieder löschen oder gäbe es da noch ne andere Möglichkeit ?

Gruss Gustl

[Struppi]

Wenn ich die Kantenlänge eines Bildes lesen will muss ich die Datei zwischenspeichern, dann lesen, dann wieder löschen oder gäbe es da noch ne andere Möglichkeit ?

nein, ohne die Datei zu lesen kannst du nicht die Eigenschaften der Datei bestimmen.

Struppi.

[Gustl]

nein, ohne die Datei zu lesen kannst du nicht die Eigenschaften der Datei bestimmen.

Hi Struppi :)

Jetzt wo Du´s sagst ... ohne laden nicht lesen ist ja klar ...

Wie mach ich das am besten, also wie komm ich dann an das temporäre File ran ? Oder muss ich es mit namen speichern und dann wieder unlink ?

Gruss Gustl

[迪拉斯]

Hey,

Wenn ich die Kantenlänge eines Bildes lesen will muss ich die Datei zwischenspeichern, dann lesen, dann wieder löschen

Dateien sind nicht nötig.

#!perl -T  
use strict;  
use diagnostics;  
  
use Image::Size qw(imgsize);  
use LWP::Simple qw(get);  
  
my $uri = 'http://www.w3.org/Icons/valid-xhtml10';  
my ($x, $y, $type);  
  
{  
    my $img = get $uri;  
  
    if (defined $img) {  
        ($x, $y, $type) = imgsize \$img;  
    } else {  
        die "could not retrieve <$uri>";  
    };  
};  

[Gustl]

Hey,

Wenn ich die Kantenlänge eines Bildes lesen will muss ich die Datei zwischenspeichern, dann lesen, dann wieder löschen
Dateien sind nicht nötig.

#!perl -T

use strict;
use diagnostics;

use Image::Size qw(imgsize);
use LWP::Simple qw(get);

my $uri = 'http://www.w3.org/Icons/valid-xhtml10';
my ($x, $y, $type);

{
    my $img = get $uri;

if (defined $img) {
        ($x, $y, $type) = imgsize $img;
    } else {
        die "could not retrieve <$uri>";
    };
};

>   

\--  
  
Hi, also jetzt vom durchlesen trifft das den Nagel auf den Kopf. Werds morgen mal probieren.  
  
Wobei ja get auch irgendwo n temporär-file anlegt und es wohl gleich nach dem lesen mit imgsize wieder verwirft. Das hat meine andere Frage dann auch gleich beantwortet !  
  
Schönen Dank, Gustl

[迪拉斯]

Wobei ja get auch irgendwo n temporär-file anlegt

Nö, läuft alles über Sockets.

[Gustl]

#!perl -T

use strict;
use diagnostics;

use Image::Size qw(imgsize);
use LWP::Simple qw(get);

my $uri = 'http://www.w3.org/Icons/valid-xhtml10';
my ($x, $y, $type);

{
    my $img = get $uri;

if (defined $img) {
        ($x, $y, $type) = imgsize $img;
    } else {
        die "could not retrieve <$uri>";
    };
};

  
Also das klappt so. Ich prüfe noch den $type auf JPG PNG GIF. Nur noch eine Frage: Wie komme ich an die Speichergrösse in byte ?  
  
Gruss Gustl

[Gustl]

($x, $y, $type) = imgsize $img;

Also das klappt so. Ich prüfe noch den $type auf JPG PNG GIF. Nur noch eine Frage: Wie komme ich an die Speichergrösse in byte ?

Gruss Gustl

[迪拉斯]

length $img

[Gustl]

LWP::Simple

Nächstes Problem: Wenn ich mit if head prüfe, reicht eine url ohne explizitem Dateinamen, es wird auf index verwiesen. Ich muss aber prüfen ob eine Datei tatsächlich existiert, d.h der User MUSS eine Datei angeben.

Gibt der Anwender http://www.x.de ein sagt head ok. (nehmen wir an der User hat vergessen die datei anzugeben) Ich erwarte aber dass der Anwender http://www.x.de/datei.* eingibt.

Hmmm ...

Gruss Gustl

[Siechfred]

Nächstes Problem: Wenn ich mit if head prüfe, reicht eine url ohne explizitem Dateinamen, es wird auf index verwiesen. Ich muss aber prüfen ob eine Datei tatsächlich existiert, d.h der User MUSS eine Datei angeben.

Eventuell hilft URI::Split:

#!/usr/bin/perl -w  
use strict;  
use diagnostics;  
use URI::Split qw/uri_split/;  
  
my $uri = 'http://www.anaboe.net/foo.html';  
my $path = (uri_split($uri))[2];  
print $path;

Alles, was nach der TLD kommt, steht in $path, diesen Teil kannst du dann prüfen. Ansonsten kannst du dir auch alles ab dem letzten Slash holen und prüfen, ob dieser Teil eine von dir akzeptierte Dateierweiterung hat.

Siechfred

[Gustl]

Guten Morgen.

Eventuell hilft URI::Split:

my $uri = 'http://www.anaboe.net/foo.html';
my $path = (uri_split($uri))[2];
print $path;[/code]

Hab ich auch gelesen. Wie käme ich an das letzte Element, da ich ja nicht weiss aus wie vielen Elementen URI besteht. Wenn [2] das dritte ist ... Mit [-1] ? Ich muss einfach mal testen was zurückgegeben wird.

Ansonsten kannst du dir auch alles ab dem letzten Slash holen und prüfen, ob dieser Teil eine von dir akzeptierte Dateierweiterung hat.

self_html.html -> Nach dem letzten Slash hinter dem Punkt ... oder ich kann vielleicht den mime-type prüfen ? Welche Dateierweiterungen gibt es die den mime-type text/html haben ? htm,html,xhtml ?

Na da hab ich mir wieder was angefangen.

Gruss Gustl

[Siechfred]

Wie käme ich an das letzte Element, da ich ja nicht weiss aus wie vielen Elementen URI besteht. Wenn [2] das dritte ist ... Mit [-1] ? Ich muss einfach mal testen was zurückgegeben wird.

Das musst du nicht, es ist definitiv immer das dritte Element. Sollte es dies nicht geben, wie bspw. hier im Forum (ohne 'my'), enthält das Element einfach nur einen Slash.

self_html.html -> Nach dem letzten Slash hinter dem Punkt ... oder ich kann vielleicht den mime-type prüfen ? Welche Dateierweiterungen gibt es die den mime-type text/html haben ? htm,html,xhtml ?

Den MIME-Typen bekommst du viel eleganter:

#!/usr/bin/perl -w  
use strict;  
use diagnostics;  
use LWP::UserAgent;  
use [link:http://search.cpan.org/~markov/MIME-Types-1.18/@title=MIME::Type];  
  
my $ua = LWP::UserAgent->new;  
my $response = $ua->get('http://www.anaboe.net/');  
my $mime = MIME::Type->new(type => $response->header('Content-type'));  
print $mime->simplified; # 'text/html'

Na da hab ich mir wieder was angefangen.

Hehe, viel Spaß :)

Siechfred

[Siechfred]

Den MIME-Typen bekommst du viel eleganter:

In der Tat, aber nicht mit Hilfe von MIME::Type:

#!/usr/bin/perl -w  
use strict;  
use diagnostics;  
use LWP::UserAgent;  
  
my $ua = LWP::UserAgent->new;  
my $response = $ua->get('http://www.anaboe.net/');  
my $mimestring = $response->header('Content-type');  
my $mimetype = substr $mimestring, 0, index($mimestring, ',');  
print $mimetype;

Sorry, mein Fehler, ich hatte die Beschreibung zu MIME::Type nicht richtig gelesen.

Siechfred

[Gustl]

use LWP::UserAgent;

my $mimestring = $response->header('Content-type');

  
liefert 0 den mime-type und 1 den charset aus, falls vorhanden. (text/html; charset=iso-8859-1)  
  

> ~~~perl
  
my $mimetype = substr $mimestring, 0, index($mimestring, ',');  

liefert das gleiche, nur hinten fehlt ein zeichen. also z.B: image/jpe anstatt jpeg oder charset=iso-8859- anstatt 8859-1.

Könnte ich schon brauchen, ich lass mir von mimestring pos 0 liefern, wie auch immer. das dumme ist, wenn es die datei nicht gibt oder sie nicht lesbar ist bekomme ich den mime-type der nächst erreichbaren datei zurück.

Stünde somit wieder beim Anfangsproblem, der User MUSS eine Datei benennen die dem von mir zugelassenen Typ entspricht. Aber an den Dateinamen alleine komm ich nicht wirklich ran, auch nicht mit uri_split[2]. Die Eingabe möchte ich auch nicht auf 2 inputs aufsplitten.

Schnauf, das wird wohl spannend.

Schon 2 Tage ohne Lösung -> Gruss Frustl

[Siechfred]

my $mimestring = $response->header('Content-type');[/code]
liefert 0 den mime-type und 1 den charset aus, falls vorhanden. (text/html; charset=iso-8859-1)

Ja, habe ich auch schon gesehen, ich sollte gründlicher recherchieren:

my $mimetype = ($response->header('Content-type'))[0];

HTTP::Headers (zu $h->header($field)): A multi-valued field will be returned as separate values in list context and will be concatenated with ", " as separator in scalar context.

Das substr-Gedöns kann man sich also sparen, wenn man das Ergebnis im Listenkontext betrachtet.

Siechfred

[_roro]

hi,

Wie kann ich mit externen Pfadangaben "http://www" Dateien prüfen ?

use LWP::Simple;

if(head $url){ print "Seite lebt\n"}

get(), mirror()...

roro

[Gustl]

Hi all !

Also das ist mal mein Test-Script geworden. Vielleicht ist ja jemand so freundlich und übt ein wenig konstruktive Kritik resp. der vielen Umwege bzw. ist es noch möglich in der Eingabe zu tricksen ? Danke an alle Helfer !

Grüsse Gustl

  
#!/usr/bin/perl  
  
use CGI qw/:standard/;  
use strict;  
use CGI::Carp qw/fatalsToBrowser/;  
use Image::Size qw(imgsize);  
use LWP::Simple qw(get head);  
use LWP::UserAgent;  
  
my $ziel="http://www.";  
my $bild="http://www.";  
  
my $ausgabe; my $back; my $yachse=240; my $xachse=320; my $isize=10241;  
  
my @types=("text/html","JPG","GIF","PNG");  
my @ends=("htm","jpg","jpeg","gif","png");  
  
$ziel=lc($ziel); $bild=lc($bild); $ziel=~s/ //g; $bild=~s/ //g;  
$ziel=~s/\/+$//g; $bild=~s/\/+$//g;  
unless($ziel){$ziel="Ist leer";} unless($bild){$bild="Ist leer";}  
my $pz=$ziel; $pz=~s/(.*)\.//g; my $pb=$bild; $pb=~s/(.*)\.//g;  
  
my @ms=split(/;/,(LWP::UserAgent->new->get($ziel)->header('Content-type')));  
  
my $h_end; if($pz=~/$ends[0]/){$h_end=1;}  
my $h_typ; if($ms[0]=~/$types[0]/){$h_typ=1;}  
  
if ((head $ziel)&&($h_end)&&($h_typ))  
{  
  $ausgabe="Deine URI: <font color=blue>Ist erreichbar und wurde akzeptiert</font><br><br>";  
}  
  else  
{  
  $back=1;  
  $ausgabe="<font color=red>Deine URI entspricht nicht den Vorgaben oder ist nicht erreichbar</font><br><br>  
  Eingabe: <font color=red>$ziel</font><br><br>";  
}  
  
my $img=get $bild; my ($x,$y,$type)=imgsize \$img; my $size=length $img;  
  
my $i_end; if(($pb=~/$ends[1]/)||($pb=~/$ends[2]/)||($pb=~/$ends[3]/)||($pb=~/$ends[4]/)){$i_end=1;}  
my $i_typ; if(($type=~/$types[1]/)||($type=~/$types[2]/)||($type=~/$types[3]/)){$i_typ=1;}  
my $i_sp; if(($size < $isize)&&($size ne 0)){$i_sp=1;}  
my $i_ka; if(($x eq $xachse)&&($y eq $yachse)){$i_ka=1;}  
  
if ((head $bild)&&($i_end)&&($i_typ)&&($i_sp)&&($i_ka))  
{  
  $ausgabe="$ausgabe Dein Bild: <font color=blue>Ist erreichbar und wurde akzeptiert</font><br><br>";  
}  
  else  
{  
  $back=1;  
  $ausgabe="$ausgabe <font color=red>Dein Bild entspricht nicht den Vorgaben oder ist nicht erreichbar</font><br><br>";  
  
  unless((head $bild)&&($i_end)&&($i_typ))  
  {  
    $ausgabe="$ausgabe Eingabe: <font color=red>$bild</font><br><br>";  
    goto weiter;  
  }  
  
  $ausgabe="$ausgabe Eingabe: $bild<br><br>";  
  $ausgabe="$ausgabe Mime-Type: $type<br><br>";  
  
  my $kbyte=sprintf("%.3f",($size / 1024));  
  
  unless($i_sp)  
  {  
    $ausgabe="$ausgabe Grösse: <font color=red>$size in Byte ($kbyte in Kilobyte)</font><br><br>";  
    goto weiter;  
  }  
  
  $ausgabe="$ausgabe Grösse: $size in Byte ($kbyte in Kilobyte)<br><br>";  
  
  unless($i_ka)  
  {  
    $ausgabe="$ausgabe Maße Höhe/Breite: <font color=red>$y x $x in Pixel</font><br><br>";  
  }  
}  
  
weiter:  
  
if($back)  
{  
  $ausgabe="$ausgabe Das war nix. Probier was anderes";  
}  
  
print header('text/html');  
  
print "$ausgabe";  
  
unless ($back)  
{  
  print"Das war gut. Probier trotzdem was anderes";  
}

[迪拉斯]

Hey,
einige Sachen, die ich anspreche, sind Mäkelei und haben keine schlimme Wirkung, wenn man sie nicht befolgt. Andere wiederum sind dicke Hunde und können kritisch sein. Zu welcher Kategorie eine gehört, merkst du mit der Erfahrung.

• Codegestaltung ist ziemlich knorrig, lege dir Perl::Tidy zu.
• Du hast vergessen, Taintmode einzuschalten.
• Cargokultprogrammierung mit use. Du musst dir bewusst machen, was use bewirkt, nämlich den Import von Funktionen. Für CGI.pm importierst du :standard, also eine ganze Gruppe von Funktionen, und dann benutzt du sie nicht, dein ganzes HTML ist nämlich manuell zusammengekleistert. Wieso die unnötige Namensraumverschmutzung schlecht ist, bemerkt man dann, wenn man feststellen muss, dass sowohl LWP::Simple als auch CGI.pm eine Funktion namens head exportieren. Geh solchen Kollisionen aus dem Weg, indem du objektorientierte Methodenaufrufe machst, statt Funktionen zu importieren und prozedural aufzurufen. Wenn du importierst, schränke das auf die Funktionen ein, die du wirklich benötigst. Ein Vorteil davon ist, dass im Kopf eines Programms die verwendeten Funktionen quasi durch den Import selber dokumentiert werden, sehr wichtig zur Wartbarkeit.
• Wenn man LWP::UserAgent hat, braucht man LWP::Simple nicht mehr.
• Du hast nicht bedacht, dass in Strings, welche durch " begrenzt werden, Variablen interpoliert werden können. Wenn jemand das Programm übernimmt, den String ändert und ein Sigil $@% einfügt, und versäumt, es zu maskieren, gibt's unerwartete Ergebnisse. Deshalb, defensiv programmieren und standardmäßig ' bzw. q zur Begrenzung verwenden.
• Scope einschränken. Definiere nicht einfach alles zu Anfang, was du benötigst. So ist es schlecht nachvollziehbar, wann welche Variable tatsächlich benutzt wird. Definiere Variablen immer erst kurz bevor du sie brauchst. Hilfsvariablen sollen immer temporär sein und ihre Gültigkeit verlieren, wenn sie ihren Dienst verrichtet haben. Man kann dazu nackte Blöcke {}; einsetzen.
• URIs können Großbuchstaben haben! Hier darf lc nicht eingesetzt werden.
• Ich hab nach 20 Variablendeklarationen aufgehört, zu zählen. Für ein 100-Zeilenprogramm ist das viel zu viel. Die Benennung ist größtenteils undurchsichtig und somit unbrauchbar fürs Verständnis.
• Einige Variablen ändern sich nie. Benutze richtige Konstanten.
• Die Arraydatenstrukturen haben doppelte Zwecke; man kann es deutlich in der Quelle sehen, dass sie für Verschiedenes benötigt werden. Trenne Daten nach Zweck.
• Dein Programm hat keine Kommentare. Du musst aufschreiben, was die vielen Regex und Bedingungen auf anschaulicher Ebene bewirken. Jetzt ist es sehr zeitaufwändig, es nachzuvollziehen.
• s/\/+$//g; Schiefezahnstochersyndrom. Wenn du ein / innerhalb eines Regex benötigst, nimm einfach andere begrenzer! s|/+$||g;
• Du setzt beinahe überall den Modifier g in Regex ein, wo er keinen Sinn ergibt. Bitte nochmal in perlretut nachlesen.
• Du musst noch mal die Doku von LWP aufmerksam lesen. Stell dir vor, der Server liefert eine Fehlermeldung und diese ist für gewöhnlich in HTML; somit ist die URI zwar erreichbar, aber nur, was eine Maschine darunter versteht, nicht ein Mensch. Das kann durch Falscheingabe der URI erfolgt sein oder kann durch ganz andere Umstände außerhalb deines Einflusses. Deine absicht war wohl, zu prüfen, ob der URI auch erfolgreich erreichbar ist, dafür gibt es die Methode is_success.
• Einzelbedingungen schreibt man idiomatischer mit nachfolgendem statement modifier. $ziel = "Ist leer" unless $ziel;
• Lerne, wann man runde Klammern braucht (Bedingungen, Vorranggruppierung, Listenkontext/-erzeugung, Methodenaufrufe) und wann nicht (prozedurale Aufrufe).
• Lerne, wozu Schleifen nützlich sind. Diese verketteten Bedingungen werden sehr schnell sehr unhandlich.
• $ziel und $bild werden unnötigerweise zweimal geholt.
• Mache die Stringverkettung lieber explizit: $ausgabe .= 'angehängtes';
• goto verleitet zu Spagettiprogrammierung. Es gibt viele andere Kontrollstrukturen, die allesamt besser geeignet sind. Siehe perlsyn.
• Wozu die Prüfung auf Endungen? Ressourcen im Web sind keine Dateien, und brauchen keine Endungen zu haben. Die Endungen sind nicht ausschlaggebend für den Typ, also ist ein Test darauf sinnlos. Das ist auch der grund, weshalb die Regex $pb =~ s/(.•)\.//g; fehlerhaft ist. Aus http://www.w3.org/Icons/valid-xhtml10 macht sie org/Icons/valid-xhtml10.
• ($size < $isize) && ($size ne 0)
Da hast du hast negative Zahlen nicht bedacht. $size kann hier zwar nie negativ sein, aber übernehme nicht diese Ausdrucksweise aus Gewohnheit nicht für andere Programme. Der mathematische Ausdruck 0 < $size < $isize heißt in perl5 (0 < $size) && ($size < $isize). (In perl6 ist das bequemer.)
• Wozu eigentlich diese seltsame Trennung von $ziel und $bild? Ressource ist Ressource im Web. Das lässt sich prima generalisieren.
• Ich greife noch mal zusammengestückelte Erzeugung von HTML auf. Da du das Grundprinzip von Vorlagen schon intuitiv erfasst hast, nämlich Daten sammeln und am Ende in einem Rutsch ausgeben, sollte es dir nicht schwerfallen, den gedanklich kleinen Sprung zu machen und auf ein richtiges Templatesystem umzusatteln. Das lohnt sich ab zwei Seiten, und hier ist nur eine, aber ich weigere mich, HTML auf eine niederere Art und Weise zu erzeugen. Ich nehme Text::Template, das ist supereinfach zu lernen und doch so mächtig, dass du für lange Zeit kein anderes brauchst.

So, das war's im Detail. Hier geht ausnahmsweise ein Neuschreiben schneller als schrittweises Refactoring. So würde ich es machen:

  
#!/usr/bin/perl -T  
use v5.8; # für Readonly  
use utf8; # wegen eingebettetem HTML  
use strict;  
use diagnostics;  
  
use CGI qw(); # kein Funktionsimport, nur OOP-Methoden verwendet  
use Image::Size qw(imgsize);  
use LWP::UserAgent qw(); # nur OOP  
use Readonly;  
use Text::Template qw();  
  
# --  
  
my $uri = 'http://www.w3.org/Icons/valid-xhtml10';  
  
Readonly my @ALLOWEDT => qw(text/html text/plain text/xml application/xml application/xhtml);  
Readonly my @ALLOWEDI => qw(image/png image/jpeg image/gif);  
  
Readonly my $SIZEX => 320; # muss exakte größe passen  
Readonly my $SIZEY => 240;  
Readonly my $MAXSIZE => 10241, # muss kleiner als das sein  
  
my %t; # Templatevariablen  
  
# --  
  
my $response = LWP::UserAgent->new->get($uri);  
$t{'code'} = $response->code; # HTTP status code  
$t{'msg'} = $response->message; # HTTP status message  
  
if ($response->is_success) {  
    $t{'ct'} = $response->header('Content-Type');  
    if (scalar grep {$t{'ct'} =~ /^$_/} @ALLOWEDT) {  
        $t{'r'} = 'Der Server lieferte die gewünschte Ressource fehlerfrei. Der Typ ist akzeptiert.';  
    } elsif (scalar grep {$t{'ct'} =~ /^$_/} @ALLOWEDI) {  
        my $img = $response->content;  
        my ($x, $y) = imgsize \$img;  
        $t{'x'} = $x;  
        $t{'y'} = $y;  
        $t{'size'} = length $img;  
        if ($x == $SIZEX and $y == $SIZEY and length $img < $MAXSIZE) {  
            $t{'r'} = 'Der Server lieferte die gewünschte Ressource fehlerfrei. Es handelt sich um ein akzeptiertes Bild.';  
        } else {  
            $t{'r'} = 'Der Server lieferte die gewünschte Ressource fehlerfrei. Es ist zwar ein Bild, aber wird nicht akzeptiert.';  
        };  
    } else {  
        $t{'r'} = 'Der Server lieferte die gewünschte Ressource fehlerfrei, aber sie hat keinen akzeptierten Typ.';  
    };  
} else {  
    $t{'r'} = 'Der Server lieferte eine Fehlermeldung oder ist nicht erreichbar.';  
};  
  
# --  
  
my $q = CGI->new;  
print $q->header('text/html;charset=utf-8');  
my $template = Text::Template->new(TYPE => 'STRING', DELIMITERS => ['<%', '%>'], SOURCE => <<'');  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">  
<html><head><title>Ergebnis</title></head><body>  
<ul>  
    <li>Status: <% $code %></li>  
    <li>Statusbotschaft: <% $msg %></li>  
    <% $OUT .= "<li>Typ: $ct</li>" if defined $ct %>  
    <%  
        if (defined $size) {  
            $kb = sprintf '%.3f', $size / 1024;  
        $OUT .= qq{  
            <li>Breite: ${x}px</li>  
            <li>Höhe: ${y}px</li>  
            <li>Größe: $size Byte, $kb Kilobyte</li>  
        }}  
    %>  
</ul>  
<p><% $r %></p>  
</body></html>  
  
print $template->fill_in(HASH => \%t);  

Der Programmfluss lässt sich supereinfach lesen, es sind nur Verschachtelungen, keine Sprünge. Schau mal, wie ich die Datenstrukturen kommentiert habe, das macht eine Kommentierung des Algorithmus beinahe überflüssig. Deine Hausaufgabe: Passe die Fehlermeldung so an, dass der Nutzer weiß, aus welchem Grund das Bild nicht akzeptiert ist!

[Gustl]

Hey, Danke schön, Du hast Dir ja richtig Arbeit gemacht und ich werd mit Sicherheit einiges draus lernen können. Allerdings gibts da vieles, was ich nicht verstehe, mit Sicherheit zu viel für diesen Thread.

Leider kann ich Dein Script nicht testen, ich brings nicht zum laufen :(

Die Unterteilung in uri und bild hat den Grund, dass es auch 2 unterschiedliche uri´s sind bzw. schon nach http:// sein könnten.

Deshalb die Frage: Wenn die uri ohne dateiname angegeben wird, also einfach nur http://www.selfhtml.de ist if_success dann true ? Falls ja stehe ich wieder vor dem Haupt-Problem dass user explizit in uri1 seine html-Datei angeben MUSS und in uri2 seine bild-datei.

Bei mir war es so, deshalb ja erst die Testerei mit den Endungen. Die Typ-Prüfung alleine reichte nicht, zumindest nicht mit head $uri, das findet im pfad nur irgendwas was auf den typ passt und ist dann true.

Wie kann ich nur sicherstellen dass der user mir die namen der Dateien angibt ohne die Endungen zu prüfen ? Das war irgendwie das Hauptproblem des ganzen. Es nützt mir ja nix, wenn ich später eine dieser ganz bestimmten dateien finden muss.

$pb =~ s/(.•)\.//g; Bei mir liefert diese Anweisung alles hinter dem letzten punkt. An http://www.w3.org/Icons/valid-xhtml10 wird bei mir definitiv kein Punkt angehängt.

lc: Ja daran hab ich nicht gedacht weil ich immer alles klein schreibe. Das würde zu Verwirrungen bei user führen, muss ich anders machen.

Also Dein Statement im ganzen ist super-lang, ich werd einfach mal vieles davon ausprobieren und es mir des öfteren vornehmen, ist aber am Sonntag nicht Zeit zu.

Grüsse Gustl

[Siechfred]

Cargokultprogrammierung

Das lese ich schon zum zweiten Mal von dir. Was verstehst du darunter?

Siechfred

[迪拉斯]

http://google.com/search?q=mother+roast+cut+%2Boff+ends
http://en.wikipedia.org/wiki/Cargo_cult_(disambiguation)

[Siechfred]

http://google.com/search?q=mother+roast+cut+%2Boff+ends

???

http://en.wikipedia.org/wiki/Cargo_cult_(disambiguation)

Du warst auch schon mal geistreicher, aber trotzdem danke für den Link.

Siechfred