Upload mudando a extensão dos arquivos

[luiscarlos5046 3]

Olá Galera,
Estou fazendo umas alterações num site que outro programador k-gão fez e não arrumou até hoje.

Ele fez um sistema de upload de arquivos para PDF, XML, DOC ou ZIP... Só que nos arquivos ZIP o sistema troca a extensão para VND...
e os DOC faz upload normal tbm mas coloca extensão .octet

 

Alguém já passou por isso?
Deve ser algum bug da programação mau feita ?

[William Bruno 1501]

Depende do código cara.

 

Acha a função move_uploaded_file() e veja o que ela faz.

[luiscarlos5046 3]

Olá Willian!

Não consegui descobrir não. Segue minha classe de Upload pra analise.

 

 

<?php

/*
 * jQuery File Upload Plugin PHP Example 5.5
 * https://github.com/blueimp/jQuery-File-Upload
 *
 * Copyright 2010, Sebastian Tschan
 * https://blueimp.net
 *
 * Licensed under the MIT license:
 * http://www.opensource.org/licenses/MIT
 */

class UploadHandler {

    private $options;

    function __construct($options = null) {
        $this->options = array(
            'script_url' => $this->get_full_url() . '/',
            'upload_dir' => dirname(__FILE__) . '/files/',
            'upload_url' => $this->get_full_url() . '/files/',
            'param_name' => 'files',
            // The php.ini settings upload_max_filesize and post_max_size
            // take precedence over the following max_file_size setting:
            'max_file_size' => null,
            'min_file_size' => 1,
            'accept_file_types' => '/.+$/i',
            'max_number_of_files' => null,
            // Set the following option to false to enable non-multipart uploads:
            'discard_aborted_uploads' => true,
            // Set to true to rotate images based on EXIF meta data, if available:
            'orient_image' => false,
            'image_versions' => array(
                // Uncomment the following version to restrict the size of
                // uploaded images. You can also add additional versions with
                // their own upload directories:
                'large' => array(
                    'upload_dir' => dirname(__FILE__) . '/files/',
                    'upload_url' => dirname($_SERVER['PHP_SELF']) . '/files/',
                    'max_width' => 1920,
                    'max_height' => 1200
                ),
                'thumbnail' => array(
                    'upload_dir' => dirname(__FILE__) . '/thumb/',
                    'upload_url' => $this->get_full_url() . '/thumb/',
                    'width' => 80,
                    'height' => 80
                )
            )
        );
        if ($options)
            $this->options = array_merge($this->options, $options);
    }

    function get_full_url() {
        return (isset($_SERVER['HTTPS']) ? 'https://' : 'http://') . (isset($_SERVER['REMOTE_USER']) ? $_SERVER['REMOTE_USER'] . '@' : '') . (isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : ($_SERVER['SERVER_NAME'] . (isset($_SERVER['HTTPS']) && $_SERVER['SERVER_PORT'] === 443 || $_SERVER['SERVER_PORT'] === 80 ? '' : ':' . $_SERVER['SERVER_PORT']))) . substr($_SERVER['SCRIPT_NAME'], 0, strrpos($_SERVER['SCRIPT_NAME'], '/'));
    }

    private function get_file_object($file_name) {
        $file_path = $this->options['upload_dir'] . $file_name;
        if (is_file($file_path) && $file_name[0] !== '.') {
            $file = new stdClass();
            $file->name = $file_name;
            $file->size = filesize($file_path);
            $file->url = $this->options['upload_url'] . rawurlencode($file->name);
            foreach ($this->options['image_versions'] as $version => $options) {
                if (is_file($options['upload_dir'] . $file_name))
                    $file->{$version . '_url'} = $options['upload_url'] . rawurlencode($file->name);
            }
            $file->delete_url = $this->options['script_url'] . '?file=' . rawurlencode($file->name);
            $file->delete_type = 'DELETE';
            return $file;
        }
        return null;
    }

    private function get_file_objects() {
        return array_values(array_filter(array_map(array($this, 'get_file_object'), scandir($this->options['upload_dir']))));
    }

    private function create_scaled_image($file_name, $options) {
        $file_path = $this->options['upload_dir'] . $file_name;
        $new_file_path = $options['upload_dir'] . $file_name;
        list($img_width, $img_height) = @getimagesize($file_path);
        if (!$img_width || !$img_height)
            return false;
        $scale = max(
            $options['width'] / $img_width,
            $options['height'] / $img_height
        );
        if ($options['width']) {
            $new_width = $img_width * $scale;
            $new_x = ($new_width > $options['width']) ? $new_width - $options['width'] : 0;
        }
        elseif ($options['max_width']) {
            $new_x = 0;
            if ($scale < 1)
                $scale = 1;
            if ($img_width * $scale > $options['max_width'])
                $new_width = $options['max_width'];
            else
                $new_width = $img_width * $scale;
        }
        if ($options['height']) {
            $new_height = $img_height * $scale;
            $new_y = ($new_height > $options['height']) ? $new_height - $options['height'] : 0;
        }
        elseif ($options['max_height']) {
            $new_y = 0;
            if ($scale < 1)
                $scale = 1;
            if ($img_height * $scale > $options['max_height'])
                $new_height = $options['max_height'];
            else
                $new_height = $img_height * $scale;
        }

        if ($options['max_width'] || $options['max_height']) {
                $scale = min(
                    $new_width / $img_width,
                    $new_height / $img_height
                );
            $new_width = $img_width * $scale;
            $new_height = $img_height * $scale;
        }
        $new_img = @imagecreatetruecolor($new_width - $new_x, $new_height - $new_y);
        switch (strtolower(substr(strrchr($file_name, '.'), 1))) {
            case 'jpg':
            case 'jpeg':
                $src_img = @imagecreatefromjpeg($file_path);
                $write_image = 'imagejpeg';
                if ($options['quality'])
                    $quality = $options['quality'];
                else
                    $quality = 75;
                break;
            case 'gif':
                @imagecolortransparent($new_img, @imagecolorallocate($new_img, 0, 0, 0));
                $src_img = @imagecreatefromgif($file_path);
                $write_image = 'imagegif';
                break;
            case 'png':
                @imagecolortransparent($new_img, @imagecolorallocate($new_img, 0, 0, 0));
                @imagealphablending($new_img, false);
                @imagesavealpha($new_img, true);
                $src_img = @imagecreatefrompng($file_path);
                $write_image = 'imagepng';
                break;
            default:
                $src_img = $image_method = null;
        }
        $success = $src_img && @imagecopyresampled(
            $new_img,
            $src_img,
            0 - $new_x / 2,
            0 - $new_y / 2,
            0, 0,
            $new_width,
            $new_height,
            $img_width,
            $img_height
        );
        if ($options['logo']) {
            $logo_img = @imagecreatefrompng($options['logo']);
            $success = $success && @imagecopy(
                $new_img,
                $logo_img,
                5,
                $height - $logo_height - 5,
                0, 0,
                imagesx($logo_img),
                imagesy($logo_img)
            );
        }
        $success = $success && $write_image($new_img, $new_file_path, $quality);
        if ($options['logo'])
            @imagedestroy($logo_img);
        @imagedestroy($src_img);
        @imagedestroy($new_img);
        return $success;
    }

    private function has_error($uploaded_file, $file, $error) {
        if ($error)
            return $error;
        if (!preg_match($this->options['accept_file_types'], $file->name))
            return 'acceptFileTypes';
        if ($uploaded_file && is_uploaded_file($uploaded_file))
            $file_size = filesize($uploaded_file);
        else
            $file_size = $_SERVER['CONTENT_LENGTH'];
        if ($this->options['max_file_size'] && ($file_size > $this->options['max_file_size'] || $file->size > $this->options['max_file_size']))
            return 'maxFileSize';
        if ($this->options['min_file_size'] && $file_size < $this->options['min_file_size'])
            return 'minFileSize';
        if (is_int($this->options['max_number_of_files']) && (count($this->get_file_objects()) >= $this->options['max_number_of_files']))
            return 'maxNumberOfFiles';
        return $error;
    }

    private function trim_file_name($name, $type) {
        // Remove path information and dots around the filename, to prevent uploading
        // into different directories or replacing hidden system files.
        // Also remove control characters and spaces (\x00..\x20) around the filename:
        $file_name = trim(basename(stripslashes($name)), ".\x00..\x20");
        $mime_types = array(
            'txt' => 'text/plain',
            'html' => 'text/html',
            'css' => 'text/css',
            'js' => 'application/javascript',
            'json' => 'application/json',
            'xml' => 'application/xml',
            'swf' => 'application/x-shockwave-flash',
            'flv' => 'video/x-flv',
            'png' => 'image/png',
            'jpg' => 'image/jpeg',
            'gif' => 'image/gif',
            'bmp' => 'image/bmp',
            'ico' => 'image/vnd.microsoft.icon',
            'tif' => 'image/tiff',
            'svg' => 'image/svg+xml',
            'zip' => 'application/zip',
            'rar' => 'application/x-rar',
            'exe' => 'application/x-msdownload',
            'msi' => 'application/x-msdownload',
            'cab' => 'application/vnd.ms-cab-compressed',
            'mp3' => 'audio/mpeg',
            'mov' => 'video/quicktime',
            'pdf' => 'application/pdf',
            'psd' => 'image/vnd.adobe.photoshop',
            'eps' => 'application/postscript',
            'ps' => 'application/postscript',
            'doc' => 'application/msword',
            'rtf' => 'application/rtf',
            'xls' => 'application/vnd.ms-excel',
            'ppt' => 'application/vnd.ms-powerpoint',
            'odt' => 'application/vnd.oasis.opendocument.text',
            'ods' => 'application/vnd.oasis.opendocument.spreadsheet'
        );
        // Add missing file extension for known image types:
        if (strpos($file_name, '.') === false) {
            if (in_array($type, $mime_types)) {
                $array = array_keys($mime_types, $type);
                $extension = $array[0];
            }
            elseif (preg_match('/^[a-z]+\/([a-z]+)/', $type, $matches))
                $extension = $matches[1];
            if (isset($extension))
                $file_name .= '.' . $extension;
        }
        return $file_name;
    }

    private function orient_image($file_path) {
        $exif = exif_read_data($file_path);
        $orientation = intval(@$exif['Orientation']);
        if (!in_array($orientation, array(3, 6, 8)))
            return false;
        $image = @imagecreatefromjpeg($file_path);
        switch ($orientation) {
            case 3:
                $image = @imagerotate($image, 180, 0);
                break;
            case 6:
                $image = @imagerotate($image, 270, 0);
                break;
            case 8:
                $image = @imagerotate($image, 90, 0);
                break;
            default:
                return false;
        }
        $success = imagejpeg($image, $file_path);
        @imagedestroy($image);
        return $success;
    }

    private function handle_file_upload($uploaded_file, $name, $size, $type, $error) {
        $file = new stdClass();
        $file->name = $this->trim_file_name($name, $type);
        $file->size = intval($size);
        $file->type = $type;
        $error = $this->has_error($uploaded_file, $file, $error);
        if (!$error && $file->name) {
            $file_path = $this->options['upload_dir'] . $file->name;
            $append_file = !$this->options['discard_aborted_uploads'] && is_file($file_path) && $file->size > filesize($file_path);
            clearstatcache();
            if ($uploaded_file && is_uploaded_file($uploaded_file)) {
                if ($append_file)
                    file_put_contents($file_path, fopen($uploaded_file, 'r'), FILE_APPEND);
                else {
                    if (!file_exists($this->options['upload_dir']))
                        mkdir($this->options['upload_dir'], 0777, true);
                    move_uploaded_file($uploaded_file, $file_path);
                }
            }
            else
                file_put_contents($file_path, fopen('php://input', 'r'), $append_file ? FILE_APPEND : 0);
            $file_size = filesize($file_path);
            if ($file_size === $file->size) {
                if ($this->options['orient_image'])
                    $this->orient_image($file_path);
                $file->url = $this->options['upload_url'] . rawurlencode($file->name);
                foreach ($this->options['image_versions'] as $version => $options) {
                    if (!file_exists($options['upload_dir']))
                        mkdir($options['upload_dir'], 0777, true);
                    if ($this->create_scaled_image($file->name, $options))
                        $file->{$version . '_url'} = $options['upload_url'] . rawurlencode($file->name);
                }
            }
            else if ($this->options['discard_aborted_uploads']) {
                unlink($file_path);
                $file->error = 'abort';
            }
            $file->size = $file_size;
            $file->delete_url = $this->options['script_url'] . '?file=' . rawurlencode($file->name);
            $file->delete_type = 'DELETE';
        }
        else
            $file->error = $error;
        return $file;
    }

    public function get() {
        $file_name = isset($_REQUEST['file']) ? basename(stripslashes($_REQUEST['file'])) : null;
        if ($file_name)
            $info = $this->get_file_object($file_name);
        else
            $info = $this->get_file_objects();
        header('Content-type: application/json');
        echo json_encode($info);
    }

    public function post() {
        if (isset($_REQUEST['_method']) && $_REQUEST['_method'] === 'DELETE')
            return $this->delete();
        $upload = isset($_FILES[$this->options['param_name']]) ? $_FILES[$this->options['param_name']] : null;
        $info = array();
        if ($upload && is_array($upload['tmp_name'])) {
            foreach ($upload['tmp_name'] as $index => $value) {
                $info[] = $this->handle_file_upload(
                    $upload['tmp_name'][$index],
                    md5(uniqid(time())),
                    isset($_SERVER['HTTP_X_FILE_SIZE']) ? $_SERVER['HTTP_X_FILE_SIZE'] : $upload['size'][$index],
                    isset($_SERVER['HTTP_X_FILE_TYPE']) ? $_SERVER['HTTP_X_FILE_TYPE'] : $upload['type'][$index],
                    $upload['error'][$index]
                );
            }
        }
        elseif ($upload || isset($_SERVER['HTTP_X_FILE_NAME'])) {
            $info[] = $this->handle_file_upload(
                isset($upload['tmp_name']) ? $upload['tmp_name'] : null,
                isset($_SERVER['HTTP_X_FILE_NAME']) ? md5(uniqid(time())) : (isset($upload['name']) ? md5(uniqid(time())) : null),
                isset($_SERVER['HTTP_X_FILE_SIZE']) ? $_SERVER['HTTP_X_FILE_SIZE'] : (isset($upload['size']) ? isset($upload['size']) : null),
                isset($_SERVER['HTTP_X_FILE_TYPE']) ? $_SERVER['HTTP_X_FILE_TYPE'] : (isset($upload['type']) ? isset($upload['type']) : null),
                isset($upload['error']) ? $upload['error'] : null
            );
        }
        header('Vary: Accept');
        $json = json_encode($info);
        $redirect = isset($_REQUEST['redirect']) ? stripslashes($_REQUEST['redirect']) : null;
        if ($redirect) {
            header('Location: ' . sprintf($redirect, rawurlencode($json)));
            return;
        }
        if (isset($_SERVER['HTTP_ACCEPT']) && (strpos($_SERVER['HTTP_ACCEPT'], 'application/json') !== false))
            header('Content-type: application/json');
        else
            header('Content-type: text/plain');
        echo $json;
        return $info;
    }

    public function delete() {
        $file_name = isset($_REQUEST['file']) ? basename(stripslashes($_REQUEST['file'])) : null;
        $file_path = $this->options['upload_dir'] . $file_name;
        $success = is_file($file_path) && $file_name[0] !== '.' && unlink($file_path);
        if ($success) {
            foreach ($this->options['image_versions'] as $version => $options) {
                $file = $options['upload_dir'] . $file_name;
                if (is_file($file))
                    unlink($file);
            }
        }
        header('Content-type: application/json');
        echo json_encode($success);
        return $success;
    }

}

[William Bruno 1501]

move_uploaded_file($uploaded_file, $file_path);

ok? é nessa linha em que o arquivo é escrito. Deste método:

handle_file_upload($uploaded_file, $name, $size, $type, $error) {

E o método que tem essa função, é chamado aqui:

            foreach ($upload['tmp_name'] as $index => $value) {
                $info[] = $this->handle_file_upload(
                    $upload['tmp_name'][$index],
                    md5(uniqid(time())),
                    isset($_SERVER['HTTP_X_FILE_SIZE']) ? $_SERVER['HTTP_X_FILE_SIZE'] : $upload['size'][$index],
                    isset($_SERVER['HTTP_X_FILE_TYPE']) ? $_SERVER['HTTP_X_FILE_TYPE'] : $upload['type'][$index],
                    $upload['error'][$index]
                );
            }

Então por enquanto o valor de $name é: md5(uniqid(time()))

Essa variavel $name sofre uma transformação aqui:

 

$file->name = $this->trim_file_name($name, $type);

Vamos olhar a função trim_file_name então:

        $mime_types = array(
            'txt' => 'text/plain',
            'html' => 'text/html',
            'css' => 'text/css',
            'js' => 'application/javascript',
            'json' => 'application/json',
            'xml' => 'application/xml',
            'swf' => 'application/x-shockwave-flash',
            'flv' => 'video/x-flv',
            'png' => 'image/png',
            'jpg' => 'image/jpeg',
            'gif' => 'image/gif',
            'bmp' => 'image/bmp',
            'ico' => 'image/vnd.microsoft.icon',
            'tif' => 'image/tiff',
            'svg' => 'image/svg+xml',
            'zip' => 'application/zip',
            'rar' => 'application/x-rar',
            'exe' => 'application/x-msdownload',
            'msi' => 'application/x-msdownload',
            'cab' => 'application/vnd.ms-cab-compressed',
            'mp3' => 'audio/mpeg',
            'mov' => 'video/quicktime',
            'pdf' => 'application/pdf',
            'psd' => 'image/vnd.adobe.photoshop',
            'eps' => 'application/postscript',
            'ps' => 'application/postscript',
            'doc' => 'application/msword',
            'rtf' => 'application/rtf',
            'xls' => 'application/vnd.ms-excel',
            'ppt' => 'application/vnd.ms-powerpoint',
            'odt' => 'application/vnd.oasis.opendocument.text',
            'ods' => 'application/vnd.oasis.opendocument.spreadsheet'
        );

ela possui esse array "de -> para" (dicionário de dados) para tentar descobrir a extensão ideal apartir do mimetype do arquivo.

 

No caso, você informou que quando envia um arquivo .zip a extensão gravada é vnd?

tem certeza? não existe vnd como opção desse dicionário.

 

Debugue a função trim_file_name, pois como ela que é a responsável pela "transformação" da variável $name, se há algum bug, está nela.

 

Lembrando que o valor do parâmetro $type vem deste ternário:

isset($_SERVER['HTTP_X_FILE_TYPE']) ? $_SERVER['HTTP_X_FILE_TYPE'] : $upload['type'][$index]

Que diz: se existir um cabeçalho HTTP_X_FILE_TYPE, use ele, se não, use o 'type' do array com index do foreach().