<?php // $Id: fileUpload.lib.php,v 1.79.2.2 2005/09/09 09:15:31 pcool Exp $
/*
==============================================================================
	Dokeos - elearning and course management software

	Copyright (c) 2004 Dokeos S.A.
	Copyright (c) 2003 University of Ghent (UGent)
	Copyright (c) 2001 Universite catholique de Louvain (UCL)
	Copyright (c) various contributors

	For a full list of contributors, see "credits.txt".
	The full license can be read in "license.txt".

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	See the GNU General Public License for more details.

	Contact: Dokeos, 181 rue Royale, B-1000 Brussels, Belgium, info@dokeos.com
==============================================================================
*/
/**
==============================================================================
	FILE UPLOAD LIBRARY

*	This is the file upload library for Dokeos.
*	Include/require it in your code to use its functionality.
*
*	@package dokeos.library
*	@todo test and reorganise
==============================================================================
*/

/*
==============================================================================
List of functions
replace_dangerous_char($filename, $strict = 'loose')
function php2phps ($fileName)
function htaccess2txt($filename)
function disable_dangerous_file($filename)
function unique_name($path,$name)
function get_document_title($name)
function process_uploaded_file($uploaded_file)
function handle_uploaded_document($_course,$uploaded_file,$base_work_dir,$upload_path,$user_id,$to_group_id,$to_user_id,$maxFilledSpace,$unzip=0,$what_if_file_exists='')
function enough_size($fileSize, $dir, $maxDirSpace) //depreciated
function enough_space($file_size, $max_dir_space)
function dir_total_space($dirPath) //depreciated
function documents_total_space()
function add_ext_on_mime($fileName,$fileType)
function treat_uploaded_file($uploadedFile, $baseWorkDir, $uploadPath, $maxFilledSpace, $uncompress= '') //depreciated
function unzip_uploaded_file($uploaded_file, $upload_path, $base_work_dir, $max_filled_space)
function clean_up_files_in_zip($p_event, &$p_header)
function clean_up_path(&$path)
function add_document($_course,$path,$filetype,$filesize,$title)
function update_existing_document($_course,$document_id,$filesize)
function item_property_update_on_folder($_course,$path,$user_id)
function get_levels($filename)
function set_default_settings($upload_path,$filename,$filetype="file")
function search_img_from_html($htmlFile)
function create_unexisting_directory($_course,$user_id,$base_work_dir,$desired_dir_name)
function move_uploaded_file_collection_into_directory($_course, $uploaded_file_collection, $base_work_dir, $missing_files_dir,$user_id,$max_filled_space)
function replace_img_path_in_html_file($originalImgPath, $newImgPath, $htmlFile)
function create_link_file($filePath, $url)
function api_replace_links_in_html($upload_path, $full_file_name)
function api_replace_links_in_string($upload_path, $buffer)
function check_for_missing_files($file)
function build_missing_files_form($missing_files,$upload_path,$file_name)
	Still experimental:
function api_replace_parameter($upload_path, $buffer, $param_name="src")
==============================================================================
*/


/**
 * replaces "forbidden" characters in a filename string
 *
 * @author - Hugues Peeters <peeters@ipm.ucl.ac.be>
 * @author - René Haentjens, UGent (RH)
 * @param  - string $filename
 * @param  - string $strict (optional) remove all non-ASCII
 * @return - the cleaned filename
 */

function replace_dangerous_char($filename, $strict = 'loose')
{
	$filename = ereg_replace("\.+$", "", substr(strtr(ereg_replace(
	    "[^!-~\x80-\xFF]", "_", trim($filename)), '\/:*?"<>|\'',
        /* Keep C1 controls for UTF-8 streams */  '-----_---_'), 0, 250));
	if ($strict != 'strict') return $filename;

	return ereg_replace("[^!-~]", "x", $filename);
}

//------------------------------------------------------------------------------

/**
 * change the file name extension from .php to .phps
 * Useful to secure a site !!
 *
 * @author - Hugues Peeters <peeters@ipm.ucl.ac.be>
 * @param  - fileName (string) name of a file
 * @return - the filenam phps'ized
 */

function php2phps ($fileName)
{
	$fileName = eregi_replace("\.(php.?|phtml)$", ".phps", $fileName);
	return $fileName;
}

//------------------------------------------------------------------------------

/**
 * Renames .htaccess & .HTACCESS tot htaccess.txt
 *
 * @param string $filename
 * @return string 
 */
function htaccess2txt($filename)
{
	$filename = str_replace('.htaccess', 'htaccess.txt', $filename);
	$filename = str_replace('.HTACCESS', 'htaccess.txt', $filename);
    return $filename;
}

//------------------------------------------------------------------------------


/**
 * this function executes our safety precautions
 * more functions can be added
 *
 * @param string $filename
 * @return string
 * @see php2phps()
 * @see htaccess2txt()
 */
function disable_dangerous_file($filename)
{
	$filename = php2phps($filename);
	$filename = htaccess2txt($filename);
	return $filename;
}

//------------------------------------------------------------------------------

/**
 * this function generates a unique name for a file on a given location
 * filenames are changed to name_#.ext
 *
 * @param string $path
 * @param string $name
 * @return new unique name
 */
function unique_name($path,$name)
{
	$ext = substr(strrchr($name, "."), 0);
	$name_no_ext = substr($name, 0, strlen($name) - strlen(strstr($name,$ext)));
	$n=1;
	while(file_exists($path . $name_no_ext . $unique . $ext)) 
	{
	$unique = "_" . $n;
	$n++;
	}
	return $name_no_ext . $unique . $ext;
}

//------------------------------------------------------------------------------

/**
 * Returns the name without extension, used for the title
 *
 * @param string $name
 * @return name without the extension
 */
function get_document_title($name)
{
	//if they upload .htaccess...
	$name = disable_dangerous_file($name);
	$ext = substr(strrchr($name, "."), 0);
	$name_no_ext = substr($name, 0, strlen($name) - strlen(strstr($name,$ext)));
	$filename = addslashes($name_no_ext);
	return $filename;
}

//------------------------------------------------------------------------------

/**
 * This checks if the upload succeeded
 *
 * @param array $uploaded_file ($_FILES)
 * @return true if upload succeeded
 */
function process_uploaded_file($uploaded_file)
{
/* phpversion is needed to determine if error codes are sent with the file upload */
$phpversion = intval(str_replace(".", "", phpversion()));

/* as of version 4.2.0 php gives error codes if something went wrong with the upload */
if ($phpversion >= 420)
{
	//0; There is no error, the file uploaded with success. 
	//1; The uploaded file exceeds the upload_max_filesize directive in php.ini. 
	if ($uploaded_file['error'] == 1) 
	{
		Display::display_error_message(get_lang('UplExceedMaxServerUpload'). ini_get('upload_max_filesize')); //server config
		return false;
	}
	//2; The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form. 
	//not used at the moment, but could be handy if we want to limit the size of an upload (e.g. image upload in html editor).
	elseif ($uploaded_file['error'] == 2) 
	{
		Display::display_error_message(get_lang('UplExceedMaxPostSize'). round($_POST['MAX_FILE_SIZE']/1024) ." KB");
		return false;
	}
	//3; The uploaded file was only partially uploaded. 
	elseif ($uploaded_file['error'] == 3) 
	{
		Display::display_error_message(get_lang('$UplPartialUpload')." ".get_lang('PleaseTryAgain'));
		return false;
	}
	//4; No file was uploaded. 
	elseif ($uploaded_file['error'] == 4) 
	{
		Display::display_error_message(get_lang('UplNoFileUploaded')." ". get_lang('UplSelectFileFirst'));
		return false;
	}	
}
/* older php versions */
else {
	/* is there an uploaded file? */
	if (!is_uploaded_file($uploaded_file['tmp_name']))
	{
		Display::display_error_message(get_lang('UplNoFileUploaded'));
		return false;
	}
	/* file upload size limitations */
	$max_upload_file_size = (ini_get('upload_max_filesize')*1024*1024);
	if (($uploaded_file['size'])>$max_upload_file_size) 
	{
		Display::display_error_message(get_lang('UplFileTooBig'));
		return false;
	}
	/* tmp_name gets set to none if something went wrong */
	if ($uploaded_file['tmp_name'] == "none") 
	{
		Display::display_error_message(get_lang('UplUploadFailed'));
		return false;
	}
}
return true;
}

//------------------------------------------------------------------------------

/**
 * this function does the save-work for the documents.
 * it handles the uploaded file and adds the properties to the database
 * if unzip=1 and the file is a zipfile, it is extracted
 * if we decide to save ALL kinds of documents in one database, 
 * we could extend this with a $type='document', 'scormdocument',...
 *
 * @param array $_course
 * @param array $uploaded_file ($_FILES)
 * @param string $base_work_dir
 * @param string $upload_path
 * @param int $user_id
 * @param int $to_group_id, 0 for everybody
 * @param int $to_user_id, NULL for everybody
 * @param int $maxFilledSpace
 * @param int $unzip 1/0
 * @param string $what_if_file_exists overwrite, rename or warn if exists (default)
 * @param boolean Optional output parameter. So far only use for unzip_uploaded_document function. If no output wanted on success, set to false.
 * @return path of the saved file
 */
function handle_uploaded_document($_course,$uploaded_file,$base_work_dir,$upload_path,$user_id,$to_group_id=0,$to_user_id=NULL,$maxFilledSpace='',$unzip=0,$what_if_file_exists='',$output=true)
{
	if(!$user_id) die("Not a valid user.");
	
	//strip slashes
	$uploaded_file['name']=stripslashes($uploaded_file['name']);
	//add extension to files without one (if possible)
	$uploaded_file['name']=add_ext_on_mime($uploaded_file['name'],$uploaded_file['type']);
	
	//check if there is enough space to save the file
	if (!enough_space($uploaded_file['size'], $maxFilledSpace))
	{
		Display::display_error_message(get_lang('UplNotEnoughSpace'));
		return false;
	}
	//if the want to unzip, check if the file has a .zip (or ZIP,Zip,ZiP,...) extension
	if ($unzip == 1 && preg_match("/.zip$/", strtolower($uploaded_file['name'])) )
	{
		return unzip_uploaded_document($uploaded_file, $upload_path, $base_work_dir, $maxFilledSpace, $output);
		//display_message("Unzipping file");
	}
	//we can only unzip ZIP files (no gz, tar,...)
	elseif ($unzip == 1 && !preg_match("/.zip$/", strtolower($uploaded_file['name'])) )
	{
		Display::display_error_message(get_lang('UplNotAZip')." ".get_lang('PleaseTryAgain'));
		return false;
	}
	else
	{
	//clean up the name and prevent dangerous files
	//remove strange characters
	$clean_name = replace_dangerous_char($uploaded_file['name']);
	//no "dangerous" files
	$clean_name = disable_dangerous_file($clean_name);
	//echo "<br/>clean name = ".$clean_name;
	//echo "<br/>upload_path = ".$upload_path;
	//if the upload path differs from / (= root) it will need a slash at the end
	if ($upload_path!='/') 
		$upload_path = $upload_path.'/';
	//echo "<br/>upload_path = ".$upload_path;
	$file_path = $upload_path.$clean_name;
	//echo "<br/>file path = ".$file_path;
	//full path to where we want to store the file with trailing slash
	$where_to_save = $base_work_dir.$upload_path;
	//echo "<br/>where to save = ".$where_to_save;
	// full path of the destination
	$store_path = $where_to_save.$clean_name;
	//echo "<br/>store path = ".$store_path;
	//name of the document without the extension (for the title)
	$document_name = get_document_title($uploaded_file['name']);
	//size of the uploaded file (in bytes)
	$file_size = $uploaded_file['size'];
		//what to do if the target file exists
		switch ($what_if_file_exists)
			{
			//overwrite the file if it exists
			case 'overwrite':
				
				//check if the target file exists, so we can give another message
				if (file_exists($store_path))
				{
					$file_exists = true;
				}
				else
				{
					$file_exists = false;
				}
				if (@move_uploaded_file($uploaded_file['tmp_name'], $store_path))
				{
					if($file_exists)
					{
						//UPDATE DATABASE!
						$document_id = DocumentManager::get_document_id($_course,$file_path);
						if ($document_id)
						{	
							//update filesize
							update_existing_document($_course,$document_id,$uploaded_file['size']);
							//update document item_property
							item_property_update($_course,TOOL_DOCUMENT,$document_id,'DocumentUpdated',$user_id,$to_group_id,$to_user_id);
						}
						//if the file is in a folder, we need to update all parent folders
						item_property_update_on_folder($_course,$upload_path,$user_id);
						//display success message with extra info to user
						if($output){
							Display::display_normal_message(get_lang('UplUploadSucceeded')."<br/>".$file_path .' '. get_lang('UplFileOverwritten'));
						}
						return $file_path;
					}
					else
					{
						//put the document data in the database
						$document_id = add_document($_course,$file_path,'file',$file_size,$document_name);
						if ($document_id)
						{	
							//put the document in item_property update
							item_property_update($_course,TOOL_DOCUMENT,$document_id,'DocumentAdded',$user_id,$to_group_id,$to_user_id);
						}
						//if the file is in a folder, we need to update all parent folders
						item_property_update_on_folder($_course,$upload_path,$user_id);
						//display success message to user
						Display::display_normal_message(get_lang('UplUploadSucceeded')."<br/>".$file_path);
						return $file_path;
					}
				}
				else
				{
					Display::display_error_message(get_lang('UplUnableToSaveFile'));
					return false;
				}
				break;
				
			//rename the file if it exists
			case 'rename':
				$new_name = unique_name($where_to_save, $clean_name);
				$store_path = $where_to_save.$new_name;
				$new_file_path = $upload_path.$new_name;

				if (@move_uploaded_file($uploaded_file['tmp_name'], $store_path))
				{
					//put the document data in the database
					$document_id = add_document($_course,$new_file_path,'file',$file_size,$document_name);
					if ($document_id)
					{	
						//update document item_property
						item_property_update($_course,TOOL_DOCUMENT,$document_id,'DocumentAdded',$user_id,$to_group_id,$to_user_id);
					}
					//if the file is in a folder, we need to update all parent folders
					item_property_update_on_folder($_course,$upload_path,$user_id);
					//display success message to user
					if($output){
						Display::display_normal_message(get_lang('UplUploadSucceeded'). "<br>" .get_lang('UplFileSavedAs') . $new_file_path);
					}
					return $new_file_path;
				}
				else
				{
					Display::display_error_message(get_lang('UplUnableToSaveFile'));
					return false;
				}
				break;
				
			//only save the file if it doesn't exist or warn user if it does exist
			default: 
				if (file_exists($store_path))
				{
					Display::display_error_message($clean_name.get_lang('UplAlreadyExists'));
				}
				else
				{
					if (@move_uploaded_file($uploaded_file['tmp_name'], $store_path))
					{

						//put the document data in the database
						$document_id = add_document($_course,$file_path,'file',$file_size,$document_name);
						if ($document_id)
						{	
							//update document item_property
							item_property_update($_course,TOOL_DOCUMENT,$document_id,'DocumentAdded',$user_id,$to_group_id,$to_user_id);
						}
						//if the file is in a folder, we need to update all parent folders
						item_property_update_on_folder($_course,$upload_path,$user_id);
						//display success message to user
						if($output){
							Display::display_normal_message(get_lang('UplUploadSucceeded')."<br/>".$file_path);
						}
						return $file_path;
					}
					else
					{
						Display::display_error_message(get_lang('UplUnableToSaveFile'));
						return false;
					}
				}
				break;
				}
	}
}

//------------------------------------------------------------------------------

/**
 * Check if there is enough place to add a file on a directory
 * on the base of a maximum directory size allowed
 * @deprecated use enough_space instead!
 * @author - Hugues Peeters <peeters@ipm.ucl.ac.be>
 * @param  - fileSize (int) - size of the file in byte
 * @param  - dir (string) - Path of the directory
 *           whe the file should be added
 * @param  - maxDirSpace (int) - maximum size of the diretory in byte
 * @return - boolean true if there is enough space,
 *				boolean false otherwise
 *
 * @see    - enough_size() uses  dir_total_space() function
 */

function enough_size($fileSize, $dir, $maxDirSpace)
{
	if ($maxDirSpace)
	{
		$alreadyFilledSpace = dir_total_space($dir);

		if ( ($fileSize + $alreadyFilledSpace) > $maxDirSpace)
		{
			return false;
		}
	}

	return true;
}

//------------------------------------------------------------------------------

/**
 * Check if there is enough place to add a file on a directory
 * on the base of a maximum directory size allowed
 *
 * @author Bert Vanderkimpen
 * @param  int file_size size of the file in byte
 * @param array $_course
 * @param  int max_dir_space maximum size
 * @return boolean true if there is enough space, false otherwise
 *
 * @see enough_space() uses  documents_total_space() function
 */

function enough_space($file_size, $max_dir_space)
{
	if ($max_dir_space)
	{
		$already_filled_space = documents_total_space();
		if ( ($file_size + $already_filled_space) > $max_dir_space)
		{
			return false;
		}
	}

	return true;
}

//------------------------------------------------------------------------------

/**
 * Compute the size already occupied by a directory and is subdirectories
 *
 * @author - Hugues Peeters <peeters@ipm.ucl.ac.be>
 * @param  - dirPath (string) - size of the file in byte
 * @return - int - return the directory size in bytes
 */

function dir_total_space($dirPath)
{
	chdir ($dirPath) ;
	$handle = opendir($dirPath);

	while ($element = readdir($handle) )
	{
		if ( $element == "." || $element == "..")
		{
			continue; // skip the current and parent directories
		}
		if ( is_file($element) )
		{
			$sumSize += filesize($element);
		}
		if ( is_dir($element) )
		{
			$dirList[] = $dirPath."/".$element;
		}
	}

	closedir($handle) ;

	if ( sizeof($dirList) > 0)
	{
		foreach($dirList as $j)
		{
			$sizeDir = dir_total_space($j);	// recursivity
			$sumSize += $sizeDir;
		}
	}

	return $sumSize;
}

//------------------------------------------------------------------------------

/**
 * Calculate the total size of all documents in a course
 *
 * @author Bert vanderkimpen
 * @param  int $to_group_id (to calculate group document space)
 * @return int total size
 */

function documents_total_space($to_group_id='0')
{
	$TABLE_ITEMPROPERTY = Database::get_course_table(LAST_TOOL_EDIT_TABLE);
	$TABLE_DOCUMENT = Database::get_course_table(DOCUMENT_TABLE);
	
	$sql = "SELECT SUM(size) 
	FROM  ".$TABLE_ITEMPROPERTY."  AS props, ".$TABLE_DOCUMENT."  AS docs
	WHERE docs.id = props.ref 
	AND props.tool = '".TOOL_DOCUMENT."' 
	AND props.to_group_id='".$to_group_id."' 
	AND props.visibility <> 2";

	$result = api_sql_query($sql,__FILE__,__LINE__);
		
	if($result && mysql_num_rows($result)!=0)
	{	
		$row = mysql_fetch_row($result);

		return $row[0];
	}
	else
	{
		return 0;
	} 
}

//------------------------------------------------------------------------------

/**
 * Try to add an extension to files without extension
 * Some applications on Macintosh computers don't add an extension to the files.
 * This subroutine try to fix this on the basis of the MIME type sent
 * by the browser.
 *
 * Note : some browsers don't send the MIME Type (e.g. Netscape 4).
 *        We don't have solution for this kind of situation
 *
 * @author - Hugues Peeters <peeters@ipm.ucl.ac.be>
 * @author - Bert Vanderkimpen
 * @param  - fileName (string) - Name of the file
 * @param  - fileType (string) - Type of the file
 * @return - fileName (string)
 *
 */

function add_ext_on_mime($fileName,$fileType)
{
	/*
	 * Check if the file has an extension AND if the browser has sent a MIME Type
	 */

	if(!ereg("([[:alnum:]]|[[[:punct:]])+\.[[:alnum:]]+$", $fileName)
		&& $fileType)
	{
		/*
		 * Build a "MIME-types / extensions" connection table
		 */

		static $mimeType = array();

		$mimeType[] = "application/msword";             $extension[] =".doc";
		$mimeType[] = "application/rtf";                $extension[] =".rtf";
		$mimeType[] = "application/vnd.ms-powerpoint";  $extension[] =".ppt";
		$mimeType[] = "application/vnd.ms-excel";       $extension[] =".xls";
		$mimeType[] = "application/pdf";                $extension[] =".pdf";
		$mimeType[] = "application/postscript";         $extension[] =".ps";
		$mimeType[] = "application/mac-binhex40";       $extension[] =".hqx";
		$mimeType[] = "application/x-gzip";             $extension[] ="tar.gz";
		$mimeType[] = "application/x-shockwave-flash";  $extension[] =".swf";
		$mimeType[] = "application/x-stuffit";          $extension[] =".sit";
		$mimeType[] = "application/x-tar";              $extension[] =".tar";
		$mimeType[] = "application/zip";                $extension[] =".zip";
		$mimeType[] = "application/x-tar";              $extension[] =".tar";
		$mimeType[] = "text/html";                      $extension[] =".htm";
		$mimeType[] = "text/plain";                     $extension[] =".txt";
		$mimeType[] = "text/rtf";                       $extension[] =".rtf";
		$mimeType[] = "img/gif";                        $extension[] =".gif";
		$mimeType[] = "img/jpeg";                       $extension[] =".jpg";
		$mimeType[] = "img/png";                        $extension[] =".png";
		$mimeType[] = "audio/midi";                     $extension[] =".mid";
		$mimeType[] = "audio/mpeg";                     $extension[] =".mp3";
		$mimeType[] = "audio/x-aiff";                   $extension[] =".aif";
		$mimeType[] = "audio/x-pn-realaudio";           $extension[] =".rm";
		$mimeType[] = "audio/x-pn-realaudio-plugin";    $extension[] =".rpm";
		$mimeType[] = "audio/x-wav";                    $extension[] =".wav";
		$mimeType[] = "video/mpeg";                     $extension[] =".mpg";
		$mimeType[] = "video/quicktime";                $extension[] =".mov";
		$mimeType[] = "video/x-msvideo";                $extension[] =".avi";
		//test on PC (files with no extension get application/octet-stream)
		//$mimeType[] = "application/octet-stream";      $extension[] =".ext";

		/*
		 * Check if the MIME type sent by the browser is in the table
		 */

		foreach($mimeType as $key=>$type)
		{
			if ($type == $fileType)
			{
				$fileName .=  $extension[$key];
				break;
			}
		}

		unset($mimeType, $extension, $type, $key); // Delete to eschew possible collisions
	}

	return $fileName;
}

//------------------------------------------------------------------------------

/**
 *
 * @author Hugues Peeters <hugues.peeters@claroline.net>
 *
 * @param  array $uploadedFile - follows the $_FILES Structure
 * @param  string $baseWorkDir - base working directory of the module
 * @param  string $uploadPath  - destination of the upload.
 *                               This path is to append to $baseWorkDir
 * @param  int $maxFilledSpace - amount of bytes to not exceed in the base
 *                               working directory
 *
 * @return boolean true if it succeds, false otherwise
 */
function treat_uploaded_file($uploadedFile, $baseWorkDir, $uploadPath, $maxFilledSpace, $uncompress= '')
{
	$uploadedFile['name']=stripslashes($uploadedFile['name']);

	if (!enough_size($uploadedFile['size'], $baseWorkDir, $maxFilledSpace))
	{
		return api_failure::set_failure('not_enough_space');
	}

	if ($uncompress == 'unzip' && preg_match("/.zip$/", strtolower($uploadedFile['name'])) )
	{
		return unzip_uploaded_file($uploadedFile, $uploadPath, $baseWorkDir, $maxFilledSpace);
	}
	else
	{
		$fileName = trim($uploadedFile['name']);

		// CHECK FOR NO DESIRED CHARACTERS
		$fileName = replace_dangerous_char($fileName);

		// TRY TO ADD AN EXTENSION TO FILES WITOUT EXTENSION
		$fileName = add_ext_on_mime($fileName,$uploadedFile['type']);

		// HANDLE PHP FILES
		$fileName = php2phps($fileName);

		// COPY THE FILE TO THE DESIRED DESTINATION
		if(move_uploaded_file($uploadedFile['tmp_name'], $baseWorkDir.$uploadPath."/".$fileName))
				set_default_settings($uploadPath,$fileName);

		return true;
	}
}
/**
 * Manages all the unzipping process of an uploaded file
 *
 * @author Hugues Peeters <hugues.peeters@claroline.net>
 *
 * @param  array  $uploadedFile - follows the $_FILES Structure
 * @param  string $uploadPath   - destination of the upload.
 *                                This path is to append to $baseWorkDir
 * @param  string $baseWorkDir  - base working directory of the module
 * @param  int $maxFilledSpace  - amount of bytes to not exceed in the base
 *                                working directory
 *
 * @return boolean true if it succeeds false otherwise
 */

function unzip_uploaded_file($uploadedFile, $uploadPath, $baseWorkDir, $maxFilledSpace)
{
	$zipFile = new pclZip($uploadedFile['tmp_name']);

	// Check the zip content (real size and file extension)

	$zipContentArray = $zipFile->listContent();

	$okScorm=false;

	foreach($zipContentArray as $thisContent)
	{
		if ( preg_match('~.(php.*|phtml)$~i', $thisContent['filename']) )
		{
			return api_failure::set_failure('php_file_in_zip_file');
		}
		elseif(stristr($thisContent['filename'],'imsmanifest.xml'))
		{
			$okScorm=true;
		}
		elseif(stristr($thisContent['filename'],'LMS'))
		{
			$okPlantynScorm1=true;
		}
		elseif(stristr($thisContent['filename'],'REF'))
		{
			$okPlantynScorm2=true;
		}
		elseif(stristr($thisContent['filename'],'SCO'))
		{
			$okPlantynScorm3=true;
		}
		elseif(stristr($thisContent['filename'],'AICC'))
		{
			$okAiccScorm=true;
		}

		$realFileSize += $thisContent['size'];
	}

	if ((($okPlantynScorm1==true) and ($okPlantynScorm2==true) and ($okPlantynScorm3==true)) or ($okAiccScorm==true))
	{
		$okScorm=true;
	}

	if(!$okScorm && defined('CHECK_FOR_SCORM') && CHECK_FOR_SCORM)
	{
		return api_failure::set_failure('not_scorm_content');
	}

	if (! enough_size($realFileSize, $baseWorkDir, $maxFilledSpace) )
	{
		return api_failure::set_failure('not_enough_space');
	}

	// it happens on Linux that $uploadPath sometimes doesn't start with '/'
	if($uploadPath[0] != '/')
	{
		$uploadPath='/'.$uploadPath;
	}

	if($uploadPath[strlen($uploadPath)-1] == '/')
	{
		$uploadPath=substr($uploadPath,0,-1);
	}

	/*
	--------------------------------------
		Uncompressing phase
	--------------------------------------
	*/
	/*
		The first version, using OS unzip, is not used anymore
		because it does not return enough information.
		We need to process each individual file in the zip archive to
		- add it to the database
		- parse & change relative html links
	*/
	if (PHP_OS == 'Linux' && ! get_cfg_var('safe_mode') && false)	// *** UGent, changed by OC ***
	{
		// Shell Method - if this is possible, it gains some speed
		exec("unzip -d \"".$baseWorkDir.$uploadPath."/\"".$uploadedFile['name']." "
			 .$uploadedFile['tmp_name']);
	}
	else
	{
		// PHP method - slower...

		chdir($baseWorkDir.$uploadPath);
		$unzippingState = $zipFile->extract();
		for($j=0;$j<count($unzippingState);$j++)
		{
			$state=$unzippingState[$j];

			//fix relative links in html files
			$extension = strrchr($state["stored_filename"], ".");
		}

		if($dir=@opendir($baseWorkDir.$uploadPath))
		{
			while($file=readdir($dir))
			{
				if($file != '.' && $file != '..')
				{
					$filetype="file";

					if(is_dir($baseWorkDir.$uploadPath.'/'.$file)) $filetype="folder";

					$safe_file=replace_dangerous_char($file,'strict');

					@rename($baseWorkDir.$uploadPath.'/'.$file,$baseWorkDir.$uploadPath.'/'.$safe_file);

					set_default_settings($uploadPath,$safe_file,$filetype);
				}
			}

			closedir($dir);
		}
	}

	return true;
}
//------------------------------------------------------------------------------

/**
 * Manages all the unzipping process of an uploaded document
 * This uses the item_property table for properties of documents
 *
 * @author Hugues Peeters <hugues.peeters@claroline.net>
 * @author Bert Vanderkimpen
 *
 * @param  array  $uploadedFile - follows the $_FILES Structure
 * @param  string $uploadPath   - destination of the upload.
 *                                This path is to append to $baseWorkDir
 * @param  string $baseWorkDir  - base working directory of the module
 * @param  int $maxFilledSpace  - amount of bytes to not exceed in the base
 *                                working directory
 * @param		boolean	Output switch. Optional. If no output not wanted on success, set to false. 
 *
 * @return boolean true if it succeeds false otherwise
 */

function unzip_uploaded_document($uploaded_file, $upload_path, $base_work_dir, $max_filled_space, $output = true)
{
	global $_course;
	global $_uid;
	global $to_user_id;
	global $to_group_id;
	
	$zip_file = new pclZip($uploaded_file['tmp_name']);

	// Check the zip content (real size and file extension)

	$zip_content_array = $zip_file->listContent();


	foreach((array) $zip_content_array as $this_content)
	{
		$real_filesize += $this_content['size'];
	}

	if (! enough_space($real_filesize, $max_filled_space) )
	{
		Display::display_error_message(get_lang('UplNotEnoughSpace'));
		return false;
	}
	
	// it happens on Linux that $uploadPath sometimes doesn't start with '/'
	if($upload_path[0] != '/')
	{
		$upload_path='/'.$upload_path;
	}
	/*
	--------------------------------------
		Uncompressing phase
	--------------------------------------
	*/
	//get into the right directory
	chdir($base_work_dir.$upload_path);
	//we extract using a callback function that "cleans" the path
	$unzipping_state = $zip_file->extract(PCLZIP_CB_PRE_EXTRACT, 'clean_up_files_in_zip');
	if ($upload_path != '/')
		$upload_path = $upload_path.'/';
	if($unzipping_state!=0)
	{
		for($j=0;$j<count($unzipping_state);$j++)
		{
			$state=$unzipping_state[$j];
			$filename = $state['stored_filename'];
			//echo("<br>filename = ".$filename."<br>");
			$filename2 = $state['filename'];
			//echo("<br>filename2 = ".$filename2."<br>");
			$filetype="file";
			//if(is_dir($filename))
			if($state['folder']==1)
			{
				$filetype="folder";	
				$endchar=substr($filename,strlen($filename)-1,1);
				if($endchar=="\\" || $endchar=="/")
					$filename=substr($filename,0,strlen($filename)-1);
			}

			//store document in database
			if($state['status']=="ok" || $state['status']=="already_a_directory")
			{
				//echo $base_work_dir.$upload_path.clean_up_path($state["stored_filename"])." (".$filetype.")<br/>";
				$cleaned_up_filename = clean_up_path($filename);
				$file_path = $upload_path.$cleaned_up_filename;
				//echo("file path = ".$file_path."<br>");
				
				//this is a quick fix for zipfiles that have files in folders but the folder is not stored in the zipfile
				//if the path has folders, check if they already are in the database
				if(dirname('/'.$cleaned_up_filename)!='/' AND dirname('/'.$cleaned_up_filename)!='\\')
				{
					$folder_id=DocumentManager::get_document_id($_course,$upload_path.dirname($cleaned_up_filename));
					if(!$folder_id)
					{
						//echo($upload_path.dirname($cleaned_up_filename).' not found in database!<br>');
						$folder_id = add_document($_course,$upload_path.dirname($cleaned_up_filename),'folder',0,basename(dirname($cleaned_up_filename)));
						if($folder_id)
						{
							item_property_update($_course,TOOL_DOCUMENT,$folder_id,'FolderAdded',$_uid,$to_group_id,$to_user_id);
							//echo('folder '.$upload_path.dirname($cleaned_up_filename)." added<br>\n");
						}
					}
				}	
				
				$store_path = $base_work_dir.$file_path;
				//echo("store path = ".$store_path."<br>");
				$document_name = get_document_title(basename($filename));
				//echo("document_name = ".$document_name."<br><br>");
				//put the document data in the database
				//if the file/dir does not exist, just add it
				//if(!file_exists($store_path)) <- not working, as the file is already extracted
				//so we check if the document is already in the database
				$document_id = DocumentManager::get_document_id($_course,$file_path);
				if(!$document_id)
				{
				$document_id = add_document($_course,$file_path,$filetype,$state['size'],$document_name);
					if ($document_id)
					{	
						$lastedit_type = ($filetype=='folder')?'FolderAdded':'DocumentAdded';
						//update item property for document
						item_property_update($_course,TOOL_DOCUMENT,$document_id,$lastedit_type,$_uid,$to_group_id,$to_user_id);
					}		
				}
				//file/dir exists -> update
				else 
				{
					$lastedit_type = ($filetype=='folder')?'FolderUpdated':'DocumentUpdated';
					//update the document in item_property
					item_property_update($_course,TOOL_DOCUMENT,$document_id,$lastedit_type,$_uid,$to_group_id,$to_user_id);
				}

			}
		}
	//print_r_pre($zip_content_array);
	//if the file is in a folder, we need to update all parent folders
	item_property_update_on_folder($_course,$upload_path,$_uid);
	//display success message to user
	if($output){
		Display::display_normal_message(get_lang('UplZipExtractSuccess'));
	}
	return true;
	}
	else {
		//zip file could not be extracted -> corrupt file
		Display::display_error_message(get_lang('UplZipCorrupt'));
		return false;
	}
}

//------------------------------------------------------------------------------

/**
 * this function is a callback function that is used while extracting a zipfile
 * http://www.phpconcept.net/pclzip/man/en/index.php?options-pclzip_cb_pre_extract
 *
 * @param $p_event
 * @param $p_header
 * @return 1 (If the function returns 1, then the extraction is resumed)
 */
function clean_up_files_in_zip($p_event, &$p_header)
{
	clean_up_path($p_header['filename']);
	return 1;
}

//------------------------------------------------------------------------------

/**
 * this function cleans up a given path
 * by eliminating dangerous file names and cleaning them
 *
 * @param string $path
 * @return $path
 * @see disable_dangerous_file()
 * @see replace_dangerous_char()
 */
function clean_up_path(&$path)
{
	//split the path in folders and files    
    $path_array = explode('/',$path);
    //clean up every foler and filename in the path
    foreach($path_array as $key => $val)
	{
		//we don't want to lose the dots in ././folder/file (cfr. zipfile)
		if($path_array[$key]!='.')
			$path_array[$key] = disable_dangerous_file( replace_dangerous_char($val) );
	}
	//join the "cleaned" path
	$path = implode('/',$path_array);
	return $path;
}

//------------------------------------------------------------------------------

/**
 * Adds a new document to the database
 *
 * @param array $_course
 * @param string $path
 * @param string $filetype
 * @param int $filesize
 * @param string $title
 * @return id if inserted document
 */
function add_document($_course,$path,$filetype,$filesize,$title,$comment=NULL)
{
	$TABLE_DOCUMENT  = "`".$_course['dbNameGlu']."document`";
	$sql="INSERT INTO $TABLE_DOCUMENT
	(`path`,`filetype`,`size`,`title`, `comment`)
	VALUES ('$path','$filetype','$filesize','$title', '$comment')";
	if(api_sql_query($sql,__FILE__,__LINE__))
	{
		//display_message("Added to database (id ".mysql_insert_id().")!");
		return mysql_insert_id();
	}
	else
	{
		//display_error("The uploaded file could not be added to the database (".mysql_error().")!");
		return false;
	} 	
}

//------------------------------------------------------------------------------

/*
function get_document_id() moved to document.lib.php
*/

//------------------------------------------------------------------------------

/**
 * Update an existing document in the database
 * as the file exists, we only need to change the size
 *
 * @param array $_course
 * @param int $document_id
 * @param int $filesize
 * @return boolean true /false
 */
function update_existing_document($_course,$document_id,$filesize)
{
	$TABLE_DOCUMENT  = "`".$_course['dbNameGlu']."document`";
	$sql="UPDATE $TABLE_DOCUMENT
	SET `size`='$filesize' WHERE id='$document_id'";
	
	if(api_sql_query($sql,__FILE__,__LINE__))
	{
		return true;
	}
	else
	{
		return false;
	} 	
}


/**
 * this function updates the last_edit_date, last edit user id on all folders in a given path
 *
 * @param array $_course
 * @param string $path
 * @param int $user_id
 */
function item_property_update_on_folder($_course,$path,$user_id)
{
	//display_message("Start update_lastedit_on_folder");
	//if we are in the root, just return... no need to update anything	
	if ($path=='/')
		return;
		
	//if the given path ends with a / we remove it
	$endchar=substr($path,strlen($path)-1,1);
	if($endchar=='/')
	$path=substr($path,0,strlen($path)-1);

	$TABLE_ITEMPROPERTY  = "`".$_course['dbNameGlu']."item_property`";
		
	//get the time
	$time = date("Y-m-d H:i:s", time());
	
	//get all paths in the given path
	// /folder/subfolder/subsubfolder/file
	// if file is updated, subsubfolder, subfolder and folder are updated
	
	$exploded_path = explode('/',$path);
	
	foreach ($exploded_path as $key => $value) {
		//we don't want a slash before our first slash
		if($key!=0){
			$newpath .= "/".$value;	

			//echo "path= ".$newpath."<br>";
			//select ID of given folder
			$folder_id = DocumentManager::get_document_id($_course,$newpath);
		
			if($folder_id)
			{	
				$sql = "UPDATE $TABLE_ITEMPROPERTY SET `lastedit_date`='$time',`lastedit_type`='DocumentInFolderUpdated', `lastedit_user_id`='$user_id' WHERE tool='".TOOL_DOCUMENT."' AND ref='$folder_id'";
				api_sql_query($sql,__FILE__,__LINE__);
			}
		}
	}
}
//------------------------------------------------------------------------------

/**
 * Returns the directory depth of the file.
 *
 * @author	Olivier Cauberghe <olivier.cauberghe@ugent.be>
 * @param	path+filename eg: /claroline/document/document.php
 * @return	The directory depth
 */
function get_levels($filename)
{
	$levels=explode("/",$filename);
	if(empty($levels[count($levels)-1])) unset($levels[count($levels)-1]);
	return count($levels);
}

/*
	function file_set_default_settings

	moved to fileManage.lib.php,
	class FileManager
*/

//------------------------------------------------------------------------------

/**
 * Adds file to document table in database
 * @deprecated, use file_set_default_settings instead
 *
 * @author	Olivier Cauberghe <olivier.cauberghe@ugent.be>
 * @param	path,filename
 * @action	Adds an entry to the document table with the default settings.
 */
function set_default_settings($upload_path,$filename,$filetype="file")
{
	global $dbTable,$dbNamePrefix;
	global $default_visibility;

	if (!$default_visibility)
		$default_visibility="v";

	$upload_path=str_replace('\\','/',$upload_path);
	$upload_path=str_replace("//","/",$upload_path);

	if($upload_path == '/')
	{
		$upload_path='';
	}
	elseif(!empty($upload_path) && $upload_path[0] != '/')
	{
		$upload_path="/$upload_path";
	}

	$endchar=substr($filename,strlen($filename)-1,1);

	if($endchar == '/')
	{
		$filename=substr($filename,0,-1);
	}

	//$dbTable already has `backticks`!
	//$query="select count(*) as bestaat from `$dbTable` where path='$upload_path/$filename'";
	$query="select count(*) as bestaat from $dbTable where path='$upload_path/$filename'";
	$result=api_sql_query($query,__FILE__,__LINE__);
	$row=mysql_fetch_array($result);
	if($row["bestaat"]>0)
		//$query="update `$dbTable` set path='$upload_path/$filename',visibility='$default_visibility', filetype='$filetype' where path='$upload_path/$filename'";
		$query="update $dbTable set path='$upload_path/$filename',visibility='$default_visibility', filetype='$filetype' where path='$upload_path/$filename'";
	else //$query="INSERT INTO `$dbTable` (path,visibility,filetype) VALUES('$upload_path/$filename','$default_visibility','$filetype')";
		$query="INSERT INTO $dbTable (path,visibility,filetype) VALUES('$upload_path/$filename','$default_visibility','$filetype')";
	api_sql_query($query,__FILE__,__LINE__);
}

//------------------------------------------------------------------------------

/**
 * retrieve the image path list in a html file
 *
 * @author Hugues Peeters <hugues.peeters@claroline.net>
 * @param  string $htmlFile
 * @return array -  images path list
 */

function search_img_from_html($htmlFile)
{
	$imgFilePath = array();

	$fp = fopen($htmlFile, "r") or die('<center>can not open file</center>');

	// search and store occurences of the <IMG> tag in an array

	$buffer = fread( $fp, filesize($htmlFile) ) or die('<center>can not read file</center>');;

	if ( preg_match_all('~<[[:space:]]*img[^>]*>~i', $buffer, $matches) )
	{
		$imgTagList = $matches[0];
	}

	fclose ($fp); unset($buffer);

	// Search the image file path from all the <IMG> tag detected

	if ( sizeof($imgTagList)  > 0)
	{
		foreach($imgTagList as $thisImgTag)
		{
			if ( preg_match('~src[[:space:]]*=[[:space:]]*[\"]{1}([^\"]+)[\"]{1}~i',
							$thisImgTag, $matches) )
			{
				$imgPathList[] = $matches[1];
			}
		}

		$imgPathList = array_unique($imgPathList);		// remove duplicate entries
	}

	return $imgPathList;

}

//------------------------------------------------------------------------------

/**
 * creates a new directory trying to find a directory name
 * that doesn't already exist
 * (we could use unique_name() here...)
 *
 * @author Hugues Peeters <hugues.peeters@claroline.net>
 * @author Bert Vanderkimpen
 * @param array $_course current course information
 * @param int $user_id current user id
 * @param string $desiredDirName complete path of the desired name 
 * @return string actual directory name if it succeeds,
 *         boolean false otherwise
 */

function create_unexisting_directory($_course,$user_id,$to_group_id,$to_user_id,$base_work_dir,$desired_dir_name, $title = null)
{
	$nb = '';
	while ( file_exists($base_work_dir.$desired_dir_name.$nb) )
	{
		$nb += 1;
	}
	if( $title == null)
	{
		$title = basename($desired_dir_name);
	}
	if ( mkdir($base_work_dir.$desired_dir_name.$nb, 0777))
	{
		$document_id = add_document($_course, $desired_dir_name.$nb,'folder',0,$title);
		if ($document_id)
		{	
		//update document item_property
		item_property_update($_course,TOOL_DOCUMENT,$document_id,'FolderCreated',$user_id,$to_group_id,$to_user_id);
		return $desired_dir_name.$nb;
		}
	}
	else
	{
	return false;
	}
}

//------------------------------------------------------------------------------

/**
 * Handles uploaded missing images
 *
 * @author Hugues Peeters <hugues.peeters@claroline.net>
 * @author Bert Vanderkimpen
 * @param array $_course
 * @param array $uploaded_file_collection - follows the $_FILES Structure
 * @param string $base_work_dir
 * @param string $missing_files_dir
 * @param int $user_id
 * @param int $max_filled_space
 */

function move_uploaded_file_collection_into_directory($_course, $uploaded_file_collection, $base_work_dir, $missing_files_dir,$user_id,$to_group_id,$to_user_id,$max_filled_space)
{
	$number_of_uploaded_images = count($uploaded_file_collection['name']);	
	for ($i=0; $i < $number_of_uploaded_images; $i++)
		{
		$missing_file['name'] = $uploaded_file_collection['name'][$i];
		$missing_file['type'] = $uploaded_file_collection['type'][$i];
		$missing_file['tmp_name'] = $uploaded_file_collection['tmp_name'][$i];
		$missing_file['error'] = $uploaded_file_collection['error'][$i];
		$missing_file['size'] = $uploaded_file_collection['size'][$i];

		$upload_ok = process_uploaded_file($missing_file);
			if($upload_ok)
			{
			$new_file_list[] = handle_uploaded_document($_course,$missing_file,$base_work_dir,$missing_files_dir,$user_id,$to_group_id,$to_user_id,$max_filled_space,0,'overwrite');
			}
		unset($missing_file);
		}
	return $new_file_list;
}

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

/*
 * Open the old html file and replace the src path into the img tag
 * This also works for files in subdirectories.
 * @param $originalImgPath is an array
 * @param $newImgPath is an array
 */
function replace_img_path_in_html_file($originalImgPath, $newImgPath, $htmlFile)
{
	global $_course;

	/*
	 * Open the file
	 */
	$fp = fopen($htmlFile, "r");
	$buffer = fread ($fp, filesize ($htmlFile));

	/*
	 * Fix the image tags
	 */
	for ($i = 0, $fileNb = count($originalImgPath); $i < $fileNb ; $i++)
	{
		$replace_what = $originalImgPath[$i];
		/*
		we only need the directory and the filename
		/path/to/file_html_files/missing_file.gif -> file_html_files/missing_file.gif
		*/
		$exploded_file_path = explode('/',$newImgPath[$i]);
		$replace_by = $exploded_file_path[count($exploded_file_path)-2].'/'.$exploded_file_path[count($exploded_file_path)-1];
		//$message .= "Element [$i] <b>" . $replace_what . "</b> replaced by <b>" . $replace_by . "</b><br>"; //debug
		//api_display_debug_info($message);

		$buffer = str_replace( $replace_what, $replace_by, $buffer);
	}

	$new_html_content .= $buffer;

	fclose ($fp) or die ('<center>cannot close file</center>');;

	/*
	 * Write the resulted new file
	 */
	$fp = fopen($htmlFile, 'w')      or die('<center>cannot open file</center>');
	fwrite($fp, $new_html_content)   or die('<center>cannot write in file</center>');
}

//------------------------------------------------------------------------------

/**
 * Creates a file containing an html redirection to a given url
 *
 * @author Hugues Peeters <hugues.peeters@claroline.net>
 * @param string $filePath
 * @param string $url
 * @return void
 */

function create_link_file($filePath, $url)
{
	$fileContent = '<html>'
				  .'<head>'
				  .'<meta http-equiv="refresh" content="1;url='.$url.'">'
				  .'</head>'
				  .'<body>'
				  .'</body>'
				  .'</html>';

	 $fp = fopen ($filePath, 'w') or die ('can not create file');
	 fwrite($fp, $fileContent);
}

//------------------------------------------------------------------------------

/**
	Open html file $full_file_name;
	Parse the hyperlinks; and
	Write the result back in the html file.

	@author Roan Embrechts
	@version 0.1
 */
function api_replace_links_in_html($upload_path, $full_file_name)
{
	//Open the file
	$fp = fopen($full_file_name, "r");
	$buffer = fread ($fp, filesize ($full_file_name));

	//Parse the contents
	$new_html_content = api_replace_links_in_string($upload_path, $buffer);

	//Write the result
	$fp = fopen($full_file_name, "w");
	fwrite($fp, $new_html_content);
}

//------------------------------------------------------------------------------

/**
	@deprecated, use api_replace_parameter instead

	Parse the buffer string provided as parameter
	Replace the a href tags so they are displayed correctly.
	- works for files in root and subdirectories
	- replace relative hyperlinks to use showinframes.php?file= ...
	- add target="_top" to all absolute hyperlinks
	- leave local anchors untouched (e.g. #CHAPTER1)
	- leave links with download.php and showinframes.php untouched

	@author Roan Embrechts
	@version 0.6
*/
function api_replace_links_in_string($upload_path, $buffer)
{
	// Search for hyperlinks
	if ( preg_match_all("/<a[\s]*href[^<]*>/i", $buffer, $matches) )
	{
		$tag_list = $matches[0];
	}

	// Search the filepath of all detected <a href> tags
	if (sizeof($tag_list)  > 0)
	{
		$file_path_list=array();
		$href_list=array();

		foreach($tag_list as $this_tag)
		{
			/* Match case insensitive, the stuff between the two ~ :
				a href = <exactly one quote><one or more non-quotes><exactly one ">
				e.g. a href="www.google.be", A HREF =   "info.html"
				to match ["] escape the " or else PHP interprets it
				[\"]{1} --> matches exactly one "
				+	1 or more (like * is 0 or more)
				[\s]* matches whitespace
				$matches contains captured subpatterns
				the only one here is ([^\"]+) --> matches[1]
			*/
			if ( preg_match("~a href[\s]*=[\s]*[\"]{1}([^\"]+)[\"]{1}~i",
				   		 $this_tag, $matches) )
			{
				$file_path_list[] = $matches[1];//older
				$href_list[] = $matches[0];//to also add target="_top"
			}
		}


	}

	// replace the original hyperlinks
	// by the correct ones
	for ($count = 0; $count < sizeof($href_list); $count++)
	{
		$replaceWhat[$count] = $href_list[$count];

		$is_absolute_hyperlink = strpos($replaceWhat[$count], "http");
		$is_local_anchor = strpos($replaceWhat[$count], "#");
		if ($is_absolute_hyperlink == false && $is_local_anchor == false )
		{
			//this is a relative hyperlink
			if (
				(strpos($replaceWhat[$count], "showinframes.php") == false) &&
				(strpos($replaceWhat[$count], "download.php") == false)
				)
			{
				//fix the link to use showinframes.php
				$replaceBy[$count] = "a href = \"showinframes.php?file=" . $upload_path."/".$file_path_list[$count]."\" target=\"_top\"";
			}
			else
			{
				//url already fixed, leave as is
				$replaceBy[$count] = $replaceWhat[$count];
			}
		}
		else if ($is_absolute_hyperlink)
		{
			$replaceBy[$count] = "a href=\"" . $file_path_list[$count] . "\" target =\"_top\"";
		}
		else
		{
			//don't change anything
			$replaceBy[$count] = $replaceWhat[$count];
		}
		//Display::display_normal_message("link replaced by " . $replaceBy[$count]); //debug
	}

	$buffer = str_replace($replaceWhat, $replaceBy, $buffer);
	return $buffer;
}

//------------------------------------------------------------------------------

/**
	EXPERIMENTAL - function seems to work, needs more testing

	@param $upload_path is the path where the document is stored, like "/archive/"
	if it is the root level, the function expects "/"
	otherwise "/path/"

	This function parses all tags with $param_name parameters.
	so the tags are displayed correctly.

	--------------
	Algorithm v1.0
	--------------
		given a string and a parameter,
		* OK find all tags in that string with the specified parameter (like href or src)
		* OK for every one of these tags, find the src|href|... part to edit it
		* OK change the src|href|... part to use download.php (or showinframes.php)
		* OK do some special stuff for hyperlinks

		Exceptions
		* OK if download.php or showinframes.php is already in the tag, leave it alone
		* OK if mailto is in the tag, leave it alone
		* OK if the src|href param contains http://, it's absolute --> leave it alone

		Special for hyperlinks (a href...)
		* OK add target="_top"
		* OK use showinframes.php instead of download.php

	@author Roan Embrechts
	@version 1.1
*/
function api_replace_parameter($upload_path, $buffer, $param_name="src")
{
	/*
	 *	Search for tags with $param_name as a parameter
	 */
	/*
	// [\s]*	matches whitespace
	// [\"=a-z] matches ", = and a-z
	// ([\s]*[a-z]*)*	matches all whitespace and normal alphabet
	//					characters a-z combinations but seems too slow
	//	perhaps ([\s]*[a-z]*) a maximum number of times ?
	// [\s]*[a-z]*[\s]*	matches many tags
	// the ending "i" means to match case insensitive (a matches a and A)
	*/
	if ( preg_match_all("/<[a-z]+[^<]*".$param_name."[^<]*>/i", $buffer, $matches) )
	{
		$tag_list = $matches[0];
	}

	/*
	 *	Search the filepath of parameter $param_name in all detected tags
	 */
	if (sizeof($tag_list)  > 0)
	{
		$file_path_list=array();
		$href_list=array();

		foreach($tag_list as $this_tag)
		{
			//Display::display_normal_message(htmlentities($this_tag)); //debug
			if ( preg_match("~".$param_name."[\s]*=[\s]*[\"]{1}([^\"]+)[\"]{1}~i",
						$this_tag, $matches) )

			{
				$file_path_list[] = $matches[1];//older
				$href_list[] = $matches[0];//to also add target="_top"
			}
		}
	}

	/*
	 *	Replace the original tags by the correct ones
	 */
	for ($count = 0; $count < sizeof($href_list); $count++)
	{
		$replaceWhat[$count] = $href_list[$count];

		$is_absolute_hyperlink = strpos($replaceWhat[$count], "http");
		$is_local_anchor = strpos($replaceWhat[$count], "#");
		if ($is_absolute_hyperlink == false && $is_local_anchor == false )
		{
			if (
				(strpos($replaceWhat[$count], "showinframes.php") == false) &&
				(strpos($replaceWhat[$count], "download.php") == false) &&
				(strpos($replaceWhat[$count], "mailto") == false)
				)
			{
				//fix the link to use download.php or showinframes.php
				if ( preg_match("/<a([\s]*[\"\/:'=a-z0-9]*){5}href[^<]*>/i", $tag_list[$count], $match_hyperlink) )
				{
					$replaceBy[$count] = " $param_name =\"showinframes.php?file=" . $upload_path.$file_path_list[$count]."\" target=\"_top\" ";
				}
				else
				{
					$replaceBy[$count] = " $param_name =\"download.php?doc_url=" . $upload_path.$file_path_list[$count]."\" ";
				}
			}
			else
			{
				//"mailto" or url already fixed, leave as is
				//$message .= "Already fixed or contains mailto: ";
				$replaceBy[$count] = $replaceWhat[$count];
			}
		}
		else if ($is_absolute_hyperlink)
		{
			//$message .= "Absolute hyperlink, don't change, add target=_top: ";
			$replaceBy[$count] = " $param_name=\"" . $file_path_list[$count] . "\" target =\"_top\"";
		}
		else
		{
			//don't change anything
			//$message .= "Local anchor, don't change: ";
			$replaceBy[$count] = $replaceWhat[$count];
		}
		//$message .= "In tag $count, <b>" . htmlentities($tag_list[$count])
		//	. "</b>, parameter <b>" . $replaceWhat[$count] . "</b> replaced by <b>" . $replaceBy[$count] . "</b><br>"; //debug
	}
	//if (isset($message) && $message == true) api_display_debug_info($message); //debug
	$buffer = str_replace($replaceWhat, $replaceBy, $buffer);
	return $buffer;
}

//------------------------------------------------------------------------------

/**
 * Checks the extension of a file, if it's .htm or .html
 * we use search_img_from_html to get all image paths in the file
 *
 * @param string $file
 * @return array paths
 * @see check_for_missing_files() uses search_img_from_html()
 */
function check_for_missing_files($file)
{
	if (strrchr($file, '.') == '.htm' || strrchr($file, '.') == '.html')
	{
		$img_file_path = search_img_from_html($file);
		return $img_file_path;
	}
	return false;
}

//------------------------------------------------------------------------------

/**
 * This builds a form that asks for the missing images in a html file
 * maybe we should do this another way?
 *
 * @param array $missing_files
 * @param string $upload_path
 * @param string $file_name
 * @return string the form
 */
function build_missing_files_form($missing_files,$upload_path,$file_name)
{
		//do we need a / or not?
		$added_slash = ($upload_path=='/')?'':'/';
		//build the form
		$form .= "<p><strong>".get_lang('MissingImagesDetected')."</strong></p>\n"
				."<form method=\"post\" action=\"".$_SERVER['PHP_SELF']."\" enctype=\"multipart/form-data\">\n"
				//related_file is the path to the file that has missing images
				."<input type=\"hidden\" name=\"related_file\" value=\"".$upload_path.$added_slash.$file_name."\" />\n"
				."<input type=\"hidden\" name=\"upload_path\" value=\"".$upload_path."\" />\n"
				."<table border=\"0\">\n";
				foreach($missing_files as $this_img_file_path )
				{
				$form .= "<tr>\n"
					   ."<td>".basename($this_img_file_path)." : </td>\n"
					   ."<td>"
					   ."<input type=\"file\" name=\"img_file[]\"/>"
					   ."<input type=\"hidden\" name=\"img_file_path[]\" value=\"".$this_img_file_path."\" />"
					   ."</td>\n"
					   ."</tr>\n";
				}
				$form .= "</table>\n"
						."<input type=\"submit\" name=\"cancel_submit_image\" value=\"".get_lang('Cancel')."\"/>\n"
						."<input type=\"submit\" name=\"submit_image\" value=\"".get_lang('Ok')."\"/><br/>"
						."</form>\n";
				return $form;
}

//------------------------------------------------------------------------------

/**
 * This recursive function can be used during the upgrade process form older versions of Dokeos
 * It crawls the given directory, checks if the file is in the DB and adds it if it's not
 *
 * @param string $base_work_dir
 * @param string $current_path, needed for recursivity
 */
function add_all_documents_in_folder_to_database($_course,$_uid,$base_work_dir,$current_path='')
{

$path = $base_work_dir.$current_path;
//open dir
$handle=opendir($path);
	//run trough
	while($file=readdir($handle)) 
	{
	   if ($file=='.' || $file=='..') continue;
	   
	   $completepath="$path/$file";
	   //directory?
	   if (is_dir($completepath)) 
	   {
	   	$title=get_document_title($file);
	   	$safe_file=replace_dangerous_char($file);
		@rename($path.'/'.$file, $path.'/'.$safe_file);
		//if we can't find the file, add it	
		if(!DocumentManager::get_document_id($_course, $current_path.'/'.$safe_file))
		{
			$document_id=add_document($_course,$current_path.'/'.$safe_file,'folder',0,$title);
			item_property_update($_course,TOOL_DOCUMENT,$document_id,'DocumentAdded',$_uid);
			//echo $current_path.'/'.$safe_file." added!<br/>";
			
		}
		//recursive
		add_all_documents_in_folder_to_database($_course,$_uid,$base_work_dir,$current_path.'/'.$safe_file);
	    } 
	    //file!
	    else 
		{
			//rename
			$safe_file=disable_dangerous_file(replace_dangerous_char($file));
			@rename($base_work_dir.$current_path.'/'.$file,$base_work_dir.$current_path.'/'.$safe_file);
			if(!DocumentManager::get_document_id($_course, $current_path.'/'.$safe_file))
			{
			$title=get_document_title($file);
			$size = filesize($base_work_dir.$current_path.'/'.$safe_file);
			$document_id = add_document($_course,$current_path.'/'.$safe_file,'file',$size,$title);
			item_property_update($_course,TOOL_DOCUMENT,$document_id,'DocumentAdded',$_uid);
			//echo $current_path.'/'.$safe_file." added!<br/>";
			}
	    }
	}
}

?>