Location: PHPKode > projects > Aratix > aratix/admin/classes/Install.class.php
<?php
/*
** Aratix
** Version 0.1.0beta8 (Anubis)
**
** Autor: Manuel Burghammer
** E-Mail: hide@address.com
** Homepage: http://www.xitara.net
**
** File: Install.class.php - Version 0.1.0 build 438
** Position: /classes/
** Last Modified: 28.06.2006 - 22:58:37
*/

class Install{
	function __construct(){
/* Beim Aufruf der Klasse wird der Pfad
** sofort in eine lokale Variable geschrieben
** um ihn nicht mehrmals übergeben zu müssen
**
** $this->path
** Pfad, in dem die entpackten
** Dateien abgelegt werden. Im Normalfall
** ist das 'admin/install'
** und sollte nicht geändert werden.
** Da dieses noch nicht getestet
** wurde, sind die Auswirkungen
** nicht vorhersehbar
*/
		$this->path = realpath($GLOBALS['current_path'] . 'admin/install/');
		$this->uninstall_path = realpath($GLOBALS['current_path'] . 'admin/uninstall/');
		$this->db = $GLOBALS['db'];
	}
	function parse_xml($file){

/* Parsen des Files, das per $file
** übergeben wird.
** Das Objekt wird zurückgegeben und
** gleichzeitig lokal zur verfügung
** gestellt.
**
** $this->fullpath
** Installationspfad inkl. Unterordner
** für das aktuelle Modul/Block/Plugin
**
** $this->xml
** Enthält die geladene XML-Datei
*/
		$this->fullpath = $this->path . "/" . basename($file, ".zip");
		$this->xml = simplexml_load_file($this->fullpath . "/install.xml");

		return $this->xml;
	}
	function copy(){
		$this->update = FALSE;

/* Unterverzeichnisse anlegen, Dateien kopieren
** und XML-Datei für den Uninstaller
** erzeugen.
**
** $this->remove_path
** Array, das alle angelegten Pfade enthält
** Wird umgekehrt (array_reverse) in die XML-Datei
** geschrieben, um den Baum von oben nach unten
** zu löschen
**
** $this->remove_file
** Array, das alle installierten Dateien enthält
*/
		$this->remove_path = array(); // Array löschen bzw. initialisieren
		$this->remove_file = array(); // Array löschen bzw. initialisieren
		$this->db_entry = array(); // Array löschen bzw. initialisieren

/* Wenn kein SimpleXML-Objekt
** übergeben wird, dann $this->xml
** aus $this->parse_xml() übernehmen
*/
// 		if($xml == "")
			$xml = $this->xml;

/* Feststellen, ob die Erweiterung für
** die Version von Aratix geeignet ist
*/
		$min_version = $xml->aratix_min_version;
		$max_version = $xml->aratix_max_version;

/* Kompatiblität erhalten, falls Erweiterungen
** noch keine Angabe über die minimale und maximale
** Version von Aratix enthalten
*/
		if($min_version == "")
			$min_version = "0.1.0";
		if($max_version == "")
			$max_version = "0.1.9";

// 		echo $min_version . " -> " . $max_version . " -> " . $GLOBALS['config']->get('version') . " --> " . version_compare($GLOBALS['config']->get('version'), $min_version) . " -------> " . version_compare($GLOBALS['config']->get('version'), $max_version) . "<br>";

		if(version_compare($GLOBALS['config']->get('version'), $min_version, "lt") == 1){
			$installed['install'] = "to_low_version";
			$installed['act_version'] = $GLOBALS['config']->get('version');
			$installed['min_version'] = $min_version;

			$this->installed = $installed;
			return;
		}
		elseif(version_compare($GLOBALS['config']->get('version'), $max_version, "gt") == 1){
			$installed['install'] = "to_high_version";
			$installed['act_version'] = $GLOBALS['config']->get('version');
			$installed['max_version'] = $max_version;

			$this->installed = $installed;
			return;
		}

/* Feststellen, ob ein Update
** gemacht werden soll. Dazu wird
** in der Datenbank gelesen, ob
** ein ensprechender Eintrag
** vorhanden ist.
*/
		if($this->db->read(TB_PREFIX . $xml['art'] . "s", "id", "name='" . $xml->name . "'"))
			$this->update = TRUE;

/* String erzeugen für die Daten,
** die in die entsprechende Tabelle
** (blocks/modules/plugins) geschrieben
** werden.
*/
		$var = "name;;description;;install_date;;";

		if($xml['art'] != "layout")
			$var .= "admin;;";

		if($xml['art'] == "block") // Nur ein Block hat eine Position ;)
			$var .= "align;;position;;pages;;";

		$var .= "active;;version;;groups";

/* String erzeugen mit den Daten für
** Blöcke/Module/Plugins
** evtl. noch änderungen wegen
** Berechtigungen, Gruppen und Position
** nötig.
*/
		$data = $xml->name . ";;";											// Name von Block/Modul/Plugin
		$data .= html_entity_decode(utf8_decode($xml->description)) . ";;";	// Beschreibung
		$data .= "CURDATE();;";												// Installationsdatum

		if($xml['art'] != "layout")
			$data .= $xml->admin . ";;";									// Adminbereich vorhanden?

		if($xml['art'] == "block"){ 										// Nur ein Block hat eine Position
			$data .= "left;;";												// Ausrichtung, standardmässig links
			$data .= "99999;;";												// Position, 99999 sollte ganz unten sein
			$data .= ";;";													// Seiten
		}
		if(($xml['art'] == "block" && (string)$xml->name == "mainmenu") || ($xml['art'] == "layout" && (string)$xml->name == "default"))
			$data .= "true;;";												// Block Mainmenu und das Defaultlayout wird grundsätzlich bei der Installation aktiv.
		else
			$data .= "false;;";												// Alle anderen Erweiterungen ersteinmal inaktiv machen

		$data .= $xml->version . ";;";										// Version
		$data .= $xml->groups . ";;";										// Gruppen

/* Wenn Update, dann Versionen
** vergleichen. Falls Versionsnummern
** gleich sind, Dateien neu
** installieren und 'reinstall'
** zurückgeben.
**
** Falls die zu installierende
** Versionsnummer kleiner ist
** als die Installierte, fehlermeldung
** zurückgeben und Installation abbrechen
**
** Falls die installierte Version
** kleiner ist als die im
** Installationspaket angegebene
** 'old_version' (Das bezeichent, welche
** Version mindestens installiert sein
** muss, um das Update durchführen zu
** können), fehlermeldung zurückgeben
** und Installation abbrechen
*/

/* Debugausgabe, zum Löschen markiert */
// 		echo "<b>Update-Flag: " . $this->update . "</b><br>";
/* Debugausgabe Ende */

		if($this->update == TRUE){
			$act_version = $this->db->read(TB_PREFIX . $xml['art'] . "s", "version", "name='" . $xml->name . "'");
			if(version_compare((string)$xml->version, $act_version['version'], "eq")){

/* Bei einem Reinstall wird
** keine Änderung in der Datenbank
** vorgenommen.
**
** Alle Files werden gelöscht.
** Alle Files werden neu installiert.
*/

/* Debugausgabe, zum Löschen markiert */
// 				echo "<b>Reinstall " . $xml->name . " -> " . $xml->version . " :: " . $act_version['version'] . "</b><br>";
/* Debugausgabe Ende */
				$installed['install'] = "reinstall";
				$installed['version'] = (string)$xml->version;

				$this->delete_files();
			}
			else if(version_compare($xml->version, $act_version['version']) == 1){
/* Debugausgabe, zum Löschen markiert */
// 					echo "<b>Update " . $xml->name . " -> " . $xml->old_version . " :: " . $xml->version . " :: " . $act_version['version'] . "</b><br>";
// 					echo "<b>Update " . version_compare($xml->version, $act_version['version']) . " -> " . version_compare($xml->old_version, $act_version['version']) . "</b><br>";
// 					exit();
/* Debugausgabe Ende */

				if(version_compare($xml->old_version, $act_version['version']) != 1){

/* Bei einem Update wird
** die Eintragung in der
** Datenbank aktualisiert.
**
** Alle Files werden gelöscht
** Neue Files werden installiert
*/
					$this->db->update(TB_PREFIX . $xml['art'] . "s", $var, $data, "name='" . $xml->name . "'"); // Update der Datenbank

					$installed['install'] = "update";
					$installed['version'] = (string)$xml->version;
					$installed['old_version'] = (string)$xml->old_version;

					$this->delete_files();

/* Die Texte nach Sprache sortiert
** in die Datenbank schreiben
** und ggf. überflüssige Texte
** löschen
*/					if(isset($xml->sql->update->delete) && is_array($xml->sql->update->delete)){
						foreach($xml->sql->update->delete as $update){
							$this->db->delete(TB_PREFIX . $update['table'], $update . "='" . $update['value'] . "'");

/* Debugausgabe, zum Löschen markiert */
// 							echo $update['table'] . " - " . $update['value'] . " - " . $update . "<br />";
/* Debugausgabe Ende */
						}
					}
				}
				else{
					$installed['install'] = "wrong_version";
					$installed['version'] = (string)$xml->version;
					$installed['old_version'] = (string)$act_version['version'];
				}
			}

/* Wenn die Version kleiner
** als die angebene Mindest-
** version 'old_version' ist,
** wird eine Fehlermeldung
** ausgegeben
*/
			else if(version_compare($xml->old_version, $act_version['version'], "gt")){

/* Debugausgabe, zum Löschen markiert */
// 				echo "<b>Fehler " . $xml->name . " -> " . $xml->old_version . " :: " . $act_version['version'] . "</b><br>";
/* Debugausgabe Ende */

				$installed['install'] = "downgrade";
			}
		}
		else{

/* Bei einer Neuinstallation
** wird ein neuer Eintrag in
** der Datenbank vorgenommen.
**
** Alle Files werden installiert
*/

/* Debugausgabe, zum Löschen markiert */
// 			echo "<b>Installation " . $xml->name . "</b><br>";
/* Debugausgabe Ende */
			$this->new_id = $this->db->write(TB_PREFIX . $xml['art'] . "s", $var, $data); // Eintragen in die Datenbank
			$this->art = (string)$xml['art'];
			$installed['install'] = "install";
		}

/* Debugausgabe, zum Löschen markiert */
// 		echo TB_PREFIX . $xml['art'] . "s" . " -> " . $data . "<br /><br />\n";
/* Debugausgabe Ende */

/* SQL-Part auslesen, falls vorhanden.
** jede Zeile wird in einen Befehl
** umgewandelt und in die entsprechende
** Tabelle eingefügt.
**
** Die genaue Struktur kann der
** Beispieldatei für Module/Blöcke/Plugins
** entnommen werden.
*/

/* Zuerst die Einträge für die
** Sprache auslesen und in die
** Datenbank eintragen
*/
		if(isset($xml->sql)){
			$counter = 0;
			foreach($xml->sql->install->lang as $sql_data){
				$table = TB_LANG . "_" . $xml->sql->install->lang[$counter]['table'];
				$data = html_entity_decode(utf8_decode($xml->sql->install->lang[$counter]));
				$val = $xml['art'] . "_" . $xml->name;

				if($xml->sql->install->lang[$counter]['value'] != "") // Wenn 'value' nicht leer ist ...
					$val .= "_" . $xml->sql->install->lang[$counter]['value']; // ... dann einen Unterstrich ausgeben ...
				else
					$this->extension['name'] = $data; // ... sonst Namen in das Array für Smarty schreiben

				$counter++;

/* Eintragen der Werte
** in die Datenbank und
** erzeugen des Arrays für
** die XML-Datei des Uninstallers
*/
				$this->db->write($table, "var;;text", $val . ";;" . $data);
				$this->db_entry[] = "$table;;$val";

/* Debugausgabe, zum Löschen markiert */
// 				echo "Table: $table - ";
// 				echo "Val: $val - ";
// 				echo "Data: $data<br>";
/* Debugausgabe Ende */
			}

/* Erzeugen der neuen
** Tabellen
*/
			foreach($xml->sql->create as $sql_create){
				$sql_query = "CREATE TABLE " . TB_PREFIX . $sql_create['table'] . " (";
				$sql_count = 0;

/* Spalten auslesen und
** in den String schreiben
*/
				foreach($sql_create->row as $sql_row){
					$sql_query .= $sql_row . " " . $sql_row['art'];

					if($sql_row['size'] != "")
						$sql_query .= "(" . $sql_row['size'] . ")";

					$sql_query .= " " . $sql_row['flag'];

					if(count($sql_create->row) - 1 > $sql_count++)
						$sql_query .= ", ";
				}

/* Keys auslesen und an
** den Query-String anhängen
*/
				foreach($sql_create->key as $sql_key){
					$sql_query .= ", " . $sql_key['art'] . " (" . $sql_key . ")";
				}
				$sql_query .= ") ";

/* Wenn ein Typ angegeben
** ist, den TYPE anhängen
*/
				if($sql_create['type'] != "")
					$sql_query .= "TYPE=" . $sql_create['type'] . ";";

/* Eintragung in die Datenbank
*/
				$this->db->query($sql_query);

/* Debugausgabe, zum Löschen markiert */
// 				echo "<br>Query: $sql_query<br><br>";
/* Debugausgabe Ende */

/* Daten in die neue Tabelle
** schreiben
*/
				$sql_count = 0;
				$sql_query = "INSERT INTO " . TB_PREFIX . $sql_create['table'] . " (";

				foreach($sql_create->insert as $sql_insert){
					$sql_query .= $sql_insert['row'];

					if(count($sql_create->insert) - 1 > $sql_count++)
						$sql_query .= ", ";
				}
				$sql_query .= ") VALUES (";
				$sql_count = 0;

				foreach($sql_create->insert as $sql_insert){
					$sql_query .= "'" . $sql_insert . "'";

					if(count($sql_create->insert) - 1 > $sql_count++)
						$sql_query .= ", ";
				}
				$sql_query .= ");";

/* Eintragung in die Datenbank
*/
				$this->db->query($sql_query);

/* Debugausgabe, zum Löschen markiert */
// 				echo "<br>Insert: $sql_query<br><br>";
/* Debugausgabe Ende */

/* XML-Daten für das Löschen
** der neuen Tabelle erzeugen
*/
				$this->db_entry[] = TB_PREFIX . $sql_create['table'] . ";;KILL";
			}
			$this->extension['version'] = (string)$xml->version;
		}
/* Wurzelverzeichnis des Modules/Blocks/Plugins
** auslesen und alle benötigten Dateien
** kopieren.
*/
		if($xml['art'] == "layout"){
			$full_dir = $GLOBALS['config']->get('path') . '/templates/' . $xml->name; // Zielordner erzeugen
			$this->make_dir($GLOBALS['config']->get('path') . '/templates_c/' . $xml->name);
		}
		else
			$full_dir = $GLOBALS['config']->get('path') . '/' . $xml['art'] . 's/' . $xml['art'] . "_" . $xml->name; // Zielordner erzeugen

		$this->make_dir($full_dir); // Ordner anlegen

/* Unterordner aus  $full_dir
** auslesen und in einer Schleife
** Ordner um Installationspfad erzeugen
*/
		$this->d = dir($this->fullpath);
		while(false !== ($entry = $this->d->read())){
			if(!is_dir($this->fullpath . "/" . $entry) && $entry != "." && $entry != ".." && $entry != "install.xml"){

/* Array für Uninstaller erzeugen um Files löschen zu können
**
** Um alle Files restlos zu entfernen,
** wird jeder Zielpfad in eine XML-Datei
** geschrieben und im Ordner 'admin/uninstall'
** abgelegt
*/
				$this->copy_file($this->fullpath . "/" . $entry, $full_dir . "/" . $entry);
				$this->remove_file[] = $full_dir . "/" . $entry;
			}
		}

/* Adminverzeichnis auslesen,
** falls vorhanden
*/
		$dirs = array('', 'css', 'images', 'help', 'help/css', 'javascript'); // Array mit Unterverzeichnissen erzeugen

/* Schleife für alle Unterordner (aus Array)
** durchlaufen und jeden Unterordner im
** Installationspfad anlegen und entsprechende
** Rechte geben.
*/
		foreach($dirs as $dir){
			if(is_dir($this->fullpath . "/admin/" . $dir)){
				$this->d = dir($this->fullpath . "/admin/" . $dir); // Adminbereich und Unterverzeichnisse auslesen
				$full_dir = '/' . $dir; // Zielpfad erzeugen
				$this->make_dir($full_dir); // Zielpfad anlegen

/* Alle Adminverzeichnisse durchlaufen
** und die enthaltenen Dateien
** an ihre Zielorte kopieren
*/
				while(false !== ($entry = $this->d->read())){
					if(!is_dir($this->fullpath . "/admin/" . $dir . "/" . $entry) && $entry != "." && $entry != ".."){
						$this->copy_file($this->fullpath . "/admin/" . $dir . "/" . $entry, $full_dir . "/" . $entry);
						$this->remove_file[] = $full_dir . "/" . $entry; // Array erweitern für Uninstaller
					}
				}
			}
		}

/* Restliche Verzeichnisse
** auslesen. Kommentare siehe
** Zeile 428ff: Adminverzeichnis auslesen
*/
		$dirs = array('css', 'images', 'images/button', 'images/letter', 'images/letter/capital', 'images/letter/number', 'images/letter/sign', 'images/letter/small', 'help', 'help/css', 'javascript');

		foreach($dirs as $dir){
			if(is_dir($this->fullpath . "/" . $dir)){
				$this->d = dir($this->fullpath . "/" . $dir);
				$this->make_dir($full_dir . '/' . $dir);

				while(false !== ($entry = $this->d->read())){
					if(!is_dir($this->fullpath . "/" . $dir . "/" . $entry) && $entry != "." && $entry != ".."){
						$this->copy_file($this->fullpath . "/" . $dir . "/" . $entry, $full_dir . '/' . $dir . "/" . $entry);
						$this->remove_file[] = $full_dir . '/' . $dir . "/" . $entry;
					}
				}
			}
		}

/* Core-Verzeichnisse auslesen.
**
** Dateien, die im Ordner /core/
** bzw. im Ordner /admin/core/
** liegen, werden, je nach Dateinamen,
** in die Ordner /classes, /admin/classes,
** /inc oder /admin/inc Kopiert
**
** Sollte nur für Erweiterungen verwendet
** werden, die tief ins System eingreifen
** müssen. Ansonsten sollten alle Dateien
** im entsprechenden Verzeichnis
** /{art}/{art}_{name} abgelegt werden.
**
** Aus diesem Grund wird diese Funktion auch
** nicht offiziell Dokumentiert
**
** Entscheiden ist, das bei Klassendateien
** ({name}.class.php) der erste Buchstabe
** gross ist, da sonst der Autoloader nicht
** greift. Bei Includes ({name}.inc.php)
** Muss als ersten Buchstaben einen Klein-
** buchstaben haben.
**
** Das erste Wort im Namen dieser Dateien
** muss zwingend der Name der Erweiterung
** sein, ansonsten wird die Datei nicht
** kopiert, bzw. wird diese umbenannt.
*/
		$dirs = array('core', 'admin/core', 'admin/templates');

		foreach($dirs as $dir){
			if(is_dir($this->fullpath . "/" . $dir)){
				$this->d = dir($this->fullpath . "/" . $dir);
				$full_dir = $GLOBALS['config']->get('path');
				$dir_part = explode("/", $dir);

				while(false !== ($entry = $this->d->read())){
					if(!is_dir($this->fullpath . "/" . $dir . "/" . $entry) && $entry != "." && $entry != ".."){
						if(strpos(strtolower($entry), (string)$xml->name) !== FALSE){
							if(strpos($entry, ".inc.") !== FALSE)
								$target_folder = "/" . $dir_part[0] . "/inc";
							if(strpos($entry, ".class.") !== FALSE)
								$target_folder = "/" . $dir_part[0] . "/classes";
							if(strpos($entry, ".tpl") !== FALSE)
								$target_folder = "/" . $dir_part[0] . "/templates";

							$this->copy_file($this->fullpath . "/" . $dir . "/" . $entry, $full_dir . $target_folder . "/" . $entry);
							$this->remove_file[] = $full_dir . $target_folder . "/" . $entry;
						}
					}
				}
			}
		}

/* Ordner Anlegen, die in der install.xml
** aufgeführt sind.
**
** <folder>
**		<create>{Ordnername}</create>
** </folder>
*/
		if(isset($xml->folder->create)){
			foreach($xml->folder->create as $new_folder){
				$full_dir = $GLOBALS['config']->get('path') . '/' . $xml['art'] . 's/' . $xml['art'] . "_" . $xml->name . "/" . $new_folder;
				$this->make_dir($full_dir);
			}
		}

/* Modulnamen nach erfolgreicher
** Installation in ein Array schreiben
** um es im Template ausgeben zu können
*/
		$installed['art'] = ucfirst($xml['art']);
		$installed['name'] = (string)$xml->name;

/* XML-Datei für Uninstaller
** erzeugen und schreiben
*/
		$this->write_xml();
		$this->installed = $installed;

/* Archiv der Erweiterung
** löschen
*/
		if(get('page') != "install")
			unlink($GLOBALS['config']->get('path') . $GLOBALS['config']->get('admin_folder') . '/' . $this->archive);
	}
	function copy_file($source, $target){

/* Kopieren der Dateien.
**
** $source
** Quelle der Datei
**
** $target
** Ziel der Datei
*/

		rename($source, $target);
		chmod($target, 0644);

/* Debugausgabe, zum Löschen markiert */
// 		echo "Quelle: $source<br>";
// 		echo "Ziel: $target<br><br>";
/* Debugausgabe Ende */
	}
	function delete_files($uninstall_file = ''){

/* Alle Dateien löschen,
** die im entsprechenden
** Array eingetragen sind
*/
		if($uninstall_file == ""){
			$uninstaller = simplexml_load_file($this->uninstall_path . "/" . $this->xml['art'] . "_" . $this->xml->name . ".xml");
			unlink($this->uninstall_path . "/" . $this->xml['art'] . "_" . $this->xml->name . ".xml");
		}
		else{
			$uninstaller = simplexml_load_file($GLOBALS['config']->get('path') . $GLOBALS['config']->get('admin_folder') . '/uninstall/' . $uninstall_file);
			unlink($GLOBALS['config']->get('path') . $GLOBALS['config']->get('admin_folder') . '/uninstall/' . $uninstall_file);

/* Eintrag aus der Tabelle für
** Module, Blöcke oder Plugins
** entfernen
*/
			$name = explode("_", basename($uninstall_file, ".xml"));

			$this->db->delete(TB_PREFIX . $name[0] . "s", "name='" . $name[1] . "'");
		}
		if(get('page') != "install"){
			foreach($uninstaller->file as $remove_file){
				unlink($remove_file);

/* Debugausgabe, zum Löschen markiert */
// 			echo "Gelöschte Datei: " . $remove_file . "<br />";
/* Debugausgabe Ende */
			}
			foreach($uninstaller->path as $remove_path){
				$this->remove_dir($remove_path);

/* Debugausgabe, zum Löschen markiert */
// 			echo "Gelöschter Ordner: " . $remove_path . "<br />";
/* Debugausgabe Ende */
			}
		}
		foreach($uninstaller->sql as $remove_db){
			if($remove_db == "KILL")
				$this->db->query("DROP TABLE " . TB_PREFIX . $remove_db['table'] . ";");
			else
				$this->db->delete(TB_PREFIX . $remove_db['table'], "var='" . $remove_db . "'");

/* Debugausgabe, zum Löschen markiert */
// 			echo "Gelöschter DB-Eintrag: " . $remove_db . " aus Tabelle " . TB_PREFIX . $remove_db['table'] . "<br />";
/* Debugausgabe Ende */
		}
	}
	function make_dir($path){

/* Ordner anlegen und
** entsprechende Rechte
** vergeben
*/
		if(@mkdir($path, 0755))
			chmod($path, 0755);

/* Debugausgabe, zum Löschen markiert */
// 		echo "Erzeugter Ordner: " . $path . "<br />";
/* Debugausgabe Ende */

		$this->remove_path[] = $path;
	}
	function write_xml(){

/* XML-Datei anlegen für Uninstaller
** schreiben. Datei wird erzeugt aus
** den Arrays
**
** $this->remove_file
** $this->remove_path
**
** eine Datei m XML-Format
*/
		$uninstall_file = $this->uninstall_path . "/" . $this->xml['art'] . "_" . $this->xml->name . ".xml";
		$remove_path = array_reverse($this->remove_path); // Pfadliste umkehren, um die oberste Ebene als erstes zu entfernen
		$handle = fopen($uninstall_file, "w");

		fwrite($handle, "<" . "?xml version=\"1.0\" ?" . ">\n");
		fwrite($handle, "<uninstall>\n");

		foreach($this->remove_file as $remove_file){
			fwrite($handle, "\t<file>" . $remove_file . "</file>\n");
		}
		foreach($remove_path as $remove_path_){
			fwrite($handle, "\t<path>" . $remove_path_ . "</path>\n");
		}
		foreach($this->db_entry as $db_entry){
			$db_parts = explode(";;", $db_entry);
			fwrite($handle, "\t<sql table=\"" . substr($db_parts[0], strlen(TB_PREFIX)) . "\">" . $db_parts[1] . "</sql>\n");
		}
		fwrite($handle, "</uninstall>\n");
		fclose($handle);

/* Debugausgabe, zum Löschen markiert */
// 		echo "Datei <b>$uninstall_file</b> erfolgreich geschrieben<br />";
// 		echo "<pre>";
// 		print_r($this->remove_file);
// 		print_r($remove_path);
// 		print_r($this->db_entry);
// 		echo "</pre>";
/* Debugausgabe Ende */
	}
	function install_archive($file){

/* Archiv mit Namen $file
** entpacken.
** Momentan werden nur ZIP-Archive
** unterstützt, später folgen dann
** folgende Archive
**
** tar
** tar.gz
** tar.bz2
**
** Die Auswahl, welches Format
** vorhanden ist, wird anhand der
** Dateiendung getroffen
*/
		if(substr($file, -4) == ".zip"){
			$module_path = $file;
			$archive = new Unpack($module_path);

			if ($archive->extract(PCLZIP_OPT_PATH, $this->path) == 0)
				die("Error: " . $archive->errorInfo(true));

			$xml = $this->parse_xml($file);
			$folder = basename($file, ".zip");
		}
		if(substr($file, -4) == ".tar"){

		}
		if(substr($file, -7) == ".tar.gz"){

		}
		if(substr($file, -8) == ".tar.bz2"){

		}
		$this->archive = $file;
		$this->copy();
		$this->remove_dir($this->path . "/" . $folder);
	}
	function remove_dir($dirName){

/* Verzeichnis '$path' rekursiv
** durchlaufen und komplett löschen
**
** Um die gelöschten Dateien anzeigen
** zu lassen, die Debuganzeigen
** aktivieren. Wird am ende gelöscht
*/
/* Debugausgabe, zum Löschen markiert */
		echo "1-Pfad: " . $dirName . "<br />";
/* Debugausgabe Ende */

		if(empty($dirName)){
			return;
		}
		if(file_exists($dirName)){
			$dir = opendir($dirName);

			while(false !== ($file = readdir($dir))){
				if($file != '.' && $file != '..'){
					if(is_dir($dirName . '/' . $file)){
						$this->remove_dir($dirName . '/' . $file);
					}
					else{
						unlink($dirName . '/' . $file);
					}
				}
			}
			@rmdir($dirName . '/' . $file);
			closedir($dir);
		}
	}
}
?>
Return current item: Aratix