WebSVN – lars-tiefland.ci – Diff – /backend/controllers/UploadHandler.php

+*
 * Licensed under the MIT license:
 * https://opensource.org/licenses/MIT
 */
-if (preg_match("/\.local$/", $_SERVER["SERVER_NAME"]))
 if (preg_match("/\.local$/", $_SERVER["SERVER_NAME"])) {
 	//$GLOBALS["site"] .= ".local";
+}
 $options = null;
 $real_url = getDokDomain();
 $real_url .= "/images/upload/";
 $real_folder = $GLOBALS["webs"]["verzeichnis"] . "/images/upload/";
-$folder = "";
-$GLOBALS["folder"] = "";
+$folder = "";
-if (isset($_POST["folder"]) && $_POST["folder"])
+$GLOBALS["folder"] = "";
-{
-	$folder = Weban_Utils::clean_global_input("folder");
+if (isset($_POST["folder"]) && $_POST["folder"]) {
-} elseif (isset($_GET["folder"]) && $_GET["folder"])
+	$folder = Weban_Utils::clean_global_input("folder");
 } elseif (isset($_GET["folder"]) && $_GET["folder"]) {
 	$folder = Weban_Utils::clean_global_input("folder", "get");
-}
+}
 $bvKonf = "";
-if (isset($GLOBALS["web_rechte"]["admin"]["toolbox"]["bildverwaltung"]))
+$bvKonf = "";
-{
-	$bvKonf = $GLOBALS["web_rechte"]["admin"]["toolbox"]["bildverwaltung"];
+if (isset($GLOBALS["web_rechte"]["admin"]["toolbox"]["bildverwaltung"])) {
 	$bvKonf = $GLOBALS["web_rechte"]["admin"]["toolbox"]["bildverwaltung"];
 if (!$bvKonf)
-{
+if (!$bvKonf) {
-	$bvKonf = "Bild;;651;651";
 	$bvKonf = "Bild;;651;651";
 $GLOBALS["Imagedaten"] = array_chunk(explode(";", $bvKonf), 4);
-if ($folder)
+$GLOBALS["Imagedaten"] = array_chunk(explode(";", $bvKonf), 4);
 if ($folder) {
 	$folder = rtrim($folder, "/");
 	$GLOBALS["folder"] = $folder;
 	$folder .= "/";
 	$real_folder .= $folder;
-	$real_url .= $folder;
-	$options["upload_dir"] = $real_folder;
+	$real_url .= $folder;
-	$options["upload_url"] = $real_url;
+	$options["upload_dir"] = $real_folder;
-	foreach ($GLOBALS["Imagedaten"] as $set)
+	$options["upload_url"] = $real_url;
 	foreach ($GLOBALS["Imagedaten"] as $set) {
 		$options["image_versions"][$set[0]] = array(
 			"upload_dir" => $real_folder . $set[1] . "/",
 			"upload_url" => $real_url . $set[1] . "/",
 			"max_width" => $set[2],
-			"max_height" => $set[3],
-			);
+			"max_height" => $set[3],
 			);
 	if (!file_exists($options["upload_dir"] . "/orig/"))
 	if (!file_exists($options["upload_dir"] . "/orig/")) {
 				'HEAD',
 				'GET',
 				'POST',
 				'PUT',
 				'PATCH',
-				'DELETE'),
+				'DELETE',
+				),
 			'access_control_allow_headers' => array(
 				'Content-Type',
 				'Content-Range',
-				'Content-Disposition'),
+				'Content-Disposition',
+				),
 			// By default, allow redirects to the referer protocol+host:
 			'redirect_allow_target' => '/^' . preg_quote(parse_url($this->get_server_var('HTTP_REFERER'),
 				PHP_URL_SCHEME) . '://' . parse_url($this->get_server_var('HTTP_REFERER'),
 				PHP_URL_HOST) . '/', // Trailing slash to not match subdomains by mistake
 				'/' // preg_quote delimiter param
 			'download_via_php' => false,
 			// Read files in chunks to avoid memory limits when download_via_php
 			// is enabled, set to 0 to disable chunked reading of files:
 			'readfile_chunk_size' => 10 * 1024 * 1024, // 10 MiB
 			// Defines which files can be displayed inline when downloaded:
-			'inline_file_types' => '/\.(gif|jpe?g|png)$/i',
+			'inline_file_types' => '/\.(gif|jpe?g|png|svg)$/i',
 			// Defines which files (based on their names) are accepted for upload:
 			'accept_file_types' => '/.+$/i',
 			// The php.ini settings upload_max_filesize and post_max_size
 			// take precedence over the following max_file_size setting:
 			'max_file_size' => null,
 			'convert_params' => '-limit memory 32MiB -limit map 32MiB',
 			*/
 			// Command or path for to the ImageMagick identify binary:
 			'identify_bin' => 'identify',
 			'print_response' => true);
-		foreach ($GLOBALS["Imagedaten"] as $set)
+		foreach ($GLOBALS["Imagedaten"] as $set) {
-		{
 			$this->options["image_versions"][$set[0]] = array(
 				"upload_dir" => $real_folder . $set[1] . "/",
 				"upload_url" => $real_url . $set[1] . "/",
 				"max_width" => $set[2],
 				"max_height" => $set[3],
 				);
+		}
-		if ($options)
+		if ($options) {
-		{
 			$this->options = $options + $this->options;
+		}
-		if ($error_messages)
+		if ($error_messages) {
-		{
 			$this->error_messages = $error_messages + $this->error_messages;
+		}
-		if ($initialize)
+		if ($initialize) {
-		{
 			$this->initialize();
+		}
+	}
 	protected function initialize()
 	{
-		switch ($this->get_server_var('REQUEST_METHOD'))
 		switch ($this->get_server_var('REQUEST_METHOD')) {
 			case 'OPTIONS':
 			case 'HEAD':
 				$this->head();
 				break;
 		return session_id();
+	}
 	protected function get_user_path()
 	{
-		if ($this->options['user_dirs'])
 		if ($this->options['user_dirs']) {
 			return $this->get_user_id() . '/';
+		}
 		return '';
+	}
 	protected function get_upload_path($file_name = null, $version = null)
 	{
-		$file_name = $file_name ? $file_name : '';
-		if (empty($version))
+		$file_name = $file_name ? $file_name : '';
-		{
+		if (empty($version)) {
-			$version_path = '';
-		} else
+			$version_path = '';
-		{
+		} else {
-			$version_dir = @$this->options['image_versions'][$version]['upload_dir'];
-			if ($version_dir)
+			$version_dir = @$this->options['image_versions'][$version]['upload_dir'];
 			if ($version_dir) {
 				return $version_dir . $this->get_user_path() . $file_name;
+			}
 			$version_path = $version . '/';
 		return strpos($url, '?') === false ? '?' : '&';
+	}
 	protected function get_download_url($file_name, $version = null, $direct = false)
 	{
-		if (!$direct && $this->options['download_via_php'])
 		if (!$direct && $this->options['download_via_php']) {
 			$url = $this->options['script_url'] . $this->get_query_separator($this->options['script_url']) .
 				$this->get_singular_param_name() . '=' . rawurlencode($file_name);
-			if ($version)
 			if ($version) {
 				$url .= '&version=' . rawurlencode($version);
+			}
 			return $url . '&download=1';
 		}
-		if (empty($version))
 		if (empty($version)) {
 			$version_path = '';
-		} else
 		} else {
 			$version_url = @$this->options['image_versions'][$version]['upload_url'];
-			if ($version_url)
 			if ($version_url) {
 				return $version_url . $this->get_user_path() . rawurlencode($file_name);
+			}
 			$version_path = rawurlencode($version) . '/';
+		}
+	{
 		$file->deleteUrl = $this->options['script_url'] . $this->get_query_separator($this->
 			options['script_url']) . $this->get_singular_param_name() . '=' . rawurlencode($file->
 			name);
 		$file->deleteType = $this->options['delete_type'];
-		if ($file->deleteType !== 'DELETE')
+		if ($file->deleteType !== 'DELETE') {
-		{
 			$file->deleteUrl .= '&_method=DELETE';
+		}
+        trigger_error($file->deleteUrl);
-		if ($this->options['access_control_allow_credentials'])
+		if ($this->options['access_control_allow_credentials']) {
-		{
 			$file->deleteWithCredentials = true;
+		}
+	}
 	// Fix for overflowing signed 32 bit integers,
 	// works for sizes up to 2^32-1 bytes (4 GiB - 1):
 	protected function fix_integer_overflow($size)
 	{
-		if ($size < 0)
 		if ($size < 0) {
 			$size += 2.0 * (PHP_INT_MAX + 1);
+		}
 		return $size;
+	}
 	protected function get_file_size($file_path, $clear_stat_cache = false)
-	{
-		if ($clear_stat_cache)
+	{
-		{
-			if (version_compare(PHP_VERSION, '5.3.0') >= 0)
+		if ($clear_stat_cache) {
-			{
+			if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
-				clearstatcache(true, $file_path);
-			} else
+				clearstatcache(true, $file_path);
 			} else {
 				clearstatcache();
+			}
+		}
 		return $this->fix_integer_overflow(filesize($file_path));
+	}
 	protected function is_valid_file_object($file_name)
-	{
 		$file_path = $this->get_upload_path($file_name);
-		if (is_file($file_path) && $file_name[0] !== '.')
+		$file_path = $this->get_upload_path($file_name);
 		if (is_file($file_path) && $file_name[0] !== '.') {
 			return true;
+		}
 		return false;
 	}
 	protected function get_file_object($file_name)
 	protected function get_file_object($file_name)
 		if ($this->is_valid_file_object($file_name))
 		if ($this->is_valid_file_object($file_name)) {
 			$file = new \stdClass();
-			$file->name = $file_name;
-			$file->size = $this->get_file_size($this->get_upload_path($file_name));
+			$file->name = $file_name;
-			$file->url = $this->get_download_url($file->name);
-			foreach ($this->options['image_versions'] as $version => $options)
+			$file->size = $this->get_file_size($this->get_upload_path($file_name));
-			{
-				if (!empty($version))
+			$file->url = $this->get_download_url($file->name);
 			foreach ($this->options['image_versions'] as $version => $options) {
-					if (is_file($this->get_upload_path($file_name, $version)))
+				if (!empty($version)) {
 					if (is_file($this->get_upload_path($file_name, $version))) {
 						$file->{$version . 'Url'} = $this->get_download_url($file->name, $version);
+	}
 	protected function get_file_objects($iteration_method = 'get_file_object')
+	{
 		$upload_dir = $this->get_upload_path();
-		if (!is_dir($upload_dir))
 		if (!is_dir($upload_dir)) {
 			return array();
+		}
 		return array_values(array_filter(array_map(array($this, $iteration_method),
 			scandir($upload_dir))));
 	public function get_config_bytes($val)
+	{
 		$val = trim($val);
 		$last = strtolower($val[strlen($val) - 1]);
 		$val = (int)$val;
-		switch ($last)
+		switch ($last) {
-		{
 			case 'g':
 				$val *= 1024;
 			case 'm':
 				$val *= 1024;
 			case 'k':
 		return $this->fix_integer_overflow($val);
+	}
 	protected function validate($uploaded_file, $file, $error, $index)
 	{
-		if ($error)
 		if ($error) {
 			$file->error = $this->get_error_message($error);
 			return false;
+		}
 		$content_length = $this->fix_integer_overflow((int)$this->get_server_var('CONTENT_LENGTH'));
 		$post_max_size = $this->get_config_bytes(ini_get('post_max_size'));
-		if ($post_max_size && ($content_length > $post_max_size))
 		if ($post_max_size && ($content_length > $post_max_size)) {
 			$file->error = $this->get_error_message('post_max_size');
 			return false;
 		}
-		if (!preg_match($this->options['accept_file_types'], $file->name))
 		if (!preg_match($this->options['accept_file_types'], $file->name)) {
 			$file->error = $this->get_error_message('accept_file_types');
 			return false;
 		}
-		if ($uploaded_file && is_uploaded_file($uploaded_file))
 		if ($uploaded_file && is_uploaded_file($uploaded_file)) {
 			$file_size = $this->get_file_size($uploaded_file);
-		} else
 		} else {
 			$file_size = $content_length;
+		}
 		if ($this->options['max_file_size'] && ($file_size > $this->options['max_file_size'] ||
-			$file->size > $this->options['max_file_size']))
 			$file->size > $this->options['max_file_size'])) {
 			$file->error = $this->get_error_message('max_file_size');
 			return false;
 		}
-		if ($this->options['min_file_size'] && $file_size < $this->options['min_file_size'])
 		if ($this->options['min_file_size'] && $file_size < $this->options['min_file_size']) {
 			$file->error = $this->get_error_message('min_file_size');
 			return false;
+		}
 		if (is_int($this->options['max_number_of_files']) && ($this->count_file_objects
 			() >= $this->options['max_number_of_files']) &&
 			// Ignore additional chunks of existing files:
-			!is_file($this->get_upload_path($file->name)))
 			!is_file($this->get_upload_path($file->name))) {
 			$file->error = $this->get_error_message('max_number_of_files');
 			return false;
+		}
 		$max_width = @$this->options['max_width'];
 		$max_height = @$this->options['max_height'];
 		$min_width = @$this->options['min_width'];
 		$min_height = @$this->options['min_height'];
 		if (($max_width || $max_height || $min_width || $min_height) && preg_match($this->
-			options['image_file_types'], $file->name))
 			options['image_file_types'], $file->name)) {
 			list($img_width, $img_height) = $this->get_image_size($uploaded_file);
 			// If we are auto rotating the image by default, do the checks on
 			// the correct orientation
-			if (@$this->options['image_versions']['']['auto_orient'] && function_exists('exif_read_data') &&
-				($exif = @exif_read_data($uploaded_file)) && (((int)@$exif['Orientation']) >= 5))
+			if (@$this->options['image_versions']['']['auto_orient'] && function_exists('exif_read_data') &&
 				($exif = @exif_read_data($uploaded_file)) && (((int)@$exif['Orientation']) >= 5)) {
 				$tmp = $img_width;
 				$img_width = $img_height;
 				$img_height = $tmp;
 				unset($tmp);
 			}
-		}
-		if (!empty($img_width))
+		}
-			if ($max_width && $img_width > $max_width)
+		if (!empty($img_width)) {
 			if ($max_width && $img_width > $max_width) {
 				$file->error = $this->get_error_message('max_width');
-				return false;
 				return false;
 			if ($max_height && $img_height > $max_height)
 			if ($max_height && $img_height > $max_height) {
 				$file->error = $this->get_error_message('max_height');
-				return false;
 				return false;
 			if ($min_width && $img_width < $min_width)
 			if ($min_width && $img_width < $min_width) {
 				$file->error = $this->get_error_message('min_width');
-				return false;
 				return false;
 			if ($min_height && $img_height < $min_height)
 			if ($min_height && $img_height < $min_height) {
 				$file->error = $this->get_error_message('min_height');
 				return false;
+	}
 	protected function get_unique_filename($file_path, $name, $size, $type, $error,
 		$index, $content_range)
 	{
-		while (is_dir($this->get_upload_path($name)))
 		while (is_dir($this->get_upload_path($name))) {
 			$name = $this->upcount_name($name);
+		}
 		// Keep an existing filename if this is part of a chunked upload:
 		$uploaded_bytes = $this->fix_integer_overflow((int)$content_range[1]);
-		while (is_file($this->get_upload_path($name)))
-		{
+		while (is_file($this->get_upload_path($name))) {
-			if ($uploaded_bytes === $this->get_file_size($this->get_upload_path($name)))
 			if ($uploaded_bytes === $this->get_file_size($this->get_upload_path($name))) {
 				break;
+			}
 			$name = $this->upcount_name($name);
+		}
 	protected function fix_file_extension($file_path, $name, $size, $type, $error, $index,
 		$content_range)
+	{
 		// Add missing file extension for known image types:
 		if (strpos($name, '.') === false && preg_match('/^image\/(gif|jpe?g|png)/', $type,
-			$matches))
+			$matches)) {
-		{
 			$name .= '.' . $matches[1];
+		}
-		if ($this->options['correct_image_extensions'] && function_exists('exif_imagetype'))
+		if ($this->options['correct_image_extensions'] && function_exists('exif_imagetype')) {
-		{
-			switch (@exif_imagetype($file_path))
+			switch (@exif_imagetype($file_path)) {
-			{
 				case IMAGETYPE_JPEG:
 					$extensions = array('jpg', 'jpeg');
 					break;
 				case IMAGETYPE_PNG:
 					$extensions = array('png');
 				case IMAGETYPE_GIF:
 					$extensions = array('gif');
 					break;
+			}
 			// Adjust incorrect image file extensions:
-			if (!empty($extensions))
+			if (!empty($extensions)) {
-			{
 				$parts = explode('.', $name);
 				$extIndex = count($parts) - 1;
 				$ext = strtolower(@$parts[$extIndex]);
-				if (!in_array($ext, $extensions))
+				if (!in_array($ext, $extensions)) {
-				{
 					$parts[$extIndex] = $extensions[0];
 					$name = implode('.', $parts);
+				}
+			}
+		}
 		// 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:
 		$name = trim($this->basename(stripslashes($name)), ".\x00..\x20");
 		// Use a timestamp for empty filenames:
-		if (!$name)
+		if (!$name) {
-		{
 			$name = str_replace('.', '-', microtime(true));
+		}
 		return $name;
+	}
+	}
 	protected function get_scaled_image_file_paths($file_name, $version)
+	{
 		$file_path = $this->get_upload_path($file_name);
-		if (!empty($version))
 		if (!empty($version)) {
 			$version_dir = $this->get_upload_path(null, $version);
-			if (!is_dir($version_dir))
 			if (!is_dir($version_dir)) {
 				mkdir($version_dir, $this->options['mkdir_mode'], true);
+			}
 			$new_file_path = $version_dir . '/' . $file_name;
-		} else
 		} else {
 			$new_file_path = $file_path;
+		}
 		return array($file_path, $new_file_path);
+	}
 	protected function gd_get_image_object($file_path, $func, $no_cache = false)
-	{
 		if (empty($this->image_objects[$file_path]) || $no_cache)
 		if (empty($this->image_objects[$file_path]) || $no_cache) {
 			$this->gd_destroy_image_object($file_path);
 			$this->image_objects[$file_path] = $func($file_path);
+		}
 		return $image && imagedestroy($image);
+	}
 	protected function gd_imageflip($image, $mode)
 	{
-		if (function_exists('imageflip'))
 		if (function_exists('imageflip')) {
 			return imageflip($image, $mode);
+		}
 		$new_width = $src_width = imagesx($image);
 		$new_height = $src_height = imagesy($image);
 		$new_img = imagecreatetruecolor($new_width, $new_height);
 		$src_x = 0;
 		$src_y = 0;
-		switch ($mode)
 		switch ($mode) {
 			case '1': // flip on the horizontal axis
 				$src_y = $new_height - 1;
 				$src_height = -$new_height;
 				break;
 		return $new_img;
+	}
 	protected function gd_orient_image($file_path, $src_img)
 	{
-		if (!function_exists('exif_read_data'))
 		if (!function_exists('exif_read_data')) {
 			return false;
+		}
 		$exif = @exif_read_data($file_path);
-		if ($exif === false)
 		if ($exif === false) {
 			return false;
+		}
 		$orientation = (int)@$exif['Orientation'];
-		if ($orientation < 2 || $orientation > 8)
 		if ($orientation < 2 || $orientation > 8) {
 			return false;
 		}
-		switch ($orientation)
 		switch ($orientation) {
 			case 2:
 				$new_img = $this->gd_imageflip($src_img, defined('IMG_FLIP_VERTICAL') ?
 					IMG_FLIP_VERTICAL : 2);
 				break;
 		return true;
+	}
 	protected function gd_create_scaled_image($file_name, $version, $options)
 	{
-		if (!function_exists('imagecreatetruecolor'))
 		if (!function_exists('imagecreatetruecolor')) {
 			error_log('Function not found: imagecreatetruecolor');
 			return false;
+		}
 		list($file_path, $new_file_path) = $this->get_scaled_image_file_paths($file_name,
 			$version);
 		$type = strtolower(substr(strrchr($file_name, '.'), 1));
-		switch ($type)
 		switch ($type) {
 			case 'jpg':
 			case 'jpeg':
 				$src_func = 'imagecreatefromjpeg';
 				$write_func = 'imagejpeg';
 			default:
 				return false;
+		}
 		$src_img = $this->gd_get_image_object($file_path, $src_func, !empty($options['no_cache']));
 		$image_oriented = false;
-		if (!empty($options['auto_orient']) && $this->gd_orient_image($file_path, $src_img))
+		if (!empty($options['auto_orient']) && $this->gd_orient_image($file_path, $src_img)) {
-		{
 			$image_oriented = true;
 			$src_img = $this->gd_get_image_object($file_path, $src_func);
+		}
 		$max_width = $img_width = imagesx($src_img);
 		$max_height = $img_height = imagesy($src_img);
-		if (!empty($options['max_width']))
+		if (!empty($options['max_width'])) {
-		{
 			$max_width = $options['max_width'];
+		}
-		if (!empty($options['max_height']))
+		if (!empty($options['max_height'])) {
-		{
 			$max_height = $options['max_height'];
+		}
 		$scale = min($max_width / $img_width, $max_height / $img_height);
-		if ($scale >= 1)
+		if ($scale >= 1) {
-		{
-			if ($image_oriented)
+			if ($image_oriented) {
-			{
 				return $write_func($src_img, $new_file_path, $image_quality);
+			}
-			if ($file_path !== $new_file_path)
+			if ($file_path !== $new_file_path) {
-			{
 				return copy($file_path, $new_file_path);
+			}
 			return true;
+		}
-		if (empty($options['crop']))
+		if (empty($options['crop'])) {
-		{
 			$new_width = $img_width * $scale;
 			$new_height = $img_height * $scale;
 			$dst_x = 0;
 			$dst_y = 0;
 			$new_img = imagecreatetruecolor($new_width, $new_height);
-		} else
+		} else {
-		{
-			if (($img_width / $img_height) >= ($max_width / $max_height))
+			if (($img_width / $img_height) >= ($max_width / $max_height)) {
-			{
 				$new_width = $img_width / ($img_height / $max_height);
 				$new_height = $max_height;
-			} else
+			} else {
-			{
 				$new_width = $max_width;
 				$new_height = $img_height / ($img_width / $max_width);
+			}
 			$dst_x = 0 - ($new_width - $max_width) / 2;
 			$dst_y = 0 - ($new_height - $max_height) / 2;
 			$new_img = imagecreatetruecolor($max_width, $max_height);
+		}
 		// Handle transparency in GIF and PNG images:
-		switch ($type)
+		switch ($type) {
-		{
 			case 'gif':
 			case 'png':
 				imagecolortransparent($new_img, imagecolorallocate($new_img, 0, 0, 0));
 			case 'png':
 				imagealphablending($new_img, false);
 		return $success;
+	}
 	protected function imagick_get_image_object($file_path, $no_cache = false)
 	{
-		if (empty($this->image_objects[$file_path]) || $no_cache)
 		if (empty($this->image_objects[$file_path]) || $no_cache) {
 			$this->imagick_destroy_image_object($file_path);
 			$image = new \Imagick();
-			if (!empty($this->options['imagick_resource_limits']))
-			{
+			if (!empty($this->options['imagick_resource_limits'])) {
-				foreach ($this->options['imagick_resource_limits'] as $type => $limit)
 				foreach ($this->options['imagick_resource_limits'] as $type => $limit) {
 					$image->setResourceLimit($type, $limit);
+				}
+			}
 			$image->readImage($file_path);
 	protected function imagick_orient_image($image)
+	{
 		$orientation = $image->getImageOrientation();
 		$background = new \ImagickPixel('none');
-		switch ($orientation)
 		switch ($orientation) {
 			case \imagick::ORIENTATION_TOPRIGHT: // 2
 				$image->flopImage(); // horizontal flop around y-axis
 				break;
 			case \imagick::ORIENTATION_BOTTOMRIGHT: // 3
+	{
 		list($file_path, $new_file_path) = $this->get_scaled_image_file_paths($file_name,
 			$version);
 		$image = $this->imagick_get_image_object($file_path, !empty($options['crop']) ||
 			!empty($options['no_cache']));
-		if ($image->getImageFormat() === 'GIF')
+		if ($image->getImageFormat() === 'GIF') {
-		{
 			// Handle animated GIFs:
 			$images = $image->coalesceImages();
-			foreach ($images as $frame)
+			foreach ($images as $frame) {
-			{
 				$image = $frame;
 				$this->imagick_set_image_object($file_name, $image);
 				break;
+			}
+		}
 		$image_oriented = false;
-		if (!empty($options['auto_orient']))
+		if (!empty($options['auto_orient'])) {
-		{
 			$image_oriented = $this->imagick_orient_image($image);
+		}
 		$new_width = $max_width = $img_width = $image->getImageWidth();
 		$new_height = $max_height = $img_height = $image->getImageHeight();
-		if (!empty($options['max_width']))
+		if (!empty($options['max_width'])) {
-		{
 			$new_width = $max_width = $options['max_width'];
+		}
-		if (!empty($options['max_height']))
+		if (!empty($options['max_height'])) {
-		{
 			$new_height = $max_height = $options['max_height'];
+		}
 		$image_strip = false;
-		if (!empty($options["strip"]))
+		if (!empty($options["strip"])) {
-		{
 			$image_strip = $options["strip"];
+		}
 		if (!$image_oriented && ($max_width >= $img_width) && ($max_height >= $img_height) &&
-			!$image_strip && empty($options["jpeg_quality"]))
+			!$image_strip && empty($options["jpeg_quality"])) {
-		{
-			if ($file_path !== $new_file_path)
+			if ($file_path !== $new_file_path) {
-			{
 				return copy($file_path, $new_file_path);
+			}
 			return true;
+		}
 		$crop = !empty($options['crop']);
-		if ($crop)
+		if ($crop) {
-		{
 			$x = 0;
 			$y = 0;
-			if (($img_width / $img_height) >= ($max_width / $max_height))
+			if (($img_width / $img_height) >= ($max_width / $max_height)) {
-			{
 				$new_width = 0; // Enables proportional scaling based on max_height
 				$x = ($img_width / ($img_height / $max_height) - $max_width) / 2;
-			} else
+			} else {
-			{
 				$new_height = 0; // Enables proportional scaling based on max_width
 				$y = ($img_height / ($img_width / $max_width) - $max_height) / 2;
+			}
+		}
 		$success = $image->resizeImage($new_width, $new_height, isset($options['filter']) ?
 			$options['filter'] : \imagick::FILTER_LANCZOS, isset($options['blur']) ? $options['blur'] :
 , $new_width && $new_height // fit image into constraints if not to be cropped
 			);
-		if ($success && $crop)
+		if ($success && $crop) {
-		{
 			$success = $image->cropImage($max_width, $max_height, $x, $y);
-			if ($success)
+			if ($success) {
-			{
 				$success = $image->setImagePage($max_width, $max_height, 0, 0);
+			}
+		}
 		$type = strtolower(substr(strrchr($file_name, '.'), 1));
-		switch ($type)
+		switch ($type) {
-		{
 			case 'jpg':
 			case 'jpeg':
-				if (!empty($options['jpeg_quality']))
+				if (!empty($options['jpeg_quality'])) {
-				{
 					$image->setImageCompression(\imagick::COMPRESSION_JPEG);
 					$image->setImageCompressionQuality($options['jpeg_quality']);
+				}
 				break;
+		}
-		if ($image_strip)
+		if ($image_strip) {
-		{
 			$image->stripImage();
+		}
 		return $success && $image->writeImage($new_file_path);
+	}
 	protected function imagemagick_create_scaled_image($file_name, $version, $options)
+	{
 		list($file_path, $new_file_path) = $this->get_scaled_image_file_paths($file_name,
 			$version);
 		$resize = @$options['max_width'] . (empty($options['max_height']) ? '' : 'X' . $options['max_height']);
-		if (!$resize && empty($options['auto_orient']))
-		{
+		if (!$resize && empty($options['auto_orient'])) {
-			if ($file_path !== $new_file_path)
 			if ($file_path !== $new_file_path) {
 				return copy($file_path, $new_file_path);
+			}
 			return true;
+		}
 		$cmd = $this->options['convert_bin'];
-		if (!empty($this->options['convert_params']))
 		if (!empty($this->options['convert_params'])) {
 			$cmd .= ' ' . $this->options['convert_params'];
+		}
 		$cmd .= ' ' . escapeshellarg($file_path);
-		if (!empty($options['auto_orient']))
 		if (!empty($options['auto_orient'])) {
 			$cmd .= ' -auto-orient';
 		}
-		if ($resize)
 		if ($resize) {
 			// Handle animated GIFs:
 			$cmd .= ' -coalesce';
-			if (empty($options['crop']))
 			if (empty($options['crop'])) {
 				$cmd .= ' -resize ' . escapeshellarg($resize . '>');
-			} else
 			} else {
 				$cmd .= ' -resize ' . escapeshellarg($resize . '^');
 				$cmd .= ' -gravity center';
 				$cmd .= ' -crop ' . escapeshellarg($resize . '+0+0');
+			}
 			// Make sure the page dimensions are correct (fixes offsets of animated GIFs):
 			$cmd .= ' +repage';
 		}
-		if (!empty($options['convert_params']))
 		if (!empty($options['convert_params'])) {
 			$cmd .= ' ' . $options['convert_params'];
+		}
 		$cmd .= ' ' . escapeshellarg($new_file_path);
 		exec($cmd, $output, $error);
-		if ($error)
 		if ($error) {
 			error_log(implode('\n', $output));
 			return false;
+		}
 		return true;
+	}
 	protected function get_image_size($file_path)
-	{
-		if ($this->options['image_library'])
+	{
-		{
-			if (extension_loaded('imagick'))
+		if ($this->options['image_library']) {
-			{
+			if (extension_loaded('imagick')) {
-				$image = new \Imagick();
-				try
+				$image = new \Imagick();
-				{
-					if (@$image->pingImage($file_path))
+				try {
 					if (@$image->pingImage($file_path)) {
 						$dimensions = array($image->getImageWidth(), $image->getImageHeight());
 						$image->destroy();
 						return $dimensions;
+					}
 					return false;
-				}
 				catch (\Exception $e)
 				catch (\Exception $e) {
 					error_log($e->getMessage());
 				}
-			}
 			if ($this->options['image_library'] === 2)
 			if ($this->options['image_library'] === 2) {
 				$cmd = $this->options['identify_bin'];
 				$cmd .= ' -ping ' . escapeshellarg($file_path);
-				exec($cmd, $output, $error);
-				if (!$error && !empty($output))
+				exec($cmd, $output, $error);
 				if (!$error && !empty($output)) {
 					// image.jpg JPEG 1920x1080 1920x1080+0+0 8-bit sRGB 465KB 0.000u 0:00.000
 					$infos = preg_split('/\s+/', substr($output[0], strlen($file_path)));
 					$dimensions = preg_split('/x/', $infos[2]);
 					return $dimensions;
+				}
 				return false;
 			}
-		}
 		if (!function_exists('getimagesize'))
 		if (!function_exists('getimagesize')) {
 			error_log('Function not found: getimagesize');
 			return false;
+		}
 		return @getimagesize($file_path);
+	}
-	protected function create_scaled_image($file_name, $version, $options)
 	protected function create_scaled_image($file_name, $version, $options)
 		if ($this->options['image_library'] === 2)
-		{
+		if ($this->options['image_library'] === 2) {
-			return $this->imagemagick_create_scaled_image($file_name, $version, $options);
 			return $this->imagemagick_create_scaled_image($file_name, $version, $options);
 		if ($this->options['image_library'] && extension_loaded('imagick'))
 		if ($this->options['image_library'] && extension_loaded('imagick')) {
 			return $this->imagick_create_scaled_image($file_name, $version, $options);
+		}
 		return $this->gd_create_scaled_image($file_name, $version, $options);
 	}
 	protected function destroy_image_object($file_path)
 	protected function destroy_image_object($file_path)
 		if ($this->options['image_library'] && extension_loaded('imagick'))
 		if ($this->options['image_library'] && extension_loaded('imagick')) {
 			return $this->imagick_destroy_image_object($file_path);
 		}
-	}
+	}
 	protected function is_valid_image_file($file_path)
-	{
+	protected function is_valid_image_file($file_path)
-		if (!preg_match($this->options['image_file_types'], $file_path))
+	{
-			return false;
+		if (!preg_match($this->options['image_file_types'], $file_path)) {
 			return false;
 		if (function_exists('exif_imagetype'))
 		if (function_exists('exif_imagetype')) {
 			return @exif_imagetype($file_path);
+		}
 		$image_info = $this->get_image_size($file_path);
 		return $image_info && $image_info[0] && $image_info[1];
-	}
+	}
-	protected function handle_image_file($file_path, $file)
-	{
-		$failed_versions = array();
-		foreach ($this->options['image_versions'] as $version => $options)
+	protected function handle_image_file($file_path, $file)
-		{
+	{
-			if ($this->create_scaled_image($file->name, $version, $options))
 		$failed_versions = array();
-				if (!empty($version))
+		foreach ($this->options['image_versions'] as $version => $options) {
-				{
+			if ($this->create_scaled_image($file->name, $version, $options)) {
-					$file->{$version . 'Url'} = $this->get_download_url($file->name, $version);
-				} else
+				if (!empty($version)) {
 					$file->{$version . 'Url'} = $this->get_download_url($file->name, $version);
-					$file->size = $this->get_file_size($file_path, true);
+				} else {
-				}
+					$file->size = $this->get_file_size($file_path, true);
-			} else
+				}
-				$failed_versions[] = $version ? $version : 'original';
+			} else {
 				$failed_versions[] = $version ? $version : 'original';
+			}
 		if (count($failed_versions))
 		$file = new \stdClass();
 		$file->name = $this->get_file_name($uploaded_file, $name, $size, $type, $error,
 			$index, $content_range);
 		$file->size = $this->fix_integer_overflow((int)$size);
 		$file->type = $type;
-		if ($this->validate($uploaded_file, $file, $error, $index))
+		if ($this->validate($uploaded_file, $file, $error, $index)) {
-		{
 			$this->handle_form_data($file, $index);
 			$upload_dir = $this->get_upload_path();
-			if (!is_dir($upload_dir))
+			if (!is_dir($upload_dir)) {
-			{
 				mkdir($upload_dir, $this->options['mkdir_mode'], true);
+			}
 			$file_path = $this->get_upload_path($file->name);
 			$append_file = $content_range && is_file($file_path) && $file->size > $this->
 				get_file_size($file_path);
-			if ($uploaded_file && is_uploaded_file($uploaded_file))
+			if ($uploaded_file && is_uploaded_file($uploaded_file)) {
-			{
 				// multipart/formdata uploads (POST method uploads)
-				if ($append_file)
+				if ($append_file) {
-				{
 					file_put_contents($file_path, fopen($uploaded_file, 'r'), FILE_APPEND);
-				} else
+				} else {
-				{
 					move_uploaded_file($uploaded_file, $file_path);
+				}
-			} else
+			} else {
-			{
 				// Non-multipart uploads (PUT method support)
 				file_put_contents($file_path, fopen($this->options['input_stream'], 'r'), $append_file ?
 					FILE_APPEND : 0);
+			}
 			$file_size = $this->get_file_size($file_path, $append_file);
-			if ($file_size === $file->size)
+			$videos = array(
+				"wmf",
+				"flv",
+				"swf",
+				);
+			$docs = array(
+				"pdf",
+				"doc",
+				"docx",
+				"xls",
+				"xlsx",
-			{
+				);
+			if ($file_size === $file->size) {
 				$file->url = $this->get_download_url($file->name);
-				if ($this->is_valid_image_file($file_path))
+				if ($this->is_valid_image_file($file_path)) {
-				{
 					$this->handle_image_file($file_path, $file);
+				}
+				$mt = mime_content_type($file_path);
+				$info = pathinfo($file_path);
+				$ext = strtolower($info["extension"]);
+				$typ = 4;
+				if (substr($mt, 0, 5) == "image") {
+					$typ = 1;
+					foreach ($this->options['image_versions'] as $version => $options) {
+						if ($this->create_scaled_image($fName, $options)) {
+							$file->{$version . '_url'} = $options['upload_url'] . $fName;
-			} else
+						}
+					}
+				} elseif (in_array($ext, $docs)) {
+					$typ = 2;
+				} elseif (in_array($ext, $videos)) {
+					$typ = 3;
-			{
+				}
+				$f = $GLOBALS["folder"];
+				$sql = "INSERT INTO
+                        medien
+                    SET
+                        name='" . $fName . "',
+                        folder='" . $f . "',
+                        erstellt_am=UNIX_TIMESTAMP(),
+                        erstellt_von='" . $_SERVER["PHP_AUTH_USER"] . "',
+                        typ=" . $typ . "
+                ";
+				$this->db->query($sql);
+			} else {
 				$file->size = $file_size;
-				if (!$content_range && $this->options['discard_aborted_uploads'])
+				if (!$content_range && $this->options['discard_aborted_uploads']) {
-				{
 					unlink($file_path);
 					$file->error = $this->get_error_message('abort');
+				}
+			}
 			$this->set_additional_file_properties($file);
 	protected function readfile($file_path)
+	{
 		$file_size = $this->get_file_size($file_path);
 		$chunk_size = $this->options['readfile_chunk_size'];
-		if ($chunk_size && $file_size > $chunk_size)
 		if ($chunk_size && $file_size > $chunk_size) {
 			$handle = fopen($file_path, 'rb');
-			while (!feof($handle))
 			while (!feof($handle)) {
 				echo fread($handle, $chunk_size);
 				@ob_flush();
 				@flush();
+			}
+	}
 	protected function get_file_names_params()
+	{
 		$params = $this->get_query_param($this->options['param_name']);
-		if (!$params)
 		if (!$params) {
 			return null;
 		}
-		foreach ($params as $key => $value)
 		foreach ($params as $key => $value) {
 			$params[$key] = $this->basename(stripslashes($value));
+		}
 		return $params;
+	}
 	protected function get_file_type($file_path)
-	{
 		switch (strtolower(pathinfo($file_path, PATHINFO_EXTENSION)))
 		switch (strtolower(pathinfo($file_path, PATHINFO_EXTENSION))) {
 			case 'jpeg':
 			case 'jpg':
 				return 'image/jpeg';
 			case 'png':
 				return 'image/png';
+			case 'gif':
+				return 'image/gif';
-			case 'gif':
+			case 'svg':
-				return 'image/gif';
+				return 'image/svg';
 			default:
 				return '';
+		}
+	}
-	protected function download()
 	protected function download()
 		switch ($this->options['download_via_php'])
 		switch ($this->options['download_via_php']) {
 			case 1:
 				$redirect_header = null;
 				break;
 			default:
 				return $this->header('HTTP/1.1 403 Forbidden');
+		}
 		$file_name = $this->get_file_name_param();
-		if (!$this->is_valid_file_object($file_name))
+		if (!$this->is_valid_file_object($file_name)) {
-		{
 			return $this->header('HTTP/1.1 404 Not Found');
+		}
-		if ($redirect_header)
+		if ($redirect_header) {
-		{
 			return $this->header($redirect_header . ': ' . $this->get_download_url($file_name,
 				$this->get_version_param(), true));
+		}
 		$file_path = $this->get_upload_path($file_name, $this->get_version_param());
 		// Prevent browsers from MIME-sniffing the content-type:
 		$this->header('X-Content-Type-Options: nosniff');
-		if (!preg_match($this->options['inline_file_types'], $file_name))
+		if (!preg_match($this->options['inline_file_types'], $file_name)) {
-		{
 			$this->header('Content-Type: application/octet-stream');
 			$this->header('Content-Disposition: attachment; filename="' . $file_name . '"');
-		} else
+		} else {
-		{
 			$this->header('Content-Type: ' . $this->get_file_type($file_path));
 			$this->header('Content-Disposition: inline; filename="' . $file_name . '"');
+		}
 		$this->header('Content-Length: ' . $this->get_file_size($file_path));
 		$this->header('Last-Modified: ' . gmdate('D, d M Y H:i:s T', filemtime($file_path)));
+	}
 	protected function send_content_type_header()
+	{
 		$this->header('Vary: Accept');
-		if (strpos($this->get_server_var('HTTP_ACCEPT'), 'application/json') !== false)
 		if (strpos($this->get_server_var('HTTP_ACCEPT'), 'application/json') !== false) {
 			$this->header('Content-type: application/json');
-		} else
 		} else {
 			$this->header('Content-type: text/plain');
+		}
+	}
+	}
 	public function generate_response($content, $print_response = true)
+	{
 		$this->response = $content;
-		if ($print_response)
 		if ($print_response) {
 			$json = json_encode($content);
 			$redirect = stripslashes($this->get_post_param('redirect'));
-			if ($redirect && preg_match($this->options['redirect_allow_target'], $redirect))
 			if ($redirect && preg_match($this->options['redirect_allow_target'], $redirect)) {
 				$this->header('Location: ' . sprintf($redirect, rawurlencode($json)));
 				return;
+			}
 			$this->head();
-			if ($this->get_server_var('HTTP_CONTENT_RANGE'))
 			if ($this->get_server_var('HTTP_CONTENT_RANGE')) {
 				$files = isset($content[$this->options['param_name']]) ? $content[$this->
 					options['param_name']] : null;
-				if ($files && is_array($files) && is_object($files[0]) && $files[0]->size)
 				if ($files && is_array($files) && is_object($files[0]) && $files[0]->size) {
 					$this->header('Range: 0-' . ($this->fix_integer_overflow((int)$files[0]->size) -
 ));
+				}
+			}
 		$this->header('Pragma: no-cache');
 		$this->header('Cache-Control: no-store, no-cache, must-revalidate');
 		$this->header('Content-Disposition: inline; filename="files.json"');
 		// Prevent Internet Explorer from MIME-sniffing the content-type:
 		$this->header('X-Content-Type-Options: nosniff');
-		if ($this->options['access_control_allow_origin'])
+		if ($this->options['access_control_allow_origin']) {
-		{
 			$this->send_access_control_headers();
+		}
 		$this->send_content_type_header();
+	}
 	public function get($print_response = true)
 	{
-		if ($print_response && $this->get_query_param('download'))
 		if ($print_response && $this->get_query_param('download')) {
 			return $this->download();
+		}
 		$file_name = $this->get_file_name_param();
-		if ($file_name)
 		if ($file_name) {
 			$response = array($this->get_singular_param_name() => $this->get_file_object($file_name));
-		} else
 		} else {
 			$response = array($this->options['param_name'] => $this->get_file_objects());
+		}
 		return $this->generate_response($response, $print_response);
+	}
 	public function post($print_response = true)
-	{
 		if ($this->get_query_param('_method') === 'DELETE')
 		if ($this->get_query_param('_method') === 'DELETE') {
 			return $this->delete($print_response);
+		}
 		$upload = $this->get_upload_data($this->options['param_name']);
 		// Content-Range: bytes 0-524287/2000000
 		$content_range_header = $this->get_server_var('HTTP_CONTENT_RANGE');
 		$content_range = $content_range_header ? preg_split('/[^0-9]+/', $content_range_header) : null;
 		$size = $content_range ? $content_range[3] : null;
 		$files = array();
-		if ($upload)
+		if ($upload) {
-		{
-			if (is_array($upload['tmp_name']))
+			if (is_array($upload['tmp_name'])) {
-			{
 				// param_name is an array identifier like "files[]",
 				// $upload is a multi-dimensional array:
-				foreach ($upload['tmp_name'] as $index => $value)
+				foreach ($upload['tmp_name'] as $index => $value) {
-				{
 					$files[] = $this->handle_file_upload($upload['tmp_name'][$index], $file_name ? $file_name :
 						$upload['name'][$index], $size ? $size : $upload['size'][$index], $upload['type'][$index],
 						$upload['error'][$index], $index, $content_range);
+				}
-			} else
+			} else {
-			{
 				// param_name is a single object identifier like "file",
 				// $upload is a one-dimensional array:
 				$files[] = $this->handle_file_upload(isset($upload['tmp_name']) ? $upload['tmp_name'] : null,
 					$file_name ? $file_name : (isset($upload['name']) ? $upload['name'] : null), $size ?
 					$size : (isset($upload['size']) ? $upload['size'] : $this->get_server_var('CONTENT_LENGTH')),
+	}
 	public function delete($print_response = true)
+	{
 		$file_names = $this->get_file_names_params();
-		if (empty($file_names))
 		if (empty($file_names)) {
 			$file_names = array($this->get_file_name_param());
+		}
 		$response = array();
-		foreach ($file_names as $file_name)
 		foreach ($file_names as $file_name) {
 			$file_path = $this->get_upload_path($file_name);
 			$success = is_file($file_path) && $file_name[0] !== '.' && unlink($file_path);
-			if ($success)
-			{
+			if ($success) {
-				foreach ($this->options['image_versions'] as $version => $options)
-				{
+				foreach ($this->options['image_versions'] as $version => $options) {
-					if (!empty($version))
 					if (!empty($version)) {
 						$file = $this->get_upload_path($file_name, $version);
-						if (is_file($file))
 						if (is_file($file)) {
 							unlink($file);
+						}
+					}
+				}

Subversion-Projekte lars-tiefland.ci

(root)/backend/controllers/UploadHandler.php – Revision 2128 → 2130