Codulle - L'explorateur de code sources

<?php
 
////////////////////////////////////////
// Encodage du fichier : UTF-8
// Utilisation des tabulations : Oui
// 1 tabulation = 4 caractères
// Fins de lignes = LF (Unix)
////////////////////////////////////////
 
///////////////////////////////
// LICENCE
///////////////////////////////
//
// This file is part of Codulle.
//
// Codulle 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.
// 
// Codulle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Codulle; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
// 
///////////////////////////////
 
 
/**
 * Librairie de fonctions inclassables.
 *
 * @author SamRay1024
 * @copyright Bubulles Creation - http://jebulle.net
 * @license http://gnu.org/copyleft/gpl.html GNU GPL
 * @since 24/11/2005
 * @version 1.0
 */
 
 
/**
 * Fonction avancée de lecture de dossiers.
 *
 * La fonction reçoit un chemin de dossier, ouvre ce dossier et en donne la liste des éléments, qui
 * peuvent être ou les dossiers, ou les fichiers, ou les deux.
 *
 * Les éléments lus du dossiers sont retournés dans un tableau de deux manières différentes. Pour
 * les cas où soit les dossiers, soit les fichiers sont demandés, le tableau retourné est un tableau
 * indexé classique à une dimension. En revanche pour le cas ou les deux types sont demandés, le tableau
 * retourné est un tableau à deux dimensions. La 1ère est associative et contient deux sous-tableaux :
 * l'un pour les dossiers, l'autre pour les fichiers.
 *
 * 		$aTableauRetour['dir'] contient les dossiers lus.
 * 		$aTableauRetour['file'] contient les fichiers lus.
 *
 * Les deux sous tableaux sont eux indexés classiquement, tout comme les tableaux de retour sur l'un
 * ou l'autre des types demandés (dossiers/fichiers).
 * 
 * @param	[STRING]	$sDir		Chemin du dossier à parcourir.
 * @param	[STRING]	$sMode		Modes de parcours du dossier :
 * 										'DOSSIERS_SEULEMENT'	=> retourne uniquement les dossiers.
 * 										'FICHIERS_SEULEMENT'	=> retourne uniquement les fichiers.
 * 										'TOUT'					=> retourne tous les éléments (dossiers ET fichiers).
 * @return	[MIXED]					FALSE en cas d'erreur, tableau des éléments lus sinon.
*/
function advScanDir( $sDir, $sMode, $aFiltres = array() )
{
	
	// creation du tableau qui va contenir les elements du dossier
	$aItemsDir = $aItemsFile = array();
	
	// ajout du slash a la fin du chemin s'il n'y est pas
	if( !preg_match( "/^.*\/$/", $sDir ) ) $sDir .= '/';
	
	// Ouverture du repertoire demande
	$handle = @opendir( $sDir );
	
	// si pas d'erreur d'ouverture du dossier on lance le scan
	if( $handle != false )
	{
		// Parcours du repertoire
		while( $sItem = readdir($handle) )
		{
			if($sItem != '.' && $sItem != '..' && !in_array( $sItem, $aFiltres ) )
			{
				
				if( is_dir( $sDir.$sItem ) )
					$aItemsDir[] = $sItem;
				else
					$aItemsFile[] = $sItem;
				
			}
		}
		
		// Fermeture du repertoire
		closedir($handle);
		
		// Tri des dossiers
		sort( $aItemsDir );
		sort( $aItemsFile );
		
		// construction tableau retour
		switch( $sMode )
		{
			case 'DOSSIERS_SEULEMENT' :
					return $aItemsDir;
				break;
			
			case 'FICHIERS_SEULEMENT' :
					return $aItemsFile;
				break;
			
			case  'TOUT' :
				return array( 'dir' => $aItemsDir, 'file' => $aItemsFile );
		}
		
		return array();	
	}
	else return false;
	
}
 
/**
 * Extraire à gauche de la n-ième sous-chaîne.
 *
 * Extrait d'une chaine tout ce qui se trouve à gauche de la n-ième sous-chaine
 * spécifiée. Par exemple, pour extraire les chemins parents dans une chaine de
 * caractères qui contient un chemin :
 * 		echo SousChaineGauche( 'dossier1/dossier2/dossier3/dossier4', '/', 2 );
 * 		=> Affiche : dossier1/dossier2
 *
 * @param	[STRING]	$sChainePrincipale	La chaine dans laquelle on doit faire l'extraction.
 * @param	[STRING]	$sSousChaine		La chaine à repérer.
 * @param	[INTEGER]	$iNbOccurences		Le nombre d'occurences à partir duquel on garde ce qui se trouve
 *											à gauche de la sous-chaine.
 * @return	[STRING]	Retourne $sChainePrincipale tronquée.
 */
function SousChaineGauche( $sChainePrincipale, $sSousChaine, $iNbOccurences )
{
	if( $sChainePrincipale !== '' )
	{
		$iOffSet = 0;
		
		for( $i = 0 ; ( $i < $iNbOccurences) && ( $iOffSet !== false ) ; $i++ )
		{
			$iOffSet = strrpos( $sChainePrincipale, $sSousChaine );
			
			if( $iOffSet !== false )
				$sChainePrincipale = substr( $sChainePrincipale, 0, $iOffSet );
		}
	}
	
	return $sChainePrincipale;	
}
 
/**
 * Nettoyer une chaine de chemin d'accès qui provient d'une URL.
 * 
 * Cette fonction permet le nettoyage d'une chaine qui représente un chemin vers un dossier quelconque.
 * Elle est destinée à eviter les failles d'accès à des dossiers interdits par une URL. Elle se charge
 * donc de repérer les dossiers vides ('//'), les noms tels './' et '../'. En plus, il est possible
 * de demander à la fonction d'interdire des dossiers spécifiques dont vous passez le nom par
 * l'intermédiaire d'un tableau.
 * 
 * La chaine étant passée par référence, elle n'est pas retournée par la fonction et est directement
 * utilisable dans le fichier appelant.
 *
 * @param	[STRING]	$sChaine				Passée par référence, la chaine est nettoyée des dossiers interdits.
 * @param	[ARRAY]		$aDossiersInterdits		Optionnel. Contient une liste de dossiers interdits.
 * @return	[ARRAY]								Retourne la chaine d'accès sous forme de tableau (pour des traitements ultérieurs)
 */
function nettoyerCheminURL( &$sChaine, $aDossiersInterdits = array() )
{
	$sExpRegDossiersInterdits = '';
	
	// On eclate le chemin dans un tableau extraire chaque dossier
	$aDossiers = explode( '/', $sChaine );
 
	// on calcul le nombres de dossiers passés dans l'url
	$iNbDossiers = sizeof($aDossiers);
	
	// Si des dossiers sont interdits, on construit la fin de l'expression régulière
	$iNbDossiersInterdits = sizeof($aDossiersInterdits);
	if( $iNbDossiersInterdits !== 0 )
		for( $i = 0 ; $i < $iNbDossiersInterdits ; $i++ )
			$sExpRegDossiersInterdits .= '|'.$aDossiersInterdits[$i];
	
	// nettoyage des dossiers, pour enlever les chaines vides, les accès du type ./ et ../
	// et les dossiers interdits
	for( $i = 0 ; $i < $iNiveau ; $i++ )
		if( $aDossiers[$i] === '' || preg_match('/^[.]+$'.$sExpRegDossiersInterdits.'/', $aDossiers[$i]) !== 0 )
			unset( $aDossiers[$i] );
	
	// reconstruction des index du tableau
	$aDossiers = array_merge($aDossiers);
	
	// Reconstruction de la chaine d'accès nettoyée
	$sChaine = implode( '/', $aDossiers );
	
	return $aDossiers;
}
 
 
?> 

• Remonter
• classes (2)
• includes (2)
• config.php
• fonctions.php
• projets (0)
• themes (1)