das kann ich nun nicht nachvollziehen... Ich denke eher, dass es etwas mit den Einstellungen in der upload.class.php zu tun hat oder so ähnlich... Ich habe nämlich momentan dasselbe Problem und habe da mal ein bisschen (leider erfolglos) in der entsprechenden Datei rumgefummelt. Da wird nämlich festgelegt, welche Dateitypen zugelassen sind und welche nicht...
************************************/
/**
* @version $Id: upload.class.php,v 1.5 2005/11/22 12:02:02 bowlingx Exp $ *
* @copyright 2005 David Heidrich, MYSELF Internet Lösungen *
*
*/
// Idea from php.net, modified for use by David Heidrich
class FileSearcher {
var $FileList = Array();
var $OrdnerList = Array();
var $counter_ordner = 0;
// TODO: Wird später per Parameter übergeben
var $fileTypes = Array("png","jpg","gif","jpeg");
function go ($dir) {
$dirList[] = $dir;
while ( ($currDir = array_pop($dirList)) !== NULL ) {
$dir = opendir($currDir);
while((false!==($file=readdir($dir)))) {
if($file =="." || $file == "..") {
continue;
}
$fullName = $currDir . "" . $file;
if ( is_dir ( $fullName ) ) {
array_push ( $dirList, $fullName );
continue;
}
$pattern = explode(".","$file");
if(isset($pattern[1])){
if(in_array($pattern[1],$this->fileTypes)){
$this->FileList[$this->counter_ordner][] = $file;
}
}
$this->OrdnerList[$this->counter_ordner] = $currDir;
}
closedir($dir);
$this->counter_ordner++;
}
}
function processFile ( $file, $dir ) {
echo "$file, $dir<br>";
}
}
// Class Thumbnail from the Book "PHP 2h after Work"
// Added a few more functions (true color images; searching for a gif compatible gd libary before creating)
// http://www.sybex.de
class Thumbnail {
// Original Thumbnail
var $path_org = "";
// Ziel Thumbnail
var $path_thumb = "";
// Breite des Thumbs
var $width = "";
// Höhe des Thumbs
var $height = "";
// Image Typ
var $thumb_type;
var $createall = false;
var $imgtypes;
var $error;
var $server_error = false;
function Thumbnail()
{
$this->imgtypes = imagetypes();
}
// Berechnung der Höhe, Breite des Thumbnails
function calcSize($org_width, $org_height)
{
$div_width = $org_width / $this->width;
$div_height = $org_height / $this->height;
if ($div_width >= $div_height) {
$new_width = $this->width;
$new_height = round($org_height / $div_width);
} else {
$new_height = $this->height;
$new_width = round($org_width / $div_height);
}
return array($new_width, $new_height);
}
// Error Funktion:
function setError($level, $msg)
{
unset($this->error);
$this->error = array('level' => $level, 'msg' => $msg);
}
// Funktion zum erstellen des Thumbnails
function createThumb($imgfile, $org_type, $org_width, $org_height, $thumb_width, $thumb_height)
{
switch ($org_type) {
case 1: $im = imagecreatefromgif($this->path_org . $imgfile);
break;
case 2: $im = imagecreatefromjpeg($this->path_org . $imgfile);
break;
case 3: $im = imagecreatefrompng($this->path_org . $imgfile);
break;
}
if ($im) {
if ($thumb = imagecreatetruecolor($thumb_width, $thumb_height)) {
imagecopyresized($thumb, $im, 0, 0, 0, 0, $thumb_width, $thumb_height, $org_width, $org_height);
switch ($this->thumb_type) {
case 1: if (function_exists("imagegif")) {
$saved = imagegif($thumb, $this->path_thumb . $imgfile);
} else {
$this->setError(1, 'This Server <b>doesnt Support</b> creating Gif Files.<br>Please choose another Image Type to Upload!<br><br>Dieser Server unterstützt das erstellen von gif Dateien nicht!<br>Wählen Sie bitte einen anderen Dateityp.<br><br>[ <a href="modules.php?name=Avatar">Back</a> ]');
$this->server_error = true;
imagedestroy($im);
return false;
}
break;
case 2:$saved = imagejpeg($thumb, $this->path_thumb . $imgfile, 100);
break;
case 3:$saved = imagepng($thumb, $this->path_thumb . $imgfile);
break;
default: $this->setError(1, 'Thumbnailformat not Supportet.');
imagedestroy($im);
return false;
}
imagedestroy($im);
imagedestroy($thumb);
if (!$saved) {
$this->setError(1, 'Cannot Save Thumbnail!');
$this->server_error = true;
return false;
} else {
return true;
}
} else {
$this->setError(1, 'Cannot create Thumbnail');
$this->server_error = true;
imagedestroy($im);
return false;
}
} else {
$this->setError(1, 'Cannot Read Picture');
$this->server_error = true;
return false;
}
}
// Thumbnail speichern
function getThumb($filename)
{
$imgfile = basename($filename);
// Prüfen ob der TEMP Ordner existiert und beschreibbar ist:
if(file_exists($this->path_thumb) && is_writeable($this->path_thumb)){
if (file_exists($this->path_org . $imgfile) && (strlen($imgfile) > 0)) {
if (file_exists($this->path_thumb . $imgfile)) {
$this->setError(0, 'Thumbnail exists');
$this->server_error = true;
if (!$this->createall) {
return true;
}
}
list($org_width, $org_height, $org_type) =
getimagesize($this->path_org . $imgfile);
switch ($org_type) {
case 1:
if (!$this->imgtypes && IMG_GIF) {
$this->setError(1, 'Pictureformat GIF not Supported');
$this->server_error = true;
return false;
}
break;
case 2:
if (!$this->imgtypes && IMG_JPG) {
$this->setError(1, 'Pictureformat JPG not Supported');
$this->server_error = true;
return false;
}
break;
case 3:
if (!$this->imgtypes && IMG_PNG) {
$this->setError(1, 'Pictureformat PNG not Supported');
$this->server_error = true;
return false;
}
break;
default: $this->setError(1, 'This Format is not Supportet');
$this->server_error = true;
return false;
}
list($thumb_width, $thumb_height) = $this->calcSize($org_width, $org_height);
if ($this->createThumb($imgfile, $org_type, $org_width, $org_height, $thumb_width, $thumb_height)) {
return true;
}
} else {
$this->setError(1, 'File Not Found (FNF)');
$this->server_error = true;
return false;
}
}
else {
$this->setError(0, 'TEMP not Found');
$this->server_error = true;
return false;
}
}
}
// Class Upload Copyright (c) 2003 by David Heidrich
class Upload {
// Variabeln für die Upload Klasse:
// Ziel Ordner
var $error;
var $dateityp;
// Die Dateitypen
// FOLGENDES ARRAY NICHT ÄNDERN!
var $typs = array('Platzhalter', 'gif', 'jpeg', 'png','png', 'swf');
// Alle erlaubten Image Typen: (Alle erlaubten Dateitypen hier hineinschreiben)
var $imagetyps = array('image/gif', 'image/pjpeg', 'image/jpeg', 'image/png', 'image/x-png');
// Alle Sonst erlaubten Typen: (Alle erlaubten Dateitypen hier hineinschreiben)
var $othertyps = array('NULL');
var $breite;
var $hoehe;
var $indexImage;
var $indexOthertyps;
var $isImage;
var $isText;
var $fileTypes;
var $error_handling = true;
var $prop_error;
var $error_message = array();
var $info;
var $sizeer = 0;
// Wenn eine Datei bereits existiert wird dieses Objekt auf "true" gesetzt!
var $Fileexists;
var $replacements = array('ä' => '_', 'ü' => '_', 'ä' => '_');
// Language Strings:
// Im folgenden array sind alle Meldungen der Upload Klasse gespeichert:
// Sollte die Klasse in eine andere Sprache übersetzt werden können die Sprachkonstanten übermittelt werden!
var $language = array("no_upload_file" => "Keine Datei zum hochladen angegeben.",
"breite_error1" => "Die Proportionen deines Bildes sind <b>zu gross</b>.<br> Die Breite deines Bildes <b>beträgt",
"breite_error2" => "</b>.<br>Erlaubt sind aber nur",
"hoehe_error1" => "Die Proportionen deines Bildes sind <b>zu gross</b>.<br> Die Höhe deines Bildes <b>beträgt",
"hoehe_error2" => "</b>.<br>Erlaubt sind aber nur",
"file_type_error" => "Der von dir hochgeladene Dateityp wird nicht unterstützt!<br>",
"upload_failed" => "Hochladen der Datei Fehlegeschlagen",
"succeed" => "Datei erfolgreich hochgeladen",
"exists" => "Die Datei existiert bereits",
"not_writeable" => "Das Zielverzeichnis/Die Datei ist nicht beschreibar! Bitte benachrichtigen Sie einen Administrator...",
"too_large" => "Die angegebene Datei überschreitet die festgelegte grösse!",
"failure" => "<b>Fehler:</b>",
"information" => "<b>Information:</b>");
function UploadStringReplace($string)
{
return(strtr($string, $this->replacements));
}
// Diese Funktion ermittelt den Dateityp der Datei und gibt ihn aus:
// GEHT NUR BEI BILDERN!
function UploadImageReturnFileTyp($file)
{
// Dateityp ermitteln:
$index = getimagesize($file);
$this->dateityp = $this->typs[$index['2']];
// Ausgabe des Dateityps bzw. False falls es kein Bild sein sollte:
return (!empty($this->dateityp))? $this->dateityp : false;
}
function UploadImageReturnFileTypByInt($file)
{
// Dateityp ermitteln:
$index = getimagesize($file);
// Ausgabe des Dateityps bzw. False falls es kein Bild sein sollte:
return (!empty($index[2]))? $index[2] : false;
}
function UploadReturnBreite($file)
{
$index_breite = getimagesize($file);
return $index_breite[0];
}
function UploadReturnHoehe($file)
{
$index_hoehe = getimagesize($file);
return $index_hoehe[1];
}
// Methode um zu prüfen ob ein Bild vorliegt oder nicht:
function validateImageType($fupload_type)
{
foreach($this->imagetyps as $ausgabe) {
$this->indexImage = $this->indexImage + 1;
}
$ii = 0;
do {
if ($fupload_type == @$this->imagetyps["$ii"]) {
// Der Variable Dateityp den ermittelten Dateityp zuweisen:
// Aber NUR wenn $fupload_type den verfügbaren entspricht...
$this->fileTypes = $this->imagetyps["$ii"];
$this->isImage = true;
}
$ii++;
} while ($ii < $this->indexImage);
return (!empty($this->fileTypes))? $this->fileTypes : false;
}
// Folgende Funktion gibt entweder false oder den Typ der Datei zurück!
function validateOtherTyps($fupload_type)
{
foreach($this->othertyps as $ausgabe) {
$this->indexOthertyps = $this->indexOthertyps + 1;
}
$ii2 = 0;
do {
if ($fupload_type == $this->othertyps["$ii2"]) {
// Der Variable Dateityp den ermittelten Dateityp zuweisen:
// Aber NUR wenn $fupload_type den verfügbaren entspricht...
$this->fileTypes = $this->othertyps["$ii2"];
$this->isImage = false;
}
$ii2++;
} while ($ii2 < $this->indexOthertyps);
return (!empty($this->fileTypes))? $this->fileTypes : false;
}
// Methode zum löschen einer Datei:
function DeleteUploadedFile($file)
{
if (is_writeable($file)) {
// Datei löschen:
unlink($file);
} else {
$this->display_error($this->language['not_writeable']);
$this->error = true;
return false;
}
}
// Funktion zum hochladen einer Datei:
function UploadFile($filename, $targetdir, $fupload, $fupload_size, $maxsize, $fupload_type, $breite, $hoehe)
{
// Überprüfen ob die Datei kleiner bzw. gleichgross wie die festgelegte Grösse ist!
if (empty($fupload)) {
$this->display_error($this->language['no_upload_file']);
$this->error = true;
return false;
}
if ($fupload_size <= $maxsize) {
// Prüfen ob die Datei ein Bild ist und wenn ja Bild prüfen lassen...
// Sollte kein Bild vorliegen wird die else klausel ausgeführt!
if ($this->validateImageType($fupload_type)) {
// Zweite Prüfung (sollte MimeType "verarscht" worden sein):
if (!$this->UploadImageReturnFileTyp($fupload)) {
unset($this->fileTypes);
$this->display_error($this->language['file_type_error']);
$this->error = true;
return false;
}
// "Echte" breite und Höhe ermitteln lassen:
$this->breite = $this->UploadReturnBreite($fupload);
$this->hoehe = $this->UploadReturnHoehe($fupload);
// Fehlerausgeben wenn die Proportionen überschritten werden:
if ($this->breite > $breite) {
if ($this->sizeer) {
$this->prop_error = true;
} else {
$this->display_error($this->language['breite_error1'] . " " . $this->breite . " " . $this->language['breite_error2'] . "<b>$breite</b><br><br>");
$this->error = true;
return false;
}
} elseif ($this->hoehe > $hoehe) {
if ($this->sizeer) {
$this->prop_error = true;
} else {
$this->display_error($this->language['hoehe_error1'] . " " . $this->hoehe . " " . $this->language['hoehe_error2'] . "<b>$hoehe</b><br><br>");
$this->error = true;
return false;
}
}
} else {
// Auf andere Dateitypen prüfen:
$this->validateOtherTyps($fupload_type);
}
if (empty($this->fileTypes)) {
$this->display_error($this->language['file_type_error'] ." $fupload_type<br><br>");
$this->error = true;
return false;
}
// Überprüfen ob der Ordner beschreibar ist:
if (is_writable($targetdir)) {
// Nur hochladen wenn die Datei noch nicht existiert!
if (!@file_exists("$targetdir/$filename")) {
if (!move_uploaded_file($fupload, "$targetdir/$filename")) {
$this->display_error($this->language['upload_failed']);
$this->error = true;
return false;
} else {
// Nötige Dateirechte geben:
@chmod("$targetdir/$filename", 0644);
$this->error = false;
return true;
}
} else {
$this->display_info($this->language['exists']);
// Wenn die Datei bereits existiert (datei mit gleichem Namen) wird die "Upload Datei" nicht hochgeladen..
$this->Fileexists = true;
return true;
}
} else {
$this->display_error($this->language['not_writeable'] . " ($targetdir)");
$this->error = true;
return false;
}
} else {
$this->display_error($this->language['too_large']);
$this->error = true;
return false;
}
}
function display_error($error)
{
if(!$this->error_handling){
$this->error_message[] = $error;
}
else {
echo "" . $this->language['failure'] . " $error";
}
}
function display_info($info)
{
if(!$this->error_handling){
$this->info[] = $info;
}
else {
echo "" . $this->language['information'] . " $info";
}
}
}
?>
Also kurz und gut, bei mir geht es z. B. um animierte GIF´s, die ich gerne als Avatar angezeigt bekommen möchte. Die Fehlermeldung wurde oben schon beschrieben:
(Datei 1:) This Server doesnt Support creating Gif Files.
Wählen Sie bitte einen anderen Dateityp.
Interessant aber ist folgendes: wenn ich nämlich nun dasselbe Image als Userbild anstatt als Avatar hochlade, funktioniert das einwandfrei, das Bild wird korrekt und animiert dargestellt... Auch größere animierte GIFS werden tatsächlich bei dieser Hochlade-Methode resized bzw. gethumbnailed und korrekt dargestellt...
Also am Server sollte es eigentlich nicht liegen...
pragmaMx Support Forum
