<?php
/*--------------------------------------------------
 | TAR/GZIP/BZIP2/ZIP ARCHIVE CLASSES 2.1
 | By Devin Doucette
 | Copyright (c) 2005 Devin Doucette
 | Email: darksnoopy@shaw.ca
 +--------------------------------------------------
 | Email bugs/suggestions to darksnoopy@shaw.ca
 +--------------------------------------------------
 | This script has been created and released under
 | the GNU GPL and is free to use and redistribute
 | only if this copyright statement is not removed
 +--------------------------------------------------*/

class Archive
{
	function archive($name = "")
	{
		$this->options = array (
			'basedir' => ".",
			'name' => $name,
			'prepend' => "",
			'inmemory' => 0,
			'overwrite' => 0,
			'recurse' => 1,
			'storepaths' => 1,
			'followlinks' => 0,
			'level' => 3,
			'method' => 1,
			'sfx' => "",
			'type' => "",
			'comment' => ""
		);
		$this->files = array ();
		$this->exclude = array ();
		$this->storeonly = array ();
		$this->error = array ();
	}

	function set_options($options)
	{
		foreach ($options as $key => $value)
			$this->options[$key] = $value;
		if (!empty ($this->options['basedir']))
		{
			$this->options['basedir'] = str_replace("\\", "/", $this->options['basedir']);
			$this->options['basedir'] = preg_replace("/\/+/", "/", $this->options['basedir']);
			$this->options['basedir'] = preg_replace("/\/$/", "", $this->options['basedir']);
		}
		if (!empty ($this->options['name']))
		{
			$this->options['name'] = str_replace("\\", "/", $this->options['name']);
			$this->options['name'] = preg_replace("/\/+/", "/", $this->options['name']);
		}
		if (!empty ($this->options['prepend']))
		{
			$this->options['prepend'] = str_replace("\\", "/", $this->options['prepend']);
			$this->options['prepend'] = preg_replace("/^(\.*\/+)+/", "", $this->options['prepend']);
			$this->options['prepend'] = preg_replace("/\/+/", "/", $this->options['prepend']);
			$this->options['prepend'] = preg_replace("/\/$/", "", $this->options['prepend']) . "/";
		}
	}

	function create_archive()
	{
		$this->make_list();

		if ($this->options['inmemory'] == 0)
		{
			$pwd = getcwd();
			chdir($this->options['basedir']);
			if ($this->options['overwrite'] == 0 && file_exists($this->options['name'] . ($this->options['type'] == "gzip" || $this->options['type'] == "bzip" ? ".tmp" : "")))
			{
				$this->error[] = "File {$this->options['name']} already exists.";
				chdir($pwd);
				return 0;
			}
			else if ($this->archive = @fopen($this->options['name'] . ($this->options['type'] == "gzip" || $this->options['type'] == "bzip" ? ".tmp" : ""), "wb+"))
				chdir($pwd);
			else
			{
				$this->error[] = "Could not open {$this->options['name']} for writing.";
				chdir($pwd);
				return 0;
			}
		}
		else
			$this->archive = "";

		switch ($this->options['type'])
		{
		case "zip":
			if (!$this->create_zip())
			{
				$this->error[] = "Could not create zip file.";
				return 0;
			}
			break;
		case "bzip":
			if (!$this->create_tar())
			{
				$this->error[] = "Could not create tar file.";
				return 0;
			}
			if (!$this->create_bzip())
			{
				$this->error[] = "Could not create bzip2 file.";
				return 0;
			}
			break;
		case "gzip":
			if (!$this->create_tar())
			{
				$this->error[] = "Could not create tar file.";
				return 0;
			}
			if (!$this->create_gzip())
			{
				$this->error[] = "Could not create gzip file.";
				return 0;
			}
			break;
		case "tar":
			if (!$this->create_tar())
			{
				$this->error[] = "Could not create tar file.";
				return 0;
			}
		}

		if ($this->options['inmemory'] == 0)
		{
			fclose($this->archive);
			if ($this->options['type'] == "gzip" || $this->options['type'] == "bzip")
				unlink($this->options['basedir'] . "/" . $this->options['name'] . ".tmp");
		}
	}

	function add_data($data)
	{
		if ($this->options['inmemory'] == 0)
			fwrite($this->archive, $data);
		else
			$this->archive .= $data;
	}

	function make_list()
	{
		if (!empty ($this->exclude))
			foreach ($this->files as $key => $value)
				foreach ($this->exclude as $current)
					if ($value['name'] == $current['name'])
						unset ($this->files[$key]);
		if (!empty ($this->storeonly))
			foreach ($this->files as $key => $value)
				foreach ($this->storeonly as $current)
					if ($value['name'] == $current['name'])
						$this->files[$key]['method'] = 0;
		unset ($this->exclude, $this->storeonly);
	}

	function add_files($list)
	{
		$temp = $this->list_files($list);
		foreach ($temp as $current)
			$this->files[] = $current;
	}

	function exclude_files($list)
	{
		$temp = $this->list_files($list);
		foreach ($temp as $current)
			$this->exclude[] = $current;
	}

	function store_files($list)
	{
		$temp = $this->list_files($list);
		foreach ($temp as $current)
			$this->storeonly[] = $current;
	}

	function list_files($list)
	{
		if (!is_array ($list))
		{
			$temp = $list;
			$list = array ($temp);
			unset ($temp);
		}

		$files = array ();

		$pwd = getcwd();
		chdir($this->options['basedir']);

		foreach ($list as $current)
		{
			$current = str_replace("\\", "/", $current);
			$current = preg_replace("/\/+/", "/", $current);
			$current = preg_replace("/\/$/", "", $current);
			if (strstr($current, "*"))
			{
				$regex = preg_replace("/([\\\^\$\.\[\]\|\(\)\?\+\{\}\/])/", "\\\\\\1", $current);
				$regex = str_replace("*", ".*", $regex);
				$dir = strstr($current, "/") ? substr($current, 0, strrpos($current, "/")) : ".";
				$temp = $this->parse_dir($dir);
				foreach ($temp as $current2)
					if (preg_match("/^{$regex}$/i", $current2['name']))
						$files[] = $current2;
				unset ($regex, $dir, $temp, $current);
			}
			else if (@is_dir($current))
			{
				$temp = $this->parse_dir($current);
				foreach ($temp as $file)
					$files[] = $file;
				unset ($temp, $file);
			}
			else if (@file_exists($current))
				$files[] = array ('name' => $current, 'name2' => $this->options['prepend'] .
					preg_replace("/(\.+\/+)+/", "", ($this->options['storepaths'] == 0 && strstr($current, "/")) ?
					substr($current, strrpos($current, "/") + 1) : $current),
					'type' => @is_link($current) && $this->options['followlinks'] == 0 ? 2 : 0,
					'ext' => substr($current, strrpos($current, ".")), 'stat' => stat($current));
		}

		chdir($pwd);

		unset ($current, $pwd);

		usort($files, array ("archive", "sort_files"));

		return $files;
	}

	function parse_dir($dirname)
	{
/*
		if ($this->options['storepaths'] == 1 && !preg_match("/^(\.+\/*)+$/", $dirname))
			$files = array (array ('name' => $dirname, 'name2' => $this->options['prepend'] .
				preg_replace("/(\.+\/+)+/", "", ($this->options['storepaths'] == 0 && strstr($dirname, "/")) ?
				substr($dirname, strrpos($dirname, "/") + 1) : $dirname), 'type' => 5, 'stat' => stat($dirname)));
		else
*/		
		$files = array ();
		$dir = @opendir($dirname);

		while ($file = @readdir($dir))
		{
			$fullname = $dirname . "/" . $file;
			if ($file == "." || $file == "..")
				continue;
			else if (@is_dir($fullname))
			{
				if (empty ($this->options['recurse']))
					continue;
				$temp = $this->parse_dir($fullname);
				foreach ($temp as $file2)
					$files[] = $file2;
			}
			else if (@file_exists($fullname))
				$files[] = array ('name' => $fullname, 'name2' => $this->options['prepend'] .
					preg_replace("/(\.+\/+)+/", "", ($this->options['storepaths'] == 0 && strstr($fullname, "/")) ?
					substr($fullname, strrpos($fullname, "/") + 1) : $fullname),
					'type' => @is_link($fullname) && $this->options['followlinks'] == 0 ? 2 : 0,
					'ext' => substr($file, strrpos($file, ".")), 'stat' => stat($fullname));
		}

		@closedir($dir);

		return $files;
	}

	function sort_files($a, $b)
	{
		if ($a['type'] != $b['type'])
			if ($a['type'] == 5 || $b['type'] == 2)
				return -1;
			else if ($a['type'] == 2 || $b['type'] == 5)
				return 1;
		else if ($a['type'] == 5)
			return strcmp(strtolower($a['name']), strtolower($b['name']));
		else if ($a['ext'] != $b['ext'])
			return strcmp($a['ext'], $b['ext']);
		else if ($a['stat'][7] != $b['stat'][7])
			return $a['stat'][7] > $b['stat'][7] ? -1 : 1;
		else
			return strcmp(strtolower($a['name']), strtolower($b['name']));
		return 0;
	}

	function download_file()
	{
		if ($this->options['inmemory'] == 0)
		{
			$this->error[] = "Can only use download_file() if archive is in memory. Redirect to file otherwise, it is faster.";
			return;
		}
		switch ($this->options['type'])
		{
		case "zip":
			header("Content-Type: application/zip");
			break;
		case "bzip":
			header("Content-Type: application/x-bzip2");
			break;
		case "gzip":
			header("Content-Type: application/x-gzip");
			break;
		case "tar":
			header("Content-Type: application/x-tar");
		}
		$header = "Content-Disposition: attachment; filename=\"";
		$header .= strstr($this->options['name'], "/") ? substr($this->options['name'], strrpos($this->options['name'], "/") + 1) : $this->options['name'];
		$header .= "\"";
		header($header);
		header("Content-Length: " . strlen($this->archive));
		header("Content-Transfer-Encoding: binary");
		header("Cache-Control: no-cache, must-revalidate, max-age=60");
		header("Expires: Sat, 01 Jan 2000 12:00:00 GMT");
		print($this->archive);
	}
}

class tar_file extends archive
{
	function tar_file($name)
	{
		$this->archive($name);
		$this->options['type'] = "tar";
	}

	function create_tar()
	{
		$pwd = getcwd();
		chdir($this->options['basedir']);

		foreach ($this->files as $current)
		{
			if ($current['name'] == $this->options['name'])
				continue;
			if (strlen($current['name2']) > 99)
			{
				$path = substr($current['name2'], 0, strpos($current['name2'], "/", strlen($current['name2']) - 100) + 1);
				$current['name2'] = substr($current['name2'], strlen($path));
				if (strlen($path) > 154 || strlen($current['name2']) > 99)
				{
					$this->error[] = "Could not add {$path}{$current['name2']} to archive because the filename is too long.";
					continue;
				}
			}
			$block = pack("a100a8a8a8a12a12a8a1a100a6a2a32a32a8a8a155a12", $current['name2'], sprintf("%07o", 
				$current['stat'][2]), sprintf("%07o", $current['stat'][4]), sprintf("%07o", $current['stat'][5]), 
				sprintf("%011o", $current['type'] == 2 ? 0 : $current['stat'][7]), sprintf("%011o", $current['stat'][9]), 
				"        ", $current['type'], $current['type'] == 2 ? @readlink($current['name']) : "", "ustar ", " ", 
				"Unknown", "Unknown", "", "", !empty ($path) ? $path : "", "");

			$checksum = 0;
			for ($i = 0; $i < 512; $i++)
				$checksum += ord(substr($block, $i, 1));
			$checksum = pack("a8", sprintf("%07o", $checksum));
			$block = substr_replace($block, $checksum, 148, 8);

			if ($current['type'] == 2 || $current['stat'][7] == 0)
				$this->add_data($block);
			else if ($fp = @fopen($current['name'], "rb"))
			{
				$this->add_data($block);
				while ($temp = fread($fp, 1048576))
					$this->add_data($temp);
				if ($current['stat'][7] % 512 > 0)
				{
					$temp = "";
					for ($i = 0; $i < 512 - $current['stat'][7] % 512; $i++)
						$temp .= "\0";
					$this->add_data($temp);
				}
				fclose($fp);
			}
			else
				$this->error[] = "Could not open file {$current['name']} for reading. It was not added.";
		}

		$this->add_data(pack("a1024", ""));

		chdir($pwd);

		return 1;
	}

	function extract_files()
	{
		$pwd = getcwd();
		chdir($this->options['basedir']);

		if ($fp = $this->open_archive())
		{
			if ($this->options['inmemory'] == 1)
				$this->files = array ();

			while ($block = fread($fp, 512))
			{
				$temp = unpack("a100name/a8mode/a8uid/a8gid/a12size/a12mtime/a8checksum/a1type/a100symlink/a6magic/a2temp/a32temp/a32temp/a8temp/a8temp/a155prefix/a12temp", $block);
				$file = array (
					'name' => $temp['prefix'] . $temp['name'],
					'stat' => array (
						2 => $temp['mode'],
						4 => octdec($temp['uid']),
						5 => octdec($temp['gid']),
						7 => octdec($temp['size']),
						9 => octdec($temp['mtime']),
					),
					'checksum' => octdec($temp['checksum']),
					'type' => $temp['type'],
					'magic' => $temp['magic'],
				);
				if ($file['checksum'] == 0x00000000)
					break;
				else if (substr($file['magic'], 0, 5) != "ustar")
				{
					$this->error[] = "This script does not support extracting this type of tar file.";
					break;
				}
				$block = substr_replace($block, "        ", 148, 8);
				$checksum = 0;
				for ($i = 0; $i < 512; $i++)
					$checksum += ord(substr($block, $i, 1));
				if ($file['checksum'] != $checksum)
					$this->error[] = "Could not extract from {$this->options['name']}, it is corrupt.";

				if ($this->options['inmemory'] == 1)
				{
					$file['data'] = fread($fp, $file['stat'][7]);
					fread($fp, (512 - $file['stat'][7] % 512) == 512 ? 0 : (512 - $file['stat'][7] % 512));
					unset ($file['checksum'], $file['magic']);
					$this->files[] = $file;
				}
				else if ($file['type'] == 5)
				{
					if (!is_dir($file['name']))
						mkdir($file['name'], $file['stat'][2]);
				}
				else if ($this->options['overwrite'] == 0 && file_exists($file['name']))
				{
					$this->error[] = "{$file['name']} already exists.";
					continue;
				}
				else if ($file['type'] == 2)
				{
					symlink($temp['symlink'], $file['name']);
					chmod($file['name'], $file['stat'][2]);
				}
				else if ($new = @fopen($file['name'], "wb"))
				{
					fwrite($new, fread($fp, $file['stat'][7]));
					fread($fp, (512 - $file['stat'][7] % 512) == 512 ? 0 : (512 - $file['stat'][7] % 512));
					fclose($new);
					chmod($file['name'], $file['stat'][2]);
				}
				else
				{
					$this->error[] = "Could not open {$file['name']} for writing.";
					continue;
				}
				chown($file['name'], $file['stat'][4]);
				chgrp($file['name'], $file['stat'][5]);
				touch($file['name'], $file['stat'][9]);
				unset ($file);
			}
		}
		else
			$this->error[] = "Could not open file {$this->options['name']}";

		chdir($pwd);
	}

	function open_archive()
	{
		return @fopen($this->options['name'], "rb");
	}
}

class gzip_file extends tar_file
{
	function gzip_file($name)
	{
		$this->tar_file($name);
		$this->options['type'] = "gzip";
	}

	function create_gzip()
	{
		if ($this->options['inmemory'] == 0)
		{
			$pwd = getcwd();
			chdir($this->options['basedir']);
			if ($fp = gzopen($this->options['name'], "wb{$this->options['level']}"))
			{
				fseek($this->archive, 0);
				while ($temp = fread($this->archive, 1048576))
					gzwrite($fp, $temp);
				gzclose($fp);
				chdir($pwd);
			}
			else
			{
				$this->error[] = "Could not open {$this->options['name']} for writing.";
				chdir($pwd);
				return 0;
			}
		}
		else
			$this->archive = gzencode($this->archive, $this->options['level']);

		return 1;
	}

	function open_archive()
	{
		return @gzopen($this->options['name'], "rb");
	}
}

class bzip_file extends tar_file
{
	function bzip_file($name)
	{
		$this->tar_file($name);
		$this->options['type'] = "bzip";
	}

	function create_bzip()
	{
		if ($this->options['inmemory'] == 0)
		{
			$pwd = getcwd();
			chdir($this->options['basedir']);
			if ($fp = bzopen($this->options['name'], "wb"))
			{
				fseek($this->archive, 0);
				while ($temp = fread($this->archive, 1048576))
					bzwrite($fp, $temp);
				bzclose($fp);
				chdir($pwd);
			}
			else
			{
				$this->error[] = "Could not open {$this->options['name']} for writing.";
				chdir($pwd);
				return 0;
			}
		}
		else
			$this->archive = bzcompress($this->archive, $this->options['level']);

		return 1;
	}

	function open_archive()
	{
		return @bzopen($this->options['name'], "rb");
	}
}

class zip_file extends archive
{
	function zip_file($name)
	{
		$this->archive($name);
		$this->options['type'] = "zip";
	}

	function create_zip()
	{
		$files = 0;
		$offset = 0;
		$central = "";

		if (!empty ($this->options['sfx']))
			if ($fp = @fopen($this->options['sfx'], "rb"))
			{
				$temp = fread($fp, filesize($this->options['sfx']));
				fclose($fp);
				$this->add_data($temp);
				$offset += strlen($temp);
				unset ($temp);
			}
			else
				$this->error[] = "Could not open sfx module from {$this->options['sfx']}.";

		$pwd = getcwd();
		chdir($this->options['basedir']);

		foreach ($this->files as $current)
		{
			if ($current['name'] == $this->options['name'])
				continue;

			$timedate = explode(" ", date("Y n j G i s", $current['stat'][9]));
			$timedate = ($timedate[0] - 1980 << 25) | ($timedate[1] << 21) | ($timedate[2] << 16) |
				($timedate[3] << 11) | ($timedate[4] << 5) | ($timedate[5]);

			$block = pack("VvvvV", 0x04034b50, 0x000A, 0x0000, (isset($current['method']) || $this->options['method'] == 0) ? 0x0000 : 0x0008, $timedate);

			if ($current['stat'][7] == 0 && $current['type'] == 5)
			{
				$block .= pack("VVVvv", 0x00000000, 0x00000000, 0x00000000, strlen($current['name2']) + 1, 0x0000);
				$block .= $current['name2'] . "/";
				$this->add_data($block);
				$central .= pack("VvvvvVVVVvvvvvVV", 0x02014b50, 0x0014, $this->options['method'] == 0 ? 0x0000 : 0x000A, 0x0000,
					(isset($current['method']) || $this->options['method'] == 0) ? 0x0000 : 0x0008, $timedate,
					0x00000000, 0x00000000, 0x00000000, strlen($current['name2']) + 1, 0x0000, 0x0000, 0x0000, 0x0000, $current['type'] == 5 ? 0x00000010 : 0x00000000, $offset);
				$central .= $current['name2'] . "/";
				$files++;
				$offset += (31 + strlen($current['name2']));
			}
			else if ($current['stat'][7] == 0)
			{
				$block .= pack("VVVvv", 0x00000000, 0x00000000, 0x00000000, strlen($current['name2']), 0x0000);
				$block .= $current['name2'];
				$this->add_data($block);
				$central .= pack("VvvvvVVVVvvvvvVV", 0x02014b50, 0x0014, $this->options['method'] == 0 ? 0x0000 : 0x000A, 0x0000,
					(isset($current['method']) || $this->options['method'] == 0) ? 0x0000 : 0x0008, $timedate,
					0x00000000, 0x00000000, 0x00000000, strlen($current['name2']), 0x0000, 0x0000, 0x0000, 0x0000, $current['type'] == 5 ? 0x00000010 : 0x00000000, $offset);
				$central .= $current['name2'];
				$files++;
				$offset += (30 + strlen($current['name2']));
			}
			else if ($fp = @fopen($current['name'], "rb"))
			{
				$temp = fread($fp, $current['stat'][7]);
				fclose($fp);
				$crc32 = crc32($temp);
				if (!isset($current['method']) && $this->options['method'] == 1)
				{
					$temp = gzcompress($temp, $this->options['level']);
					$size = strlen($temp) - 6;
					$temp = substr($temp, 2, $size);
				}
				else
					$size = strlen($temp);
				$block .= pack("VVVvv", $crc32, $size, $current['stat'][7], strlen($current['name2']), 0x0000);
				$block .= $current['name2'];
				$this->add_data($block);
				$this->add_data($temp);
				unset ($temp);
				$central .= pack("VvvvvVVVVvvvvvVV", 0x02014b50, 0x0014, $this->options['method'] == 0 ? 0x0000 : 0x000A, 0x0000,
					(isset($current['method']) || $this->options['method'] == 0) ? 0x0000 : 0x0008, $timedate,
					$crc32, $size, $current['stat'][7], strlen($current['name2']), 0x0000, 0x0000, 0x0000, 0x0000, 0x00000000, $offset);
				$central .= $current['name2'];
				$files++;
				$offset += (30 + strlen($current['name2']) + $size);
			}
			else
				$this->error[] = "Could not open file {$current['name']} for reading. It was not added.";
		}

		$this->add_data($central);

		$this->add_data(pack("VvvvvVVv", 0x06054b50, 0x0000, 0x0000, $files, $files, strlen($central), $offset,
			!empty ($this->options['comment']) ? strlen($this->options['comment']) : 0x0000));

		if (!empty ($this->options['comment']))
			$this->add_data($this->options['comment']);

		chdir($pwd);

		return 1;
	}
} ?>

<?
if (!defined('BASEPATH')) exit('No direct script access allowed');
##############################################################
# Class Unzip v2.6
#
#  @package     unzip
#  @subpackage  Library
#  @category    Archief
#  @author      Jaapio (fphpcode.nl)
#  @copyright   Copyright (c) 2007, fphpcode.nl
#  @license        http://www.gnu.org/licenses/lgpl.html
#  @version     1.0.0-alpha
#  @inpiredFrom: Alexandre Tedeschi (d) (alexandrebr at gmail dot com)
#
#  Objective:
#    This class allows programmer to easily unzip files on the fly.
#
#  Requirements:
#    This class requires extension ZLib Enabled. It is default
#    for most site hosts around the world, and for the PHP Win32 dist.
#
#  To do:
#   * Error handling
#   * Write a PHP-Side gzinflate, to completely avoid any external extensions
#   * Write other decompress algorithms
#
#  If you modify this class, or have any ideas to improve it, please contact me!
#  You are allowed to redistribute this class, if you keep my name and contact e-mail on it.
#
#  PLEASE! IF YOU USE THIS CLASS IN ANY OF YOUR PROJECTS, PLEASE LET ME KNOW!
#  If you have problems using it, don't think twice before contacting me!
#
##############################################################

if(!function_exists('file_put_contents')){
    // If not PHP5, creates a compatible function
    Function file_put_contents($file, $data){
        if($tmp = fopen($file, "w")){
            fwrite($tmp, $data);
            fclose($tmp);
            return true;
        }
        echo "<b>file_put_contents:</b> Cannot create file $file<br>";
        return false;
    }
}

class Unzip{
    Function getVersion(){
        return "2.6";
    }
    var $fileName          = '';
    var $compressedList    = Array(); // You will problably use only this one!
    var $centralDirList    = Array(); // Central dir list... It's a kind of 'extra attributes' for a set of files
    var $endOfCentral      = Array(); // End of central dir, contains ZIP Comments
    var $info              = Array();
    var $error             = Array();
    var $targetDir         = false;
    var $baseDir           = "";
    var $maintainStructure = true;
    var $applyChmod        = 0777;
    var $fh;
    var $zipSignature = "\x50\x4b\x03\x04"; // local file header signature
    var $dirSignature = "\x50\x4b\x01\x02"; // central dir header signature
    var $dirSignatureE= "\x50\x4b\x05\x06"; // end of central dir signature
    
    // --------------------------------------------------------------------
    /**
     * Constructor
     *
     * @access    Public
     * @param     string
     * @return    none
     */
    Function Unzip($props = array())
    {
        if (count($props) > 0)
        {
            $this->initialize($props);
        }
        
        //log_message('debug', "Unzip Class Initialized");
    }
    // --------------------------------------------------------------------
    
    /**
     * initialize image preferences
     *
     * @access    public
     * @param    array
     * @return    void
     */    
    function initialize($props = array())
    {
        /*
         * Convert array elements into class variables
         */
        if (count($props) > 0)
        {
            foreach ($props as $key => $val)
            {
                $this->$key = $val;
            }
        }
    }
    // --------------------------------------------------------------------
    /**
     * List all files in archive.
     *
     * @access    Public
     * @param     boolean
     * @return    mixed
     */    
    Function getList($stopOnFile=false){
        if(sizeof($this->compressedList)){
            $this->debugMsg(1, "Returning already loaded file list.");
            return $this->compressedList;
        }
        
        // Open file, and set file handler
        $fh = fopen($this->fileName, "r");
        $this->fh = &$fh;
        if(!$fh){
            $this->debugMsg(2, "Failed to load file: ".$this->fileName);
            return false;
        }
        
        $this->debugMsg(2, "Loading list from 'End of Central Dir' index list...");
        if(!$this->_loadFileListByEOF($fh, $stopOnFile)){
            $this->debugMsg(1, "Failed! Trying to load list looking for signatures...");
            if(!$this->_loadFileListBySignatures($fh, $stopOnFile)){
                $this->debugMsg(1, "Failed! Could not find any valid header.");
                $this->debugMsg(2, "ZIP File is corrupted or empty");
                return false;
            }
        }    
        return $this->compressedList;
    }
    
    // --------------------------------------------------------------------
    /**
     * Unzip file in archive.
     *
     * @access    Public
     * @param     string, boolean
     * @return    Unziped file.
     */    
    Function unzipFile($compressedFileName, $targetFileName=false){
        if(!sizeof($this->compressedList)){
            $this->debugMsg(1, "Trying to unzip before loading file list... Loading it!");
            $this->getList(false, $compressedFileName);
        }
        
        $fdetails = &$this->compressedList[$compressedFileName];
        if(!isset($this->compressedList[$compressedFileName])){
            $this->debugMsg(2, "File '<b>$compressedFileName</b>' is not compressed in the zip.");
            return false;
        }
        if(substr($compressedFileName, -1) == "/"){
            $this->debugMsg(2, "Trying to unzip a folder name '<b>$compressedFileName</b>'.");
            return false;
        }
        if(!$fdetails['uncompressed_size']){
            $this->debugMsg(1, "File '<b>$compressedFileName</b>' is empty.");
            return $targetFileName?
                file_put_contents($targetFileName, ""):
                "";
        }
        
        fseek($this->fh, $fdetails['contents-startOffset']);
        $ret = $this->uncompress(
                fread($this->fh, $fdetails['compressed_size']),
                $fdetails['compression_method'],
                $fdetails['uncompressed_size'],
                $targetFileName
            );
        if($this->applyChmod && $targetFileName)
            chmod($targetFileName, 0644);
        
        return $ret;
    }
    
    // --------------------------------------------------------------------
    /**
     * Unzip all files in archive.
     *
     * @access    Public
     * @param     none
     * @return    none
     */

    Function unzipAll(){
        if($this->targetDir === false)
            $this->debugMsg(2, "No target dir set");
        
        $lista = $this->getList();

        if(sizeof($lista))
          foreach($lista as $file=>$trash){
            $dirname  = dirname($file);
            $outDN    = $this->targetDir."/".$dirname;
            
            if(substr($dirname, 0, strlen($this->baseDir)) != $this->baseDir)
                continue;
            
            if(!is_dir($outDN) && $this->maintainStructure){
                $str = "";
                $folders = explode("/", $dirname);
                foreach($folders as $folder){
                    $str = $str?$str."/".$folder:$folder;
                    if(!is_dir($this->targetDir."/".$str)){
                        $this->debugMsg(1, "Creating folder: ".$this->targetDir."/".$str);
                        mkdir($this->targetDir."/".$str);
                        if($this->applyChmod)
                            chmod($this->targetDir."/".$str, $this->applyChmod);
                    }
                }
            }
            if(substr($file, -1, 1) == "/")
                continue;

            $this->maintainStructure?
                $this->unzipFile($file, $this->targetDir."/".$file):
                $this->unzipFile($file, $this->targetDir."/".basename($file));
        }
    }

    // --------------------------------------------------------------------
    /**
     * Free the file resource.
     *
     * @access    Public
     * @param     none
     * @return    none
     */
    
    function close(){     // Free the file resource
        if($this->fh)
            fclose($this->fh);
    }
    // --------------------------------------------------------------------
    /**
     * Free the file resource Automatic destroy.
     *
     * @access    Public
     * @param     none
     * @return    none
     */
    
    function __destroy(){
        $this->close();
    }

    // --------------------------------------------------------------------
    /**
     * Show error messages
     *
     * @access    public
     * @param    string
     * @return    string
     */    
    function display_errors($level = 2, $open = '<p>', $close = '</p>')
    {    
        $str = '';
        if($level == 1)
        foreach ($this->info as $val)
        {
            $str .= $open.$val.$close;
        }

        if($level == 2)
        foreach ($this->error as $val)
        {
            $str .= $open.$val.$close;
        }
    
        return $str;
    }
    
    // --------------------------------------------------------------------
    /**
     * Uncompress file. And save it to the targetFile.
     *
     * @access    Private
     * @param     Filecontent, int, int, boolean
     * @return    none
     */
    function uncompress($content, $mode, $uncompressedSize, $targetFileName=false){
        switch($mode){
            case 0:
                return $targetFileName?file_put_contents($targetFileName, $content):$content;
            case 1:
                $this->debugMsg(2, "Shrunk mode is not supported... yet?");
                return false;
            case 2:
            case 3:
            case 4:
            case 5:
                $this->debugMsg(2, "Compression factor ".($mode-1)." is not supported... yet?");
                return false;
            case 6:
                $this->debugMsg(2, "Implode is not supported... yet?");
                return false;
            case 7:
                $this->debugMsg(2, "Tokenizing compression algorithm is not supported... yet?");
                return false;
            case 8:
                // Deflate
                return $targetFileName?
                    file_put_contents($targetFileName, gzinflate($content, $uncompressedSize)):
                    gzinflate($content, $uncompressedSize);
            case 9:
                $this->debugMsg(2, "Enhanced Deflating is not supported... yet?");
                return false;
            case 10:
                $this->debugMsg(2, "PKWARE Date Compression Library Impoloding is not supported... yet?");
                return false;
           case 12:
               // Bzip2
               return $targetFileName?
                   file_put_contents($targetFileName, bzdecompress($content)):
                   bzdecompress($content);
            case 18:
                $this->debugMsg(2, "IBM TERSE is not supported... yet?");
                return false;
            default:
                $this->debugMsg(2, "Unknown uncompress method: $mode");
                return false;
        }
    }
    
    // --------------------------------------------------------------------
    /**
     * Save messages
     *
     * @access    Private
     * @param    string
     * @return    none
     */    

    function debugMsg($level, $string){
            if($level == 1)
                $this->error[] = "<b style='color: #777'>dUnzip2:</b> $string<br>";
            if($level == 2)
                $this->info[] = "<b style='color: #F00'>dUnzip2:</b> $string<br>";
    }
    

    Function _loadFileListByEOF(&$fh, $stopOnFile=false){
        // Check if there's a valid Central Dir signature.
        // Let's consider a file comment smaller than 1024 characters...
        // Actually, it length can be 65536.. But we're not going to support it.
        
        for($x = 0; $x < 1024; $x++){
            fseek($fh, -22-$x, SEEK_END);
            
            $signature = fread($fh, 4);
            if($signature == $this->dirSignatureE){
                // If found EOF Central Dir
                $eodir['disk_number_this']   = unpack("v", fread($fh, 2)); // number of this disk
                $eodir['disk_number']        = unpack("v", fread($fh, 2)); // number of the disk with the start of the central directory
                $eodir['total_entries_this'] = unpack("v", fread($fh, 2)); // total number of entries in the central dir on this disk
                $eodir['total_entries']      = unpack("v", fread($fh, 2)); // total number of entries in
                $eodir['size_of_cd']         = unpack("V", fread($fh, 4)); // size of the central directory
                $eodir['offset_start_cd']    = unpack("V", fread($fh, 4)); // offset of start of central directory with respect to the starting disk number
                $zipFileCommentLenght        = unpack("v", fread($fh, 2)); // zipfile comment length
                $eodir['zipfile_comment']    = $zipFileCommentLenght[1]?fread($fh, $zipFileCommentLenght[1]):''; // zipfile comment
                $this->endOfCentral = Array(
                    'disk_number_this'=>$eodir['disk_number_this'][1],
                    'disk_number'=>$eodir['disk_number'][1],
                    'total_entries_this'=>$eodir['total_entries_this'][1],
                    'total_entries'=>$eodir['total_entries'][1],
                    'size_of_cd'=>$eodir['size_of_cd'][1],
                    'offset_start_cd'=>$eodir['offset_start_cd'][1],
                    'zipfile_comment'=>$eodir['zipfile_comment'],
                );
                
                // Then, load file list
                fseek($fh, $this->endOfCentral['offset_start_cd']);
                $signature = fread($fh, 4);
                
                while($signature == $this->dirSignature){
                    $dir['version_madeby']      = unpack("v", fread($fh, 2)); // version made by
                    $dir['version_needed']      = unpack("v", fread($fh, 2)); // version needed to extract
                    $dir['general_bit_flag']    = unpack("v", fread($fh, 2)); // general purpose bit flag
                    $dir['compression_method']  = unpack("v", fread($fh, 2)); // compression method
                    $dir['lastmod_time']        = unpack("v", fread($fh, 2)); // last mod file time
                    $dir['lastmod_date']        = unpack("v", fread($fh, 2)); // last mod file date
                    $dir['crc-32']              = fread($fh, 4);              // crc-32
                    $dir['compressed_size']     = unpack("V", fread($fh, 4)); // compressed size
                    $dir['uncompressed_size']   = unpack("V", fread($fh, 4)); // uncompressed size
                    $fileNameLength             = unpack("v", fread($fh, 2)); // filename length
                    $extraFieldLength           = unpack("v", fread($fh, 2)); // extra field length
                    $fileCommentLength          = unpack("v", fread($fh, 2)); // file comment length
                    $dir['disk_number_start']   = unpack("v", fread($fh, 2)); // disk number start
                    $dir['internal_attributes'] = unpack("v", fread($fh, 2)); // internal file attributes-byte1
                    $dir['external_attributes1']= unpack("v", fread($fh, 2)); // external file attributes-byte2
                    $dir['external_attributes2']= unpack("v", fread($fh, 2)); // external file attributes
                    $dir['relative_offset']     = unpack("V", fread($fh, 4)); // relative offset of local header
                    $dir['file_name']           = fread($fh, $fileNameLength[1]);                             // filename
                    $dir['extra_field']         = $extraFieldLength[1] ?fread($fh, $extraFieldLength[1]) :''; // extra field
                    $dir['file_comment']        = $fileCommentLength[1]?fread($fh, $fileCommentLength[1]):''; // file comment            
                    
                    // Convert the date and time, from MS-DOS format to UNIX Timestamp
                    $BINlastmod_date = str_pad(decbin($dir['lastmod_date'][1]), 16, '0', STR_PAD_LEFT);
                    $BINlastmod_time = str_pad(decbin($dir['lastmod_time'][1]), 16, '0', STR_PAD_LEFT);
                    $lastmod_dateY = bindec(substr($BINlastmod_date,  0, 7))+1980;
                    $lastmod_dateM = bindec(substr($BINlastmod_date,  7, 4));
                    $lastmod_dateD = bindec(substr($BINlastmod_date, 11, 5));
                    $lastmod_timeH = bindec(substr($BINlastmod_time,   0, 5));
                    $lastmod_timeM = bindec(substr($BINlastmod_time,   5, 6));
                    $lastmod_timeS = bindec(substr($BINlastmod_time,  11, 5));    
                    
                    $this->centralDirList[$dir['file_name']] = Array(
                        'version_madeby'=>$dir['version_madeby'][1],
                        'version_needed'=>$dir['version_needed'][1],
                        'general_bit_flag'=>str_pad(decbin($dir['general_bit_flag'][1]), 8, '0', STR_PAD_LEFT),
                        'compression_method'=>$dir['compression_method'][1],
                        'lastmod_datetime'  =>mktime($lastmod_timeH, $lastmod_timeM, $lastmod_timeS, $lastmod_dateM, $lastmod_dateD, $lastmod_dateY),
                        'crc-32'            =>str_pad(dechex(ord($dir['crc-32'][3])), 2, '0', STR_PAD_LEFT).
                                              str_pad(dechex(ord($dir['crc-32'][2])), 2, '0', STR_PAD_LEFT).
                                              str_pad(dechex(ord($dir['crc-32'][1])), 2, '0', STR_PAD_LEFT).
                                              str_pad(dechex(ord($dir['crc-32'][0])), 2, '0', STR_PAD_LEFT),
                        'compressed_size'=>$dir['compressed_size'][1],
                        'uncompressed_size'=>$dir['uncompressed_size'][1],
                        'disk_number_start'=>$dir['disk_number_start'][1],
                        'internal_attributes'=>$dir['internal_attributes'][1],
                        'external_attributes1'=>$dir['external_attributes1'][1],
                        'external_attributes2'=>$dir['external_attributes2'][1],
                        'relative_offset'=>$dir['relative_offset'][1],
                        'file_name'=>$dir['file_name'],
                        'extra_field'=>$dir['extra_field'],
                        'file_comment'=>$dir['file_comment'],
                    );
                    $signature = fread($fh, 4);
                }
                
                // If loaded centralDirs, then try to identify the offsetPosition of the compressed data.
                if($this->centralDirList) foreach($this->centralDirList as $filename=>$details){
                    $i = $this->_getFileHeaderInformation($fh, $details['relative_offset']);
                    $this->compressedList[$filename]['file_name']          = $filename;
                    $this->compressedList[$filename]['compression_method'] = $details['compression_method'];
                    $this->compressedList[$filename]['version_needed']     = $details['version_needed'];
                    $this->compressedList[$filename]['lastmod_datetime']   = $details['lastmod_datetime'];
                    $this->compressedList[$filename]['crc-32']             = $details['crc-32'];
                    $this->compressedList[$filename]['compressed_size']    = $details['compressed_size'];
                    $this->compressedList[$filename]['uncompressed_size']  = $details['uncompressed_size'];
                    $this->compressedList[$filename]['lastmod_datetime']   = $details['lastmod_datetime'];
                    $this->compressedList[$filename]['extra_field']        = $i['extra_field'];
                    $this->compressedList[$filename]['contents-startOffset']=$i['contents-startOffset'];
                    if(strtolower($stopOnFile) == strtolower($filename))
                        break;
                }
                return true;
            }
        }
        return false;
    }
    Function _loadFileListBySignatures(&$fh, $stopOnFile=false){
        fseek($fh, 0);
        
        $return = false;
        for(;;){
            $details = $this->_getFileHeaderInformation($fh);
            if(!$details){
                $this->debugMsg(1, "Invalid signature. Trying to verify if is old style Data Descriptor...");
                fseek($fh, 12 - 4, SEEK_CUR); // 12: Data descriptor - 4: Signature (that will be read again)
                $details = $this->_getFileHeaderInformation($fh);
            }
            if(!$details){
                $this->debugMsg(1, "Still invalid signature. Probably reached the end of the file.");
                break;
            }
            $filename = $details['file_name'];
            $this->compressedList[$filename] = $details;
            $return = true;
            if(strtolower($stopOnFile) == strtolower($filename))
                break;
        }
        
        return $return;
    }
    Function _getFileHeaderInformation(&$fh, $startOffset=false){
        if($startOffset !== false)
            fseek($fh, $startOffset);
        
        $signature = fread($fh, 4);
        if($signature == $this->zipSignature){
        
            // Get information about the zipped file
            $file['version_needed']     = unpack("v", fread($fh, 2)); // version needed to extract
            $file['general_bit_flag']   = unpack("v", fread($fh, 2)); // general purpose bit flag
            $file['compression_method'] = unpack("v", fread($fh, 2)); // compression method
            $file['lastmod_time']       = unpack("v", fread($fh, 2)); // last mod file time
            $file['lastmod_date']       = unpack("v", fread($fh, 2)); // last mod file date
            $file['crc-32']             = fread($fh, 4);              // crc-32
            $file['compressed_size']    = unpack("V", fread($fh, 4)); // compressed size
            $file['uncompressed_size']  = unpack("V", fread($fh, 4)); // uncompressed size
            $fileNameLength             = unpack("v", fread($fh, 2)); // filename length
            $extraFieldLength           = unpack("v", fread($fh, 2)); // extra field length
            $file['file_name']          = fread($fh, $fileNameLength[1]); // filename
            $file['extra_field']        = $extraFieldLength[1]?fread($fh, $extraFieldLength[1]):''; // extra field
            $file['contents-startOffset']= ftell($fh);
            
            // Bypass the whole compressed contents, and look for the next file
            fseek($fh, $file['compressed_size'][1], SEEK_CUR);
            
            // Convert the date and time, from MS-DOS format to UNIX Timestamp
            $BINlastmod_date = str_pad(decbin($file['lastmod_date'][1]), 16, '0', STR_PAD_LEFT);
            $BINlastmod_time = str_pad(decbin($file['lastmod_time'][1]), 16, '0', STR_PAD_LEFT);
            $lastmod_dateY = bindec(substr($BINlastmod_date,  0, 7))+1980;
            $lastmod_dateM = bindec(substr($BINlastmod_date,  7, 4));
            $lastmod_dateD = bindec(substr($BINlastmod_date, 11, 5));
            $lastmod_timeH = bindec(substr($BINlastmod_time,   0, 5));
            $lastmod_timeM = bindec(substr($BINlastmod_time,   5, 6));
            $lastmod_timeS = bindec(substr($BINlastmod_time,  11, 5));
            
            // Mount file table
            $i = Array(
                'file_name'         =>$file['file_name'],
                'compression_method'=>$file['compression_method'][1],
                'version_needed'    =>$file['version_needed'][1],
                'lastmod_datetime'  =>mktime($lastmod_timeH, $lastmod_timeM, $lastmod_timeS, $lastmod_dateM, $lastmod_dateD, $lastmod_dateY),
                'crc-32'            =>str_pad(dechex(ord($file['crc-32'][3])), 2, '0', STR_PAD_LEFT).
                                      str_pad(dechex(ord($file['crc-32'][2])), 2, '0', STR_PAD_LEFT).
                                      str_pad(dechex(ord($file['crc-32'][1])), 2, '0', STR_PAD_LEFT).
                                      str_pad(dechex(ord($file['crc-32'][0])), 2, '0', STR_PAD_LEFT),
                'compressed_size'   =>$file['compressed_size'][1],
                'uncompressed_size' =>$file['uncompressed_size'][1],
                'extra_field'       =>$file['extra_field'],
                'general_bit_flag'  =>str_pad(decbin($file['general_bit_flag'][1]), 8, '0', STR_PAD_LEFT),
                'contents-startOffset'=>$file['contents-startOffset']
            );
            return $i;
        }
        return false;
    }
}
?>