pour télécharger des fichiers (sonnerie, images, etc...) sur son mobile lorsqu'on a pas de liaison (cable, ir, bluthooth) avec un ordinateur ou un pda, le seul recours est de placer ses fichiers sur un serveur web et de les récupérer par le wap, en tapant 1 par 1 l'url de chaque fichier sur le petit clavier du gsm : c'est très fastidieux !
C'est pourquoi cette explorateur de fichier a été créé et permet de surfer sur le serveur et de récupérer par simple clique chaque fichier !
Il est doté de fonctionnalités avancées :
- possibilité de générer une page wap (wml), ou bien une page i-mode(chtml)
- paramétrage d'une taille maximale de la page, car la plupart des gsm buguent pour des pages trop grandes (3,0 ko max pour certain gsm).
- trier les fichiers :
par date (du plus récent au plus ancien),
ordre alphabétique,
taille du fichier (la taille est alors indiquée, en ko)
ou par type de fichiers (affiche alors la résolution des images par ordre croissant)
- possibilité de modifier facilement les textes de début et de fin de page.
- possibilité d'interdire l'exploration de certains fichiers ou dossiers.
- possibilité d'afficher des images de dossiers ou de flèches (non supportées par tous les gsm ou émulateur).
Cet explorateur de fichier n'est pas classique car il s'adapte aux spécificités du wap :
- taille maximale de la page générée,
- peut renommer les fichiers possédant des caractères interdit, (car à la moindre erreur : accent laissé ou autre, et le gsm refuse alors de télécharger le fichier ou d'accéder au dossier).
- j'ai joint, dans l'archive zip, le fichier ".htaccess" contenant la déclaration de nombreux types mimes, nécessaire au download de fichiers wml et de divers formats de sonneries, images, jeux,...
Source / Exemple :
<?php
$time = getmicrotime();
//-------------------------------//
// Configuration //
//-----------------------------//
$langage = 'wap'; // 'wap' ou 'imode'; langage de la page générée. il s'agit du wap (wml1.0 à 2.0) ou du i-mode (chtml)
$NomDuPremierRepertoire = 'accueil'; // nom qui s'affiche pour le premier dossier explorable
$PremierDossierAExplorer = ''; // pour que le premier dossier à explorer soit celui dans lequel est placé ce fichier : mettre '' (vide). sinon, mettre './mondossier1' ou './mondossier1/mondossier2'(commence par un point + slash, et pas de slash final);
$taillemax = 3.0; //definir la taille maximum de la page wap ou chtml en ko (mettre un point et non une virgule avant les décimales).
$NombreMaxDeLiensParPage = 0 ; // mettre 0 pour aucune restriction (nombre maximum).
$AutoriseRenommageFichiers = 'non'; // 'oui' ou 'non' ; ne mettre 'oui'que si vous rencontrez des problème avec les fichiers acuentués ou contenant des caractères spéciaux. permet de renommer les fichiers ou dossiers qui risquent de faire planter la page (contenant des accuents). Vous pouvez protéger vos fichiers ci-dessous.
$FichiersEtDossiersInterdits= array( 'un fichier protege.zip', 'un dossier protege', 'index.php', 'index.htm','.htaccess' ); // mettre les noms des fichiers et les nom des dossiers ne devant pas apparaitre dans l'exploration
$ExtensionsAutorisees = '' ;
$ExtensionsInterdites ='php|php3|htm|css|js|asp'; // fichiers ne devant pas aparaitre dans l'exploration : placer les extension, séparées par un séparateur| sans espaces et sans point.
// tri par defaut ; (les dossiers seront toujours en premier) ;
// 'd' : trier par date décroissante (du plus récent au plus ancien) ;
// 'n' : trier par ordre alphabetique insensible à la casse et ordre naturelle (img5.bmp placé avant img15.bmp),
// 't' : trier par taille (et affiche la taille du fichier en ko)
// 'e' : trier par extension : affiche les dossiers puis tous les formats d'images classés par résolution (qui est affichée) puis tous les autres fichiers classés par extension.
$TriDispo = array('n','d','t','e'); // autorise à trier. Pour ne pas proposer de choix de tri, mettre : $TriDispo = array('');
$TriParDefaut = 'n';
$extensionsImages = array ('bmp', 'gif', 'jpg','jpeg','tif','png','mng','wbmp'); // formats d'images dont on cherchera a afficher la résolution.
$Autorise_Download = true ; // true : autorise de download de fichiers.
$MethodDownload = 2 ;
// 1 : envoie le contenu du fichier par php : encore quelques problèmes pour transmettre le nom du fichier, et pour certains types de fichiers : à éviter
// 2 : redirection par php : méthode recommandée
// 3 : affiche une page avec le lien à cliquer vers le fichier.
// pour compression des url :
$compression_Activee = true ; // true ou false pour activer ou désastiver la compression des url (plus de liens par pages si beaucoup de fichiers ou arborescence volumineuse des dossiers).
$FichierDeCompression = 'compression.txt' ; // nom du fichier de compression, qui sera généré.
$CompressionAPartirDe = 1 ; // nombre de page non compressées à partir duquel on va activer la compression des url
// éléments de présentation :
$afficherImagePage = 'non' ; // 'oui' ou 'non' : permet d'afficher une icone de fleche, uniquement valable si $langage = 'wap'; non supporté par tous les gsm ou emulmateurs
$afficherImageDossier = 'non';// 'oui' ou 'non' : permet d'afficher une icone de dossier, uniquement valable si $langage = 'wap'; non supporté par tous les gsm ou emulmateurs
$PrefixDossier = 'D '; // apparait avant le nom du dossier, pour le différencier d'un fichier
$PrefixFichier = ''; // apparait avant le nom du fichier, pour le différencier d'un dossier
$SeparateurNavigation = ' / ' ;
$SeparateurTri = ', ';
$separateurPageActuelle = ' / ';
$separateurPageSuivante = ' | ' ;
// débugage
$AuditTailleAffichage = 'non' ; // 'oui' ou 'non' : pour webmaster : affiche la taille exacte de la page générée avec le détail par éléments de présentation.
$debugRep = 0; // '1' ou '0';
$DebugDownload = 0; // '1' ou '0';
$debugOrdre = 0 ; // '1' ou '0';
$DebugPageEstimee = 0 ; // '1' ou '0'
//--------------------------//
// Texte affiché //
//-------------------------//
// Tous les accuents seront supprimés.
$title = 'explowap'; // titre de la page (balises "title")
$TexteDebut ='Explorateur '.ucfirst(strtolower(trim($langage))) ;
$TexteRetour = 'retour au dossier precedent'; // texte pour revenir au dossier précédent (proposé en bas de page générée)
$TexteFin = '';
$TexteClassement = 'tri par : ';
$TabTri = array( 'n'=>'fichiers' ,'d' => 'date' , 't' => 'taille','e' => 'type') ;
$TexteLienPageSuivante = '-->' ; //'>';//correspond à -->
$TexteLienPagePrecedente = '<--' ; //'<';// correspond à <--
$TexteAbsenceFichier = '<strong>Aucun fichier</strong> dans ce dossier.';
$TexteErreurDossier = 'le <strong>dossier</strong> demande est <strong>invalide</strong> ou <strong>protege</strong>';
$TexteErreurFichier = 'le <strong>fichier</strong> demande est <strong>invalide</strong> ou <strong>protege</strong>';
$TexteDownload = '<strong>Telecharger</strong> le fichier :';
//-------------------------------//
//to do //
//-----------------------------//
/*
// a faire :
- pages estimée si n page max (uniquement pour accélérer la génération de la page).
- wap uniquement : système de "card" associé au nombre de liens max par pages
- corriger finement la méthode de download n°1
//-----------------------------------------//
// initialisation //
//---------------------------------------//
// nom du fichier de navigation. ce fichier sera copié dans tous les dossiers à explorer.
$NomDuFichier = basename($_SERVER['PHP_SELF']);
//ob_start();
ini_set('track_errors', 1); // la derniere erreur sera enregistrée dans la variable globale $php_errormsg
//connection_aborted() indiquera si le client a interrompu la connexion !
// première page = 1 ; ne pas toucher à ce paramètre
$PageParDefaut = 1 ;
$VariablesURLParDefaut = array('t' => $TriParDefaut, 'p' => $PageParDefaut, 'd' => '' );
// rajoute aux fichiers cachés le nom de ce fichier, et les dossiers courant et précédent
$protect = array_merge(array('.','..',$NomDuFichier, $FichierDeCompression), $FichiersEtDossiersInterdits);
// on controle la valeur que le webmaster a tapé dans la config : $PremierDossierAExplorer = "wap/fichier/Mon premier dossier"
//et non pas une valeur qui poserai problème, comme $PremierDossierAExplorer = "./wap/fichier/Mon premier dossier/"
$PremierDossierAExplorer = ereg_replace('^\./|^\.|^/|/$','',$PremierDossierAExplorer) ;
// chemin du premier dosier à explorer
$PatchPremierDossierAExplorer = './'.$PremierDossierAExplorer ;
// si $TempTexteErreur ne vaut plus null, c'est qu'une erreur est survenue.
$TempTexteErreur = '' ;
// $DespecialiseRegex est utilisé pour despecialiser les masques (regex) :
// à utiliser sous la forme : ereg(strtr($valeurRecherchee, $DespecialiseRegex), $AuSeinDeCetteVariable)
$DespecialiseRegex = array('^'=>'\^','.'=>'\.','['=>'\[',']'=>'\]','$'=>'\$','('=>'\(',')'=>'\)','|'=>'\|','*'=>'\*','+'=>'\+','?'=>'\?','{'=>'\{','}'=>'\}','\\'=>'\\\\');
// pour explorer les dossiers, on utilise :
$SlashOuAntiSlash = '/' ;
// on peut changer cette valeur
set_magic_quotes_runtime(0);
$FacteurConvertionEnKo = 1/1000*(1024/1000) ;
$TailleMaxPageEnOctet = $taillemax / $FacteurConvertionEnKo ;
$remplacementRename = array("\'"=> "'" , "'"=> ' ' , "#"=> ' ' , "%"=> ' ' , '&'=> 'Et' , '°'=> 'Deg' , 'º'=> 'Deg' , '£'=> 'Pounds' , '¤'=> 'Et' , 'µ'=> 'u' , '§'=> 'S' , ''=> 'Euros');
// pour formater les nom de fichiers ou dossiers :
$remplacementlien = array('-'=> '' , "\'"=> ''', '<' => '<', '>' => '>', '"' => '"', '&' => '&') ;
//-----------------------------------------//
// formate le texte //
//---------------------------------------//
$TexteDebut = TexteWml($TexteDebut) ;
$TexteRetour = TexteWml($TexteRetour) ; // texte pour revenir au dossier précédent (proposé en bas de page générée)
$TexteFin = TexteWml($TexteFin); ;
$TexteClassement = TexteWml($TexteClassement) ;
$TabTri = array_map( 'TexteWml', $TabTri) ;
$TexteLienPageSuivante = TexteWml($TexteLienPageSuivante) ;
$TexteLienPagePrecedente = TexteWml($TexteLienPagePrecedente) ;
$TexteAbsenceFichier = TexteWml($TexteAbsenceFichier) ;
$TexteErreurDossier = TexteWml( $TexteErreurDossier) ;
$TexteErreurFichier = TexteWml($TexteErreurFichier) ;
$TexteDownload = TexteWml($TexteDownload);
//----------------------------------------------------------------------------------//
// valeur des balises selon qu'on affiche une page wap ou une page imode //
//--------------------------------------------------------------------------------//
$XMLversion = '<?xml version="1.0" encoding="iso-8859-1"?>'."\n" ;
$PalignCenter=' align="center">'; $PalignRight=' align="right">';
if($langage == 'wap') {
// le fichier généré est un fichier wml (wap)
$header = 'Content-Type: text/vnd.wap.wml';
$DocType = '<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "
http://www.wapforum.org/DTD/wml_1.1.xml">';
$BalisesHeadOuvre = '<wml><head><meta http-equiv="Cache-Control" content="max-age=30" forua="true"/>' ;
$BalisesHeadFerme = '</head><card id="'.$title.'">';
$BaliseSautDeLigne = '<br/>';
$BalisesFin = '</card></wml>';
$BaliseAOuvre = '<a href="'; $BaliseAFerme = '</a>';
$BalisePOuvre = '<p'; $BalisePFerme = '</p>';
if($afficherImageDossier == 'oui') $PrefixDossier = '<img alt="'.$PrefixDossier.'" localsrc="folder1" src=""/> ';
if($afficherImagePage == 'oui') {
$TexteLienPageSuivante = '<img alt="'.$TexteLienPageSuivante.'" localsrc="rightarrow2" src=""/>';
$TexteLienPagePrecedente = '<img alt="'.$TexteLienPagePrecedente.'" localsrc="leftarrow2" src=""/>';
};
}else{
// $languge == imode : la poge générée est une page i-mode
$header = 'Content-Type: text/html';
$DocType = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD Compact HTML 1.0 Draft//EN">';
$BalisesHeadOuvre = '<HTML><HEAD><TITLE>'.$title.'</TITLE>' ;
$BalisesHeadFerme = '</HEAD><BODY>';
$BaliseAOuvre = '<A href="'; $BaliseAFerme = '</A>';
$BalisePOuvre = '<DIV'; $BalisePFerme = '</DIV>';
$BaliseSautDeLigne = '<BR>';
$BalisesFin = '</BODY></HTML>';
};
//-----------------------------------------//
// download de fichiers //
//---------------------------------------//
//echo $XMLversion.$DocType.$BalisesHeadOuvre.$BalisesHeadFerme ;
$download = false ;
if(isset($_GET['f'])) {
$downloadFile = DeCompresseNom(MyStripSlashes_gpc(urldecode($_GET['f']))) ;
if(isAllowedExtension($downloadFile)){
$download = true ;
$downloadFileName = basename($downloadFile );
$fromEnLien = ereg_replace('/?'.strtr($downloadFileName, $DespecialiseRegex).'$', '', $downloadFile) ;
// $fromEnLien sera contolé par la voie générale
if(ereg('[*/\?:"|<>]', $downloadFileName)) $TempTexteErreur = $TexteErreurFichier ;
if($DebugDownload ==1)echo '<br/>$downloadFile'." = $downloadFile".'<br/>$downloadFileName'." = $downloadFileName".'<br/>$fromEnLien'." = $fromEnLien" ;
}else{
// si qq1 a rentré dans l'url' ?f= ' (vide) ou extension interdite--> affiche "erreur fichier" et cherchera s'il existe aussi '?d=xxxx/yyyy' pour afficher ce dossier.
$TempTexteErreur = $TexteErreurFichier ;
};
};
//------------------------------------------------------//
// Recupère dans l'url le tri , la page et le dossier à afficher //
//----------------------------------------------------//
$tri = (isset($_GET['t']) && in_array(MyStripSlashes_gpc(urldecode($_GET['t'])),$TriDispo)) ? MyStripSlashes_gpc(urldecode($_GET['t'])) : $TriParDefaut;
$page = (isset($_GET['p']) && is_numeric( MyStripSlashes_gpc(urldecode($_GET['p'])))) ? MyStripSlashes_gpc(urldecode($_GET['p'])) : $PageParDefaut;
// recupère le dossier à afficher
// si action de download de fichier, on connait $fromEnLien mais ont veut en vérifier la syntaxe et la validité.
if($download || isset($_GET['d'])){
if( ! $download) $fromEnLien = DeCompresseNom(urldecode($_GET['d'])) ;
if(trim($fromEnLien) == ''){$fromEnLien = '' ;}
// SECURITE +++ : la ligne ci-dessous interdit de remonter au dessus du fichier $NomDuFichier
// si contient '..' ou './.' ou './' ou 'http:' ou 'ftp:' ou n'est qu'un point '.' --> Hacking ! on bloque.
// l'adresse demandée est anormale -- > on bloque
elseif(ereg('\.\.|^\./|\\\\|http:|ftp:|^\.$', $fromEnLien))
{
$TempTexteErreur = ( $download ) ? $TexteErreurFichier : $TexteErreurDossier ;
$fromEnLien = '' ;
}else{
// le dossier demandé semble valide
// s'assure que $fromEnLien est écrit correctement enlève les / initiaux et finaux, et si commence par un point, on l'enlève.
$fromEnLien = ereg_replace('^\./|^\.|^/|/$','',$fromEnLien);
};
}else{
$fromEnLien = '';
};
// from sera utiliser pour tout ce qui concerne les chemins des fichiers ou dossiers !!!
// $from aura la forme : "./" ou "./premierdossier" ou "./premierdossier/repertoire 2"
$from = './'.ereg_replace('/$', '', (addEndSlash($PremierDossierAExplorer).$fromEnLien)) ;
//-----------------------------------------//
// Texte : dossier actuel + controle que le dosier demandé est valide//
//---------------------------------------//
$cheminRepertoire = '' ;
$arbo = explode($SlashOuAntiSlash,$from) ;
if($debugRep == 1) {
echo "<pre>Arborescence explorée dossier par dossier, en descendant : \n"; print_r($arbo);echo '</pre>';
echo '<br />$SlashOuAntiSlash = '.$SlashOuAntiSlash. '<br/>$from = '."$from".'<br/>$fromEnLien = '."$fromEnLien".'<br/>$PatchPremierDossierAExplorer = '.$PatchPremierDossierAExplorer;
};
foreach ($arbo as $repertoire){
if($debugRep ==1) echo '<br/><br/>$cheminRepertoire1 = '."$cheminRepertoire <br/>".'$repertoire'." = $repertoire";
($cheminRepertoire != '') ? $cheminRepertoire .= $SlashOuAntiSlash.$repertoire : $cheminRepertoire .= $repertoire ;
// cas particulier où $cheminRepertoire = '.' (cad le premier passage) :
//- si $PremierDossierAExplorer == '' : pour afficher le dossier racine, il va faloir
// passer au travers de tous les testes, par forcerTest=='oui' , à chaque test
//- si le premier dossier à explorer est défini dans la config ($PremierDossierAExplorer = 'mondossier')
// on passe l'étape inutile par un "continue".
if($cheminRepertoire == '.' ) {
//$cheminRepertoire .= $repertoire ; // cad : $cheminRepertoire vaut '.' (au lieu de '/.')
if($PremierDossierAExplorer == '') {
$cheminRepertoire = './' ; $repertoire = './';
}else continue ;
} //else{$cheminRepertoire .= $SlashOuAntiSlash.$repertoire ;};
if($debugRep ==1) echo '<br/>$cheminRepertoire2 = '."$cheminRepertoire <br/>".'$repertoire'." = $repertoire";
//echo (is_dir('./')) ? 'vrai': 'faux' ;// -- > retourne vrai
if( ! in_array($repertoire,$protect ) && is_dir($cheminRepertoire))
{
if($PremierDossierAExplorer == '' && $cheminRepertoire == './' && $repertoire == '') continue ; // break; marche aussi : on à la fin de l'arborescence
// RENOMER SANS ACCUENT ??
// la condition ci-dessous permet de savoir qu'on se situe en dessous (après) le premier dossier à explorer
// despeciaise les cractères speciaux de regex : ^ . [ ] $ ( ) | * + ? { } \
if(ereg('^'.strtr($PatchPremierDossierAExplorer, $DespecialiseRegex), $cheminRepertoire))
{
// nom du répertoire selon si c'est le premier dossier à explorer ou pas.
($cheminRepertoire == $PatchPremierDossierAExplorer) ?
$NomRepertoire = $NomDuPremierRepertoire : $NomRepertoire = $repertoire ;
// valeur de la variable du chemin du dossier passée dans l'url (attention : la condition est inversée par rapport à ci-dessus)
$urlDeCeDossier = ereg_replace('^/','',ereg_replace('^'.strtr($PatchPremierDossierAExplorer, $DespecialiseRegex),'',$cheminRepertoire)) ;
// enregistre le lien pour la navigation
$TabLiensRepertoiresNom[] = $NomRepertoire ;
$TabLiensRepertoiresPatch[] = $urlDeCeDossier ;
if($PremierDossierAExplorer == '' && $cheminRepertoire == './' && $repertoire == './') $cheminRepertoire = '.' ;
if($debugRep ==1) echo '<br/>$cheminRepertoire3 = '."$cheminRepertoire <br/>".'$repertoire'." = $repertoire";
};
}else{
// il y a une erreur dans l'arborescence : le chemin du dossier à explorer n'est pas valide ! ou c'est un dossier protégé !
$TempTexteErreur = $TexteErreurDossier ;
$from = $PatchPremierDossierAExplorer ; $fromEnLien = '' ;
// on stop : retour à la page par défaut, avec en plus un message d'erreur
break ;
};
};
// pour l'affichage à l'ecran : écrit dans une variable les liens vers les dosiers de navigations, séparé par $SeparateurNavigation
//-----------------------------------------//
// Download envoi
//---------------------------------------//
if($Autorise_Download && $download && $TempTexteErreur == '') {
// le répertoire est valide et les variables sont corectement formatée
// teste si le fichier existe
$PatchDownloadFile = ereg_replace('/$', '', $from).$SlashOuAntiSlash.$downloadFileName ;
if($DebugDownload == 1) echo '<br/>$PatchDownloadFile = '.$PatchDownloadFile ;
if(is_file($PatchDownloadFile)){
downloadFile($PatchDownloadFile, $downloadFileName) ;
}else{
$TempTexteErreur = $TexteErreurFichier ;
};
};
//-----------------------------------------------------------//
// Recupère la liste des fichiers placés dans le dossier //
//---------------------------------------------------------//
$Nfichiers = $NDossiers = 0 ;
//$remplacementurl = array("\'"=> "\\'" , '%'=> '%25' , ' '=> '%20' , '['=> '%5b' , ']'=> '%5d' , '`'=> '%60' , ';'=> '%3b' , '#'=> '%23');
$LongueurExplo = $LongueurPatchExplo = 0 ; //$LongueurMinCreeLien = strlen($NomDuFichier) + 2 + ($tri == $TriParDefaut) ? 0 : ;
$LongueurDossierTri = ($tri != $TriParDefaut) ? strlen("&t=$tri") : 0;
$dir = opendir($from);
while($file = readdir($dir)){
$erreur = 0 ;
($fromEnLien != '') ? $PatchEnLien = $fromEnLien.$SlashOuAntiSlash.$file : $PatchEnLien = $file ;
$Patch = $from.$SlashOuAntiSlash.$file ;
if( ! in_array($file, $protect)) {
if(is_dir($Patch)){
// si c'est un dossier :
$DossierOuFichier = 1 ;
// certains caractères font planter la pagewap (les accents en particulier), il faut les enlever du code wml : ATTENTION certain fichiers pourront être renommer !
$fileRenamed = RenamePourWml($file) ;
if($fileRenamed != $file) {$file = $fileRenamed ; $Patch = $from.$SlashOuAntiSlash.$file ;};
$lien = strtr($file, $remplacementlien);
$OrdreFichierOuDossier = ($tri != 'd') ? $file : @filemtime($Patch);
//$PatchFichierOuDossier = $PatchEnLien ;
$Lien1FichierOuDossier = $PrefixDossier.$BaliseAOuvre ;
$Lien2FichierOuDossier = '">'.$lien.$BaliseAFerme.$BaliseSautDeLigne ;
$LongueurExplo += strlen($Lien1FichierOuDossier.$NomDuFichier.urlencode($PatchEnLien).$Lien2FichierOuDossier) + 3 +$LongueurDossierTri ; // 3 car strlen(?=d) vaut 3;
$NDossiers++ ;
}elseif(is_file($Patch) && isAllowedExtension($Patch)){
// si c'est un fichier :
$DossierOuFichier = 2 ;
// certains caractères font planter la pagewap (les accents en particulier), il faut les enlever du code wml : ATTENTION certain fichiers pourront être renommer !
$fileRenamed = RenamePourWml($file) ;
if($fileRenamed != $file) {$file = $fileRenamed ; $Patch = $from.$SlashOuAntiSlash.$file ;};
$lien = strtr($file, $remplacementlien);
$TexteOptionFichier = '' ;
switch($tri){
case 't' ;
$TailleEnOctet = @filesize($Patch);
$TailleEnKiloOctet = $TailleEnOctet / 1024 ;
($TailleEnKiloOctet < 1) ? $NombreChiffreApreVirgule = 1 : $NombreChiffreApreVirgule = 0 ;
$TexteOptionFichier = ' ('.number_format($TailleEnKiloOctet,$NombreChiffreApreVirgule,',','').' ko)' ;
$OrdreFichierOuDossier = $TailleEnOctet.' '.$lien ; break;
case 'e' ;
if(ereg('.*\.([a-zA-Z0-9]+$)',$file,$regExtension)){
$extension = strtolower($regExtension[1]) ;
if(in_array($extension,$extensionsImages)){
$LesExtensions[]= 'img';
$imgsize= @getimagesize($Patch);
$TexteOptionFichier = ' ('.$imgsize[0]." x ". $imgsize[1].')';
$OrdreFichierOuDossier = $TexteOptionFichier.' '.$extension.' '.$lien ;
}else{ // ce n'est pas une image :
$LesExtensions[]= $extension ;
// ' (x ZZ)'. permet d'afficher les images en premier, par résolution, puis les autres extensions en ordre de naturel quand doublons.
$OrdreFichierOuDossier = ' (x ZZ)'.$extension.' '.$lien;
$TexteOptionFichier = '';
};
}else{ // cas rare où le fichier ne posede pas d'extension, : il sera placé à la fin
$LesExtensions[]= 'absent' ;
$TexteOptionFichier = '';
$OrdreFichierOuDossier = ' (x ZZ) ZZZ'.$lien;
}; break;
case 'd' :
$OrdreFichierOuDossier= @filemtime($Patch); break;
$TexteOptionFichier = '';
default :
$OrdreFichierOuDossier = $file ; break;
$TexteOptionFichier = '';
};
//$PatchFichierOuDossier = $PatchEnLien ;
$Lien1FichierOuDossier = $PrefixFichier.$BaliseAOuvre ;
$Lien2FichierOuDossier = '">'.$lien.$BaliseAFerme.$TexteOptionFichier.$BaliseSautDeLigne ;
$LongueurExplo += strlen($Lien1FichierOuDossier.$NomDuFichier.urlencode($PatchEnLien).$Lien2FichierOuDossier) + 3 ; // 3 = strlen(?=f);
$Nfichiers++ ;
}else{ $erreur = 1 ;}; // erreur ou interdit
if($erreur != 1) {
$TabOrdreFichierOuDossier[$DossierOuFichier][] = $OrdreFichierOuDossier ;
// avec les 3 tableaux ci-dessous : on pourra créer le lien
$TabPatchFichierOuDossier[$DossierOuFichier][] = $PatchEnLien ;
$TabLien1FichierOuDossier[$DossierOuFichier][] = $Lien1FichierOuDossier ;
$TabLien2FichierOuDossier[$DossierOuFichier][] = $Lien2FichierOuDossier ;
// pour taille estiméé :
$LongueurPatchExplo += strlen(urlencode($PatchEnLien)) ;
};
};
};
closedir($dir);
//echo $LongueurExplo ;
//print_r($TabPatchFichierOuDossier);
//--------------------------------------------------------------------------------------------//
// correction si tri par extension :
//-------------------------------------------------------------------------------------------//
if($tri == 'e' and $Nfichiers != 0) {
$LesExtensionUnique = array_unique($LesExtensions);
$LongueurExplo = $LongueurExplo + array_sum(array_map('strlen', $LesExtensionUnique)) + (sizeof($LesExtensionUnique)) * (strlen(' :'.$BaliseSautDeLigne)) ;
// si tri = extension : la longueur de explo sera sous-estimée au maximum de ((strlen($BaliseSautDeLigne)) * sizeof($LesExtensionUnique) ce qui n'est pas très grave, car on veut la taille Minimum.
};
//-----------------------------------------//
// compression //
//---------------------------------------//
$compression = false ;
do{
//OuvreIndex();
// initialise les tableaux si 2ième passage pour cause d'echec éventuel de la compression
unset($LiensRepertoiresTab, $LienClassementPossible, $tabPage, $tabLienNavigationPage );
//--------------------------------------------------------------------------------------------//
// correction si les fichier et dossiers sont compressés :
//-------------------------------------------------------------------------------------------//
if($compression_Activee && $compression)
$LongueurExplo = $LongueurExplo - $LongueurPatchExplo + LongueurChiffres(1, ($Nfichiers + $NDossiers)) ; // la longueur de explo sera sous-estimée au maximum de 111 octets s'il y a entre 100 et 1000 fichiers dans le dossier
//-----------------------------------------//
// Texte : classement //
//---------------------------------------//
if($TriDispo != array('')){
foreach($TriDispo as $variableURLtri){
if($variableURLtri == $tri){
$LienClassementActuel = '<strong>'.$TabTri[$variableURLtri].'</strong>' ;
}elseif($variableURLtri != ''){
$LienClassementPossible[] = $BaliseAOuvre.CreerLien($NomDuFichier, array('t' => $variableURLtri, 'd' => $fromEnLien), $compression)
.'" title="trier">'.$TabTri[$variableURLtri].$BaliseAFerme ;
};
};
$LienClassementPossible = (isset($LienClassementPossible)) ? ' ('.implode($SeparateurTri, $LienClassementPossible).')' : '' ;
$BrutLesClassements = Paragraphe($TexteClassement.$LienClassementActuel.$LienClassementPossible , 'droit') ;
}else{ $BrutLesClassements = '';};
//-----------------------------------------//
// Texte : arborescence (dossier actuel, Affichage //
//---------------------------------------//
if(isset($TabLiensRepertoiresNom)) {
foreach($TabLiensRepertoiresNom as $clef => $NomDossierParent){
$urlDeCeDossier = $TabLiensRepertoiresPatch[$clef] ;
$LiensRepertoiresTab[] = $BaliseAOuvre.CreerLien($NomDuFichier, array('t' => $tri, 'd' => $urlDeCeDossier), $compression).'" title="Aller a">'.TexteWml($NomDossierParent).$BaliseAFerme ;
//$LongueurArborescence += strlen($BaliseAOuvre) + CreerLien($NomDuFichier, array('t' => $tri, 'd' => $urlDeCeDossier), false) + strlen('" title="Aller a">'.$NomRepertoire.$BaliseAFerme) ;
};
// pour l'affichage à l'ecran : écrit dans une variable les liens vers les dosiers de navigations, séparé par $SeparateurNavigation
$LiensRepertoires = (isset($LiensRepertoiresTab)) ? implode($SeparateurNavigation, $LiensRepertoiresTab) : '' ;
$BrutDossierActuel = Paragraphe($LiensRepertoires) ;
//$LongueurArborescence = strlen($BrutDossierActuel) ;
}else{ $BrutDossierActuel = '';};
//-----------------------------------------//
// Prepare le code wml ou (c)html à générer //
//---------------------------------------//
$BrutHead = $BalisesHeadOuvre.$BalisesHeadFerme ;
$BrutTexteErreur = Paragraphe($TempTexteErreur) ;
$BrutTexteDebut = Paragraphe($TexteDebut, 'centre') ;
$BrutTexteFin = Paragraphe($TexteFin, 'centre') ;
if( ! $PositionRetour = strrpos($fromEnLien, '/')) $PositionRetour = 0 ;
$BrutRetour = ($fromEnLien != '' ) ?
Paragraphe($BaliseAOuvre.CreerLien($NomDuFichier, array('t' => $tri,
'd'=> substr($fromEnLien, 0,$PositionRetour)), $compression).'" title="Retour">'.$TexteRetour.$BaliseAFerme, 'centre')
: '';
$BrutDebut1 = $XMLversion.$DocType.$BrutHead.$BrutTexteDebut ;
$BrutDebut2 = $BrutTexteErreur.$BrutLesClassements.$BrutDossierActuel ;
$BrutFin = $BrutRetour.$BrutTexteFin.$BalisesFin ;
//-------------------------------------//
// Si aucun Fichier à afficher : //
//-----------------------------------//
if( ! isset($TabOrdreFichierOuDossier)) {
// aucun fichier ou dossier à afficher : le répertoire est vide : fin de la page.
$BrutAbsenceFichier = Paragraphe($TexteAbsenceFichier) ;
EnvoiHeader($header);
die($BrutDebut1.$BrutDebut2.$BrutAbsenceFichier.$BrutFin);
};
//--------------------------------------------------------------------------------------------//
// Calcul de la taille occupée par tous les éléments de taille fixe //
//-------------------------------------------------------------------------------------------//
// les octets ne sont pas exactement égaux au nombre de caractères : si on définit 3.0 ko de page max, la page généree pourra faire 2 929,6875 octets maximum
// donc : (3,000 ko équivaut à 2,929 dixPuissance3 nombre de caractères)
//$TailleMaxPageEnOctet = $taillemax*1000*(1000/1024) ;
$TailleDebutEtFin = strlen($BrutDebut1.$BrutDebut2.$BrutFin) ;
$LongueurBalisesP = strlen($BalisePOuvre.'>'.$BalisePFerme) ;
//--------------------------------------------------------------------------------------------//
// Calcul de la taille Minimale occupée par tous les éléments de taille variable //
//-------------------------------------------------------------------------------------------//
// ce sont :
// - Page x(x) / x(x)
//- lien : page suivante/precedente x(x), sachant qu'il y a (n-1) couple page suivante/precedente pour n pages par dossier.
//echo $BrutDebut1;
$NumeroPageVariable = $NumeroPagePageFin = 1 ;
$LienPageSuivante = $BaliseAOuvre.CreerLien($NomDuFichier, array('p' => ($NumeroPageVariable), 'd' => $fromEnLien, 't' => $tri), $compression).'" title="Page">'.TexteWml($TexteLienPageSuivante).$BaliseAFerme ;
$LienPagePrecedente = $BaliseAOuvre.CreerLien($NomDuFichier, array('p' => ($NumeroPageVariable), 'd' => $fromEnLien, 't' => $tri), $compression).'" title="Page">'.TexteWml($TexteLienPagePrecedente).$BaliseAFerme ;
$TailleNavigationPage = strlen($LienPagePrecedente.$separateurPageSuivante.$LienPageSuivante.$BaliseSautDeLigne) ; // $BalisePOuvre.$PalignCenter. .$BalisePFerme
$LienDernierePage = $BaliseAOuvre.CreerLien($NomDuFichier, array('p' => $NumeroPagePageFin, 'd' => $fromEnLien, 't' => $tri), $compression).'" title="Aller a">'.$NumeroPagePageFin.$BaliseAFerme ;
$TailleNumeroPage = strlen('Page : '.$NumeroPageVariable.$separateurPageActuelle.$LienDernierePage.$BaliseSautDeLigne) ;
$TailleNumeroPageDerniere = strlen('Page : '.$NumeroPagePageFin.$separateurPageActuelle.$NumeroPagePageFin.$BaliseSautDeLigne) ;
$LongueurNavigationSansChiffre = $TailleNavigationPage - (1 * 2) ; // + LongueurChiffres($PremierChiffre, $DernierChiffre) ;
$LongueurNumeroSansChiffre = $TailleNumeroPage - (1 *3) ; // + LongueurChiffres($PremierChiffre, $DernierChiffre) ;
$LongueurNumeroSansChiffreDerniere = $TailleNumeroPageDerniere - (1 * 2) ; // + LongueurChiffres($PremierChiffre, $DernierChiffre) ;
//--------------------------------------------------------------------------------------------//
// longueur totale minimum du dossier :
//-------------------------------------------------------------------------------------------//
$tailleFixeParPage0 = $TailleDebutEtFin + $LongueurBalisesP + 2 * ($TailleNumeroPageDerniere) ;
if(($TailleMaxPageEnOctet - $tailleFixeParPage0) > $LongueurExplo) { // cad s'il y a plus d'espace à occuper que ce qu'on a à remplir
$TailleDesPages = $tailleFixeParPage0 + $LongueurExplo ;
}else{
$tailleFixeParPageSansChiffre = $TailleDebutEtFin + $LongueurBalisesP + 2 * ($LongueurNavigationSansChiffre + $LongueurNumeroSansChiffre) ;
$NombreDePageMax = 10 ;
$PremierChiffre = 1 ;
$LongueurExploTemp = $LongueurExplo ;
$TailleDesPages = $TaillePresentationEstimee = 0 ;
for($NumeroPageVariable = 1 ; $NumeroPageVariable <= $NombreDePageMax ; $NumeroPageVariable++){
if(strlen($NumeroPageVariable) >= strlen($NombreDePageMax)) {
$NombreDePageMax = intval($NombreDePageMax.'0') ;
$NumeroPageVariable = 1 ;
$LongueurExploTemp = $LongueurExplo ;
$TailleDesPages = 0 ;
};
$PageMax = $NombreDePageMax - 1 ;
$TailleFixeDernierPage = $TailleDebutEtFin + $LongueurBalisesP + 2 * ($LongueurNumeroSansChiffreDerniere + 2 * (strlen($PageMax)) + strlen($PageMax) - strlen($PremierChiffre) + strlen($separateurPageSuivante.$BaliseSautDeLigne)) ;
if($LongueurExploTemp + $TailleFixeDernierPage >= $TailleMaxPageEnOctet ) {
$TailleChiffres = 2 * ((strlen($NumeroPageVariable)) * 2 + strlen($NumeroPageVariable) + 2 * (strlen($PageMax))) ;
$TailleExploPage = ($TailleMaxPageEnOctet - ($tailleFixeParPageSansChiffre + $TailleChiffres)) ;
$LongueurExploTemp -= $TailleExploPage ;
$TailleDesPages += $TailleMaxPageEnOctet ;
$TaillePresentationEstimee += $tailleFixeParPageSansChiffre + $TailleChiffres ; // pour Debug
}else{
$TailleDesPages += $LongueurExploTemp + $TailleFixeDernierPage ;
$TaillePresentationEstimee += $TailleFixeDernierPage ; // pour Debug
break ;
};
};
};
$NombrePagesEstime = $TailleDesPages / $TailleMaxPageEnOctet ;
if($DebugPageEstimee == 1) {
$TexteAfficheCompression = ($compression) ? "activee (car plus de $CompressionAPartirDe pages en mode non compressees)" : "desactivee (s'active si plus de $CompressionAPartirDe pages)" ;
echo $BalisePOuvre.'>'.$BaliseSautDeLigne."Compression : actuellement <strong>$TexteAfficheCompression</strong>".$BaliseSautDeLigne."<strong>NombrePagesEstime = ".number_format($NombrePagesEstime,2,',',' ')." pages</strong>".$BaliseSautDeLigne."Taille totale du dossier (theorique) = ".number_format(($TailleMaxPageEnOctet *$NombrePagesEstime * $FacteurConvertionEnKo ),3,',',' ')." ko".$BaliseSautDeLigne." composee de : longueurExplo = ".number_format(($LongueurExplo * $FacteurConvertionEnKo ),3,',',' ').".ko".$BaliseSautDeLigne." + longueur presentation = ".number_format(($TaillePresentationEstimee * $FacteurConvertionEnKo ),3,',',' ')." ko".$BalisePFerme ;
};
if(($NombrePagesEstime > $CompressionAPartirDe) && (! $compression) && $compression_Activee)
{$compression = true ; $succesCompression = false; continue;};
//-------------------------------//
// Tri les fichiers //
//----------------------------//
$NombreDeFichierPlusDossiers = 0 ;
ksort($TabOrdreFichierOuDossier); // on place les dossiers puis les fichiers
foreach($TabOrdreFichierOuDossier as $DossierOuFichier => $value){
switch($tri){
case 'd' : arsort($TabOrdreFichierOuDossier[$DossierOuFichier]); break;
default : natcasesort($TabOrdreFichierOuDossier[$DossierOuFichier]);
// tant qu'on y est :
$NombreDeFichierPlusDossiers += sizeof($TabOrdreFichierOuDossier[$DossierOuFichier]) ;
};
};
//echo "$Nfichiers fichiers / $NDossiers dossiers ;";
//$NombreDeFichierPlusDossiers = $Nfichiers + $NDossiers ;
//echo '<br />$NombreDeFichierPlusDossiers = '."$NombreDeFichierPlusDossiers <---> $NombreDeFichierPlusDossiers2" ;
//----------------------------------------------------//
// Scinde la liste de fichiers en plusieurs pages //
//--------------------------------------------------//
//echo '<pre>Ordre des '; ($DossierPuisFichier == 1) ? 'dossiers' : 'fichiers' ; echo "\n";print_r($TabOrdreFichierOuDossier); echo '</pre>';
$NumeroDernierePage = ($NombrePagesEstime < 10 ) ? 1 : 10 ;
do{
$NumeroPage = 1 ;
$compteurFichiersPlusDossiers = $NombreDeLiensParPage = 0 ;
$NumeroDernierePageTemp = str_repeat('x',strlen($NumeroDernierePage));
$extensionPrecedente = '' ;
unset($tabPage, $tabLienNavigationPage);
if(!isset($tabPage[$NumeroPage])) $tabPage[$NumeroPage] = '';
foreach($TabOrdreFichierOuDossier as $DossierPuisFichier => $Ordre){
if($debugOrdre == 1) {echo '<pre>Ordre des '; echo ($DossierPuisFichier == 1) ? 'dossiers' : 'fichiers' ; echo "\n";print_r($Ordre); echo '</pre>';};
if( $DossierPuisFichier ==1) {
$DouF = 'd' ; $ArrayTri = ($tri != $TriParDefaut) ? array( 't' => $tri) : null;
}else{
$DouF = 'f' ; $ArrayTri = null ;
};
reset($Ordre) ;
foreach($Ordre as $key => $valeurTri) {
$compteurFichiersPlusDossiers++;
$LienPageSuivante = $BaliseAOuvre.CreerLien($NomDuFichier, array('p' => ($NumeroPage + 1), 'd' => $fromEnLien, 't' => $tri)).'" title="Page">'.TexteWml($TexteLienPageSuivante).$BaliseAFerme ;
$LienPagePrecedente = $BaliseAOuvre.CreerLien($NomDuFichier, array('p' => ($NumeroPage - 1), 'd' => $fromEnLien, 't' => $tri)).'" title="Page">'.TexteWml($TexteLienPagePrecedente).$BaliseAFerme ;
// est-ce que cette boucle correspond au dernier fichier ou dossier : (oui dans le "else")
if($compteurFichiersPlusDossiers < $NombreDeFichierPlusDossiers ){
$LienDernierePage = $BaliseAOuvre.CreerLien($NomDuFichier, array('p' => $NumeroDernierePageTemp, 'd' => $fromEnLien, 't' => $tri)).'" title="Aller a">'.$NumeroDernierePageTemp.$BaliseAFerme ;
}else{
// il n'y a plus aucun fichier ou dossiers à afficher
$LienDernierePage = $NumeroDernierePage ; // la dernière page ne sera pas un lien
$LienPageSuivante = '';
};
// si c'est la première page : il n'y a alors pas de page precedente :
if($NumeroPage == 1) $LienPagePrecedente ='';
$LienNavigationPage = $LienPagePrecedente.$separateurPageSuivante.$LienPageSuivante.$BaliseSautDeLigne ; // $BalisePOuvre.$PalignCenter. .$BalisePFerme
$BrutNumeroPage = 'Page : '.$NumeroPage.$separateurPageActuelle.$LienDernierePage.$BaliseSautDeLigne ;
// si c'est la fin de l'exploration et qu'il n'y a qu'une page :
if($compteurFichiersPlusDossiers == $NombreDeFichierPlusDossiers and $NumeroPage ==1) $LienNavigationPage = '';
// affiche une ligne contenant le nom de la nouvelle extension
if($DossierPuisFichier == 2 && $tri=='e') {
$extension = $LesExtensions[$key];
$NouvelleExtension = ($extension != $extensionPrecedente) ? // si pas de dossier et premier fichier de la page, on retire le saut de ligne initiale.
(($DossierPuisFichier == 2 && $compteurFichiersPlusDossiers == 1) ? $extension.' :'.$BaliseSautDeLigne : $BaliseSautDeLigne.$extension.' :'.$BaliseSautDeLigne)
: '';
$extensionPrecedente = $extension ;
}else{ $NouvelleExtension = '';};
$NombreDeLiensParPage++;
$LienFichierOuDossier = $TabLien1FichierOuDossier[$DossierPuisFichier][$key]
.CreerLien($NomDuFichier, array_merge(array($DouF => $TabPatchFichierOuDossier[$DossierPuisFichier][$key]), $ArrayTri), $compression)
.$TabLien2FichierOuDossier[$DossierPuisFichier][$key] ;
$LongueurPageSansExplo = $TailleDebutEtFin + $LongueurBalisesP + 2*(strlen($BrutNumeroPage) + strlen($LienNavigationPage) ) ;
$LongueurExplo = strlen($tabPage[$NumeroPage].$NouvelleExtension.$LienFichierOuDossier) ;
// Si la taille de la page dépasse la taille max autorisée, ou que le nombre de liens dépasse la limite imposée dans la config : on crée une "page suivante".
if( ($LongueurPageSansExplo + $LongueurExplo > $TailleMaxPageEnOctet) || ($NombreMaxDeLiensParPage != 0 && $NombreDeLiensParPage > $NombreMaxDeLiensParPage)) {
$NumeroPage++ ;
$NombreDeLiensParPage = 1 ;
// on en enleve le saut de ligne initiale si on débute une nouvelle page par une nouvelle extension :
$NouvelleExtension = ereg_replace("^$BaliseSautDeLigne", '', $NouvelleExtension);
// ligne pour accelerer le processus : à partir de 10 pages (ou de 100 ou 1000 pages) il faut refaire (tout de suite) les calculs à partir du début
if($NumeroPage > $NumeroDernierePage and strlen($NumeroPage) != strlen($NumeroDernierePageTemp))break 2;
};
// rempli le tableau $tabPage qui contient la chaine des dossiers et fichiers à explorer, avec la page en clef :
if(!isset($tabPage[$NumeroPage])) $tabPage[$NumeroPage] = '';
$tabPage[$NumeroPage] .= $NouvelleExtension.$LienFichierOuDossier ;
$tabLienNavigationPage[$NumeroPage] = $LienNavigationPage ;
if($AuditTailleAffichage == 'oui') $tabLienNumeroDePageAudit[$NumeroPage] = $BrutNumeroPage ;
};
// puis place les fichiers
};
// enregistre le numéro de la dernière page
$NumeroDernierePage = $NumeroPage ;
// s'il la dernière page faisait 2 caractères (exemple : page 10) et que tout a été calculé avec une valeur de dernière page de 1 caractère : on recommence tout !
} while (strlen($NumeroDernierePage) > strlen($NumeroDernierePageTemp)) ;
//------------------------------------------------------//
// Texte : "page n°x",page precedente et suivante //
//----------------------------------------------------//
// on remplace les xx par les vrais chiffres et on construit la page à afficher
$NumeroDernierePage = $NumeroPage ; $NumeroPremierePage = 1 ;
// s'assure que la page demandée par l'internaute est valide
$pageAffiche = ($page <= $NumeroDernierePage and $page > 0) ? $page : $PageParDefaut ;
// prépare les éléments autour des fichiers à explorer :
$LienNavigationPage = $tabLienNavigationPage[$pageAffiche] ;
$LienDernierePage = ($pageAffiche == $NumeroDernierePage) ? $NumeroDernierePage :
$BaliseAOuvre.CreerLien($NomDuFichier, array('p' => $NumeroDernierePage, 'd' => $fromEnLien, 't' => $tri)).'" title="Aller a">'.$NumeroDernierePage.$BaliseAFerme ;
$BrutNumeroPage = 'Page : '.$pageAffiche.$separateurPageActuelle.$LienDernierePage.$BaliseSautDeLigne ;
$BrutCorps = $BalisePOuvre.'>'.$BrutNumeroPage.$LienNavigationPage.$tabPage[$pageAffiche].$BrutNumeroPage.$LienNavigationPage.$BalisePFerme ;
//-------------------------------------//
// compression : //
//-----------------------------------//
$succesCompression = FermeIndex();
if( ! $succesCompression) $compression_Activee = false ;
}while( ! $succesCompression);
//-------------------------------------------//
// Affiche la taille occupée par chaque zone, pour savoir si la présentation est trop longue //
//-----------------------------------------//
if($AuditTailleAffichage == 'oui'){
$GenereeEn = $BalisePOuvre.">Temps d'execution du script : <strong>".number_format((getmicrotime() - $time),4,',',' '). "s.</strong>".$BalisePFerme ;
// Audit du dossier.
$TailleFinaleExploDossierPageEnKo = $TailleRestantTotaleEnKo = $TailleFinaleDossierPageEnKo = $TotalNombreDeLiens = $TotalNombreDeLiens = $TailleFinalePresentationEnKoPageEnKo= 0 ;
$pageAfficheAudit = $pageAffiche ;
$NombreDePagesDossier = $NumeroDernierePage ;
$TexteAfficheCompression = ($compression_Activee) ? "activee (a partir de $CompressionAPartirDe pages non compressees)" : 'desactivee' ;
$TexteAfficheMaxLienAutorise = ($NombreMaxDeLiensParPage != 0) ? $NombreMaxDeLiensParPage : 'illimite' ;
$DossierAudit = ($fromEnLien != '') ? $fromEnLien : $NomDuPremierRepertoire ;
$TexteDebugAffichage1 = $BalisePOuvre.$PalignCenter."<strong>Audit de la page generee, pour le dossier <i>$DossierAudit</i></strong>$BalisePFerme.$BaliseSautDeLigne".
$BalisePOuvre.">Configuration actuelle :$BalisePFerme"."<ul><li><strong>$taillemax ko maximum</strong> par page.</li><li>Compression <strong>$TexteAfficheCompression</strong></li><li>Nombre de Liens maximum autorise par page : <strong>$TexteAfficheMaxLienAutorise</strong></li></ul>$GenereeEn";
$TexteDebugAffichage2 = $BaliseSautDeLigne.$BalisePOuvre.">Page $pageAfficheAudit / $NumeroDernierePage, actuellement affichee.$BalisePFerme";
foreach($tabPage as $pageAffiche => $exploAudit){
$TailleFinaleNumeroPageEnKo = $FacteurConvertionEnKo * (strlen($tabLienNumeroDePageAudit[$pageAffiche])) ;
$TailleFinalePageSuivanteEnKo = $FacteurConvertionEnKo * (strlen($tabLienNavigationPage[$pageAffiche])) ;
$TailleFinaleExploEnKo = $FacteurConvertionEnKo * (strlen($tabPage[$pageAffiche])) ;
$TailleFinalePageEnKo = $FacteurConvertionEnKo * (strlen($BrutDebut1.$BrutDebut2.$BalisePOuvre.'>'.$BalisePFerme.$BrutFin)) + $TailleFinaleExploEnKo + 2 *($TailleFinaleNumeroPageEnKo + $TailleFinalePageSuivanteEnKo) ;
$TailleFinalePresentationEnKo = $TailleFinalePageEnKo - $TailleFinaleExploEnKo ;
$TailleRestantEnKo = $taillemax - $TailleFinalePageEnKo ;
$NombreDeLiens = substr_count($tabPage[$pageAffiche], $BaliseAOuvre);
if($pageAffiche == $pageAfficheAudit ) $TexteDebugAffichage2 .=
'<table border="1"><tr><td>'."$pageAffiche / $NumeroDernierePage".'</td><td>Presentation</td><td>Exploration</td><td>Restant</td><td>Total</td></tr>'
.'<tr><td>ko</td><td>'.number_format($TailleFinalePresentationEnKo,2,',',' ').' ko</td><td>'.number_format($TailleFinaleExploEnKo,2,',',' ').' ko</td><td>'.number_format(($TailleRestantEnKo/$FacteurConvertionEnKo),0,',',' ').' octets</td><td><strong>'.number_format($TailleFinalePageEnKo,3,',',' ').' ko</strong></td></tr>'
.'<tr><td>%</td><td>'.number_format(($TailleFinalePresentationEnKo/$taillemax*100),1,',',' ').' %</td><td>'.number_format(($TailleFinaleExploEnKo/$taillemax*100),1,',',' ').' %</td><td>'.number_format(($TailleRestantEnKo/$taillemax*100),1,',',' ').' %</td><td>'.number_format(($TailleFinalePageEnKo/$taillemax*100),3,',',' ').' %</td></tr>'
.'<tr><td>+</td><td></td><td><strong>'.number_format($NombreDeLiens,0,',',' ').' liens</strong></td><td></td><td>sur <strong>'.$taillemax.' ko</strong> max</td></tr>'
.'</table>';
if($pageAffiche != $NumeroDernierePage) $TailleRestantTotaleEnKo += $TailleRestantEnKo ;
$TailleFinaleDossierPageEnKo += $TailleFinalePageEnKo ;
$TailleFinaleExploDossierPageEnKo += $TailleFinaleExploEnKo ;
$TailleFinalePresentationEnKoPageEnKo += $TailleFinalePresentationEnKo ;
$TotalNombreDeLiens += $NombreDeLiens ;
if($NombreDePagesDossier == 1 || $pageAffiche != $NumeroDernierePage) {
$TailleFinalePageDossier[$pageAffiche] = $TailleFinalePageEnKo ;
$TailleFinaleExploDossier[$pageAffiche] = $TailleFinaleExploEnKo ;
$TailleFinalePresentationDossier[$pageAffiche] = $TailleFinalePresentationEnKo ;
$TailleRestantDossier[$pageAffiche] = $TailleRestantEnKo ;
$NombreDeLienDossier[$pageAffiche] = $NombreDeLiens ;
};
};
$TotalReel = $TailleFinaleDossierPageEnKo + $TailleRestantTotaleEnKo ;
if($NumeroDernierePage != 1 ) {
$TexteAuditDossier = '<table border="1"><tr><td>'."$DossierAudit".'</td><td>Total theorique</td><td>total reel</td><td><strong>perdu</strong></td><td>Presentation</td><td>Exploration</td></tr>'
.'<tr><td>ko</td><td>'.number_format($TailleFinaleDossierPageEnKo,3,',',' ').' ko</td><td>'.number_format($TotalReel ,3,',',' ').' ko</td><td><strong>'.number_format(($TailleRestantTotaleEnKo / $FacteurConvertionEnKo), 0,',',' ').' octets</strong></td><td>'.number_format($TailleFinalePresentationEnKoPageEnKo,3,',',' ').' ko</td><td>'.number_format($TailleFinaleExploDossierPageEnKo,3,',',' ').' ko</td></tr>'
.'<tr><td>%</td><td>'.number_format(($TailleFinaleDossierPageEnKo/$TotalReel*100),1,',',' ').' %</td><td>'.number_format(($TotalReel/$TotalReel *100),0,',',' ').' %</td><td>'.number_format(($TailleRestantTotaleEnKo/$TotalReel*100),2,',',' ').' %</td><td>'.number_format(($TailleFinalePresentationEnKoPageEnKo/$TotalReel*100),3,',',' ').' %</td><td>'.number_format(($TailleFinaleExploDossierPageEnKo/$TotalReel*100),3,',',' ').' %</td></tr>'
.'<tr><td>+</td><td></td><td><strong>'.number_format($TotalNombreDeLiens,0,',',' ').' liens</strong></td><td></td><td>soit : '.number_format((($TotalNombreDeLiens - $NombreDeLiens) / ($NumeroDernierePage - 1)),1,',',' ').' liens par page complete</td><td><strong>sur '.$NumeroDernierePage.' pages</strong></td></tr>'
.'</table>';
}else $TexteAuditDossier = '';
if($NombreDePagesDossier > 1) {
for($i=1; $i <= 4 ; $i++){
switch($i) {
case 1 : $SyntheseValeur = max($TailleFinalePageDossier) ; $SyntheseDans = $TailleFinalePageDossier ; $Synthese = array('taille max', 'la plus <i>grande</i> ') ; break ;
case 2 : $SyntheseValeur = min($TailleFinalePageDossier) ; $SyntheseDans = $TailleFinalePageDossier ; $Synthese = array('taille min', 'la plus <i>petite</i> ') ; break ;
case 3 : $SyntheseValeur = max($NombreDeLienDossier) ; $SyntheseDans = $NombreDeLienDossier ; $Synthese = array('max liens', 'avec le <i>plus</i> de liens ') ; break ;
case 4 : $SyntheseValeur = min($NombreDeLienDossier) ; $SyntheseDans = $NombreDeLienDossier; $Synthese = array('min liens', 'avec le <i>moins</i> de liens ') ; break ;
};
$PageSynthese = array_search($SyntheseValeur, $SyntheseDans , true) ;
$StrongLien1 = $strongTaille1 = '<strong>'; $StrongLien2 = $strongTaille2 = '</strong>' ;
($SyntheseDans == $TailleFinalePageDossier) ? ($StrongLien1 = $StrongLien2 = '') : ($strongTaille1 = $strongTaille2 = '') ;
$TailleFinalePageEnKo = $TailleFinalePageDossier[$PageSynthese] ;
$TailleFinaleExploEnKo = $TailleFinaleExploDossier[$PageSynthese] ;
$TailleFinalePresentationEnKo = $TailleFinalePresentationDossier[$PageSynthese] ;
$TailleRestantEnKo = $TailleRestantDossier[$PageSynthese] ;
$NombreDeLiens = $NombreDeLienDossier[$PageSynthese] ;
$TexteDebugSynthese = $BaliseSautDeLigne.$BalisePOuvre.">Page ".$Synthese[1].": $PageSynthese / $NumeroDernierePage.$BalisePFerme"
.'<table border="1"><tr><td>'.$Synthese[0].'</td><td>Presentation</td><td>Exploration</td><td>'.$strongTaille1.'Restant'.$strongTaille2.'</td><td>'.$strongTaille1.'Total'.$strongTaille2.'</td></tr>'
.'<tr><td>ko</td><td>'.number_format($TailleFinalePresentationEnKo,2,',',' ').' ko</td><td>'.number_format($TailleFinaleExploEnKo,2,',',' ').' ko</td><td>'.$strongTaille1.number_format(($TailleRestantEnKo/$FacteurConvertionEnKo),0,',',' ').' octets'.$strongTaille2.'</td><td>'.number_format($TailleFinalePageEnKo,3,',',' ').' ko'.$strongTaille2.'</td></tr>'
.'<tr><td>%</td><td>'.number_format(($TailleFinalePresentationEnKo/$taillemax*100),1,',',' ').' %</td><td>'.number_format(($TailleFinaleExploEnKo/$taillemax*100),1,',',' ').' %</td><td>'.number_format(($TailleRestantEnKo/$taillemax*100),1,',',' ').' %</td><td>'.$strongTaille1.number_format(($TailleFinalePageEnKo/$taillemax*100),3,',',' ').' %'.$strongTaille2.'</td></tr>'
.'<tr><td>+</td><td></td><td>'.$StrongLien1.number_format($NombreDeLiens,0,',',' ').' liens'.$StrongLien2.'</td><td></td><td>sur '.$strongTaille1.$taillemax.' ko max'.$strongTaille2.'</td></tr>'
.'</table>';
};
$TexteDebugAffichageNote = "Note : La derniere page est volontairement non testee pour le calcul du <i>nombre de liens par page</i> et de la <i>taille maximum et minimum de la page</i> (car cette page est incomplete).";
}else $TexteDebugAffichageNote = "Note : l'Audit est surtout significatif lorsqu'il y a plus de 20 ou 30 dossiers ou fichiers dans le repertoire." ;
$TexteDebugAffichageFin = $BalisePOuvre.$PalignCenter."<strong>Fin</strong> de l'Audit.$BaliseSautDeLigne".$TexteDebugAffichageNote.$BalisePFerme ;
$TexteDebugAffichage = TexteWml($TexteDebugAffichage1.$TexteAuditDossier.$TexteDebugSynthese.$TexteDebugAffichage2.$TexteDebugAffichageFin) ;
}else{
$TexteDebugAffichage = '';
};
//-------------------------------------------//
// Affiche la page wap ou imode complète //
//-----------------------------------------//
EnvoiHeader($header) ;
print($BrutDebut1.$TexteDebugAffichage.$BrutDebut2.$BrutCorps.$BrutFin);
// fin
//-------------------------------------------//
// Definition des fonctions de ce script //
//-----------------------------------------//
function CreerLien($PatchFichier, $TabVariablesURL, $compression = true) {
/*------ a quoi sert cette fonction ;------*/
// on fournit :
//- $PatchFichier qui peut être un fichier ('fichier.txt') ou un chemin ('monRep/fichier.txt')
//- et un tableau des variables à passer dans l'url; ex; $TabVariablesURL = array('page'=> 4, 'jour' => 'hier')
//- la fonction retourne l'url complète : 'monRep/fichier.txt?page=4&jour=hier'
// intéret : génère toujours une url valide la plus courte posible et avec toujours '&' et non '&'.
/*------ configuration------*/
// - pour $PasDeFichierIndexPointHtm --> mettre oui si le dossier où se trouve le fichier de navigation ne possède pas de fichier
// nommé 'index.htm' ni 'index.html', qui ont la priorit" sur 'index.php' (ou si vous édité le fichier .htaccess dans ce sens).
// intérêt : réduit encore un peu la longueur de la chaine générée. Si vous n'avez rien compris : laissez 'non' !
$PasDeFichierIndexPointHtm = 'non' ;
//- $VariablesURLParDefaut est fournie hors de la fonction et avant sont execution, c'est un tableau contenant en
// clef le nom et des variables à passer dans l'url et en valeur leur valeur respective qui est chargée par défaut
// ex : $VariablesURLParDefaut = array('page' => 1, 'jour' => 'cejour');
// si vous n'avez pas compris, vous pouvez omettre cette variable
global $VariablesURLParDefaut ;
// initialisation
if( ! isset($VariablesURLParDefaut) || $VariablesURLParDefaut == '') $VariablesURLParDefaut = array('') ;
$LesVariablesURL = '';
// s'il n'y a pas de variables dans l'url on a finit !
if( isset($TabVariablesURL) && $TabVariablesURL != null) {
// ecrit correctement les variables dans l'url
$CompteurVariablesURL = 0;
foreach($TabVariablesURL as $NomVariableURL => $ValeurVariableURL){
($CompteurVariablesURL == 0) ? $separateur = '?' : $separateur = '&' ; // ne pas mettre '&' (cf. manuel php fct urlencode()
// si la valeur de cette variable url est la valeur par défaut, ou si la valeur de la variable vaut null --> on l'omet
if( $ValeurVariableURL != ''
&& ! (array_key_exists($NomVariableURL, $VariablesURLParDefaut) &&
$ValeurVariableURL == $VariablesURLParDefaut[$NomVariableURL]))
{
// autorise la compression pour le fichiers ou dossiers :
if( $compression && in_array($NomVariableURL, array('f','d'))) $ValeurVariableURL = CompresseNom($ValeurVariableURL) ;
// on protège le tout par urlencode
$LesVariablesURL .= $separateur.$NomVariableURL.'='.MyAddSlashes_gpc(urlencode($ValeurVariableURL)) ;
$CompteurVariablesURL++;
};
};
}else return ($PatchFichier) ;
// fin : retourne l'url complete
$LienComplet = $PatchFichier.$LesVariablesURL ;
return ($PasDeFichierIndexPointHtm == 'oui' && $LienComplet=='index.php') ?
'./' :
($LienComplet) ;
};
function isAllowedExtension($file) {
/*------ a quoi sert la fonction isAllowedExtension($file);------*/
// retourne true si l'extension est autorisée ou false si elle ne l'est pas
// attention : isAllowedExtension() controle seulement l'extension du nom du fichier, et pas si le fichier existe.
/*------ configuration------*/
// $file peut être un fichier ('fichier.txt') ou un chemin ('monRep/fichier.txt')
//on fourni $ExtensionsAutorisees, $ExtensionsInterdites sous la forme 'htm|css|js' en dehors et avant l'execution de la fonction
global $ExtensionsAutorisees, $ExtensionsInterdites ;
// si aucune restriction, tous les fichiers sont téléchargeables !
if( $ExtensionsAutorisees == '' && $ExtensionsInterdites == '') return true ;
// trouve l'extension du fichier à analyser
$extensionFile = (ereg('.+\.(:alnum:+)$', $file, $regExtension)) ? $regExtension[1] : '';
// simple controle qui doit-être fait avant cette fonction, mais qui évitera des faux-positifs ou faux-négatifs plus loins
if( trim($file) == '' || $extensionFile == '') return false ;
// sinon, on test d'abord les extensions autorisées s'il elles sont définies :
if($ExtensionsAutorisees != ''){
$TabExtensionsAutorisees = explode('|', $ExtensionsAutorisees);
return (in_array($extensionFile, $TabExtensionsAutorisees)) ? true : false ;
}else{ // sinon c'est que les extensions interdites sont définies : ont les tests
$TabExtensionsInterdites = explode('|', $ExtensionsInterdites);
return (in_array($extensionFile, $TabExtensionsInterdites)) ? false : true ;
};
};
/* méthode 1 : marche mais ralenti php, abandonné au profit de la méthode 2, plus simple
// la commande ci-dessous crée un masque pour regex :
// si $ExtensionsInterdites == 'htm|php|css'
// alors $listeExtensionsAutoriseesPourEreg == '.+\.htm$|.+\.php$|.+\.css$
$listeExtensionsAutoriseesPourEreg = '.+\.'.str_replace('|', '$|.+\.', $ExtensionsInterdites).'$' ;
(ereg($listeExtensionsAutoriseesPourEreg,$file)) ?
return true :
return false ;
//*******************************************************************************
//<Constructeur page>
//*******************************************************************************
function LongueurChiffres($PremierChiffre, $DernierChiffre){
$Longueur = 0 ;
for($PremierChiffre ; $PremierChiffre <= $DernierChiffre ; $PremierChiffre++) $Longueur += strlen($PremierChiffre) ;
return ($Longueur) ;
};
function Paragraphe($TexteParagraphe, $cote = ''){
global $BalisePOuvre, $BalisePFerme, $PalignCenter, $PalignRight ;
switch($cote){
case 'centre' : $align = $PalignCenter ; break;
case 'droit' : $align = $PalignRight ; break;
default : $align = '>';
};
return ( $TexteParagraphe != '') ? $BalisePOuvre.$align.SansAccuent($TexteParagraphe).$BalisePFerme : '' ;
};
function EnvoiHeader($header, $NoCache = true){
my_obstart(); // compresse gzippe la page
header($header); // doit être le premier élément envoyé, avant tout texte.
if($NoCache ){
// empeche le cache de la page, elle sera réevaluée.
header("Expires: Mon, 26 Jul 1997 05:00:00 GMT"); // disable ALL caching
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
header("Cache-Control: no-cache, must-revalidate"); // HTTP/1.1
header("Pragma: no-cache"); // HTTP/1.0
};
};
function downloadFile($PatchFile, $file) {
/*------ a quoi sert la fonction downloadFile($file);------*/
// envoi au client un fichier par php, avec le bon type mime, nom, taille
// attention : downloadFile() ne controle pas si le fichier existe.
/*------ configuration------*/
// $file doit-être un chemin valide !! ('monRep/fichier.txt' pour télécharger le fichier "fichier.txt')
global $MethodDownload ;
$AdresseAbsolueFile= 'http://'.$_SERVER['HTTP_HOST'].dirname($_SERVER['PHP_SELF']).'/'.ereg_replace('^\./','',$PatchFile) ;
switch($MethodDownload) {
case 1 :
$TypeMimeRef = array(
// sonneries
'mid' => array( 'audio/mid','audio/midi','audio/sp-midi','audio/x-mid','audio/x-midi','application/x-midi','audio/x-xmrcc-midi','audio/x-xmrcc-sp-midi'), //,'audio/*'),
'mmf' => array( 'application/vnd.smaf', 'audio/mmf','application/x-smaf','audio/x-mmf','audio/smaf'), //'audio/*'),
'wav' => array( 'audio/wav', 'audio/x-wav'), //,'audio/*'),
'mp3' => array( 'audio/mp3', 'audio/x-mp3'), //'audio/*'),
'amr' => array( 'audio/amr', 'audio/amr-wb','audio/x-amr'), //'audio/*'),
'pmd' => array( 'application/x-pmd'), //'audio/*'),
'mld' => array( ''), //'audio/*'),
'imy' => array( 'audio/x-imy', 'application/x-imy'), //'audio/*'),
'emy' => array( 'audio/x-imy', 'application/x-imy'), //'audio/*'),
'dmx' => array( ''), //'audio/*'),
'mfm' => array( 'application/vnd.smaf', 'audio/mmf','application/x-smaf','audio/x-mmf','audio/smaf'), //'audio/*'),
'seq' => array( ''), //'audio/*'),
'vox' => array( ''), //'audio/*'),
// images :
'bmp' => array('image/bmp','image/x-bmp','image/x-ms-bmp','image/x-ota-bitmap','image/x-xbitmap'),
'jpg' => array('image/jpg','image/jpeg','image/pjpeg'),
'jpeg' => array('image/jpeg','image/jpg','image/pjpeg'),
'wbmp' => array('image/wbmp','image/vnd.wap.wbmp'),
'gif' => array('image/gif'),
'tif' => array('image/tiff'),
'ani' => array('image/ani','image/ems.predefined.animation','image/ems.userdefined.animation','application/vnd.3gpp.ani-bw-large','application/vnd.3gpp.ani-bw-small'),
'pic' => array('application/x-mmc.picture','application/vnd.3gpp.pic-bw-large','application/vnd.3gpp.pic-bw-small','application/vnd.3gpp.pic-bw-var','image/ems.userdefined.picture'),
'pco' => array(''),
'png' => array('image/png','image/x-up-wpng'),
// Jeux :
'jar' => array('application/java-archive','application/java','application/x-java-archive'),
'jad' => array('application/java','application/java-archive','application/x-java-archive'),
'mpn' => array('application/game','text/game'),
'mpc' => array('application/game','text/game'),
// divers gsm, pda
'thm' => array('application/vnd.eri.thm'),
'sis' => array('image/vnd.wap.sis'),
//autres :
'txt' => array('text/plain'),
'html' => array('text/html'),
'htm' => array('text/html'),
'shtm' => array('text/html'),
'shtml' => array('text/html'),
'rtf' => array('application/rtf'),
'pdf' => array('application/pdf'),
'zip' => array('application/zip'),
'tar' => array('application/x-tar'),
'tgz' => array('application/x-tar'),
'gz' => array('application/x-gzip'),
'gtar' => array('application/x-gtar'),
'sh' => array('application/x-sh'),
'csh' => array('application/x-csh'),
'bin' => array('application/octet-stream'),
'class' => array('application/octet-stream'),
'exe' => array('application/octet-stream'),
'sea' => array('application/octet-stream'),
'hqx' => array('application/mac-binhex40'),
'doc' => array('application/msword'),
'dot' => array('application/msword'),
'pot' => array('e'),
'pps' => array('application/mspowerpoint'),
'ppt' => array('application/mspowerpoint'),
'ppz' => array('application/mspowerpoint'),
'ai' => array('application/postscript'),
'eps' => array('application/postscript'),
'ps' => array('application/postscript'),
'js' => array('application/x-javascript'),
'swf' => array('application/x-shockwave-flash'),
'sit' => array('application/x-stuffit'),
'tcl' => array('application/x-tcl'),
//'bmp' => array('image/bmp'),
//'gif' => array('image/gif'),
'jpe' => array('image/jpeg'),
//'jpeg' => array('image/jpeg'),
//'jpg' => array('image/jpeg'),
//'png' => array('image/png'),
//'tif' => array('image/tiff'),
'tiff' => array('image/tiff'),
//'mid' => array('audio/midi')
);
$MimesAcceptes = $_SERVER["HTTP_ACCEPT"];
/* $MimesAcceptes = 'application/octet-stream,application/smil,application/vnd.oma.drm.message,application/vnd.smaf,application/vnd.wap.coc,application/vnd.wap.mms-message,application/vnd.wap.multipart.mixed,application/vnd.wap.multipart.related,application/vnd.wap.sic,application/vnd.wap.slc,application/vnd.wap.wmlc,application/vnd.wap.wmlscriptc,application/vnd.wap.xhtml+xml,application/x-smaf,application/xhtml+xml,audio/mid,audio/midi,audio/x-midi,image/bmp,image/gif,image/jpeg,image/png,image/vnd.wap.wbmp,image/x-ms-bmp,text/css,text/html,text/plain,text/vnd.sun.j2me.app-descriptortext/vnd.wap.wml,text/vnd.wap.wmlscript,text/x-vcalendar,text/x-vcard';
$extension = (ereg('.+\.(:alnum:+)$', $file, $regExtension)) ? $regExtension[1] : '';
//$MimeTypeDownload = 'application/force-download' ;
// trouve le bon type mime
if($extension != '') {
if(array_key_exists($extension, $TypeMimeRef)){
foreach($TypeMimeRef[$extension] as $TypeMimePossible){
if(substr_count($MimesAcceptes, $TypeMimePossible) > 0){
$TypeMimeFile = $TypeMimePossible ;
break ;
};
};
// si on a parcourus tout le fichier sans trouver le type mime
if( ! isset($TypeMimeFile)) {
$TypeMimeFile = 'application/force-download' ;
}
};
};
//echo "|$TypeMimeFile|";
//echo "|$file|";
//echo filesize(stripslashes($PatchFile)) ;
//header('content-type: application/octetstream');
header('content-type: '.$TypeMimeFile);
header('Content-Disposition: attachment; filename='.$file);
header('Content-Length: '.filesize($PatchFile));
//header('Content-Transfer-Encoding: binary');
//header('!content-transfer-encoding:! fichier');
// Pas de mise en cache
header('Pragma: no-cache ');
header('Cache-Control: n o-store, no-cache, must-revalidate, post-check=0, pre-check =0');
header('Expires: 0');
readfile($PatchFile) ;
/*if( ! @readfile($PatchDownloadFile) || connection_aborted() != 0) {die($php_errormsg);
}else{$rien = 0 ; die();};*/
break;
case 2 :
// autre méthode : par redirection :
// dirname commence par un slash.
header("Location: $AdresseAbsolueFile");
//echo "|$AdresseAbsolueFile|";
die();
break ;
case 3 :
// autre méthode : par lien :
// dirname commence par un slash.
global $BalisesHeadOuvre, $BalisesHeadFerme, $BalisesFin, $XMLversion, $DocType, $TexteDownload, $BaliseAOuvre, $BaliseAFerme, $header ;
$BrutHead = $BalisesHeadOuvre.$BalisesHeadFerme ;
$BrutTexteDownload = Paragraphe($TexteDownload) ;
$BrutDebut1 = $XMLversion.$DocType.$BrutHead ;
$BrutFin = $BalisesFin ;
$LienDownload = $BaliseAOuvre.$AdresseAbsolueFile.'">'.$file.$BaliseAFerme ;
EnvoiHeader($header);
die($BrutDebut1.$BrutTexteDownload.$LienDownload.$BrutFin);
break ;
default : $rien = 0 ;
};
};
//*******************************************************************************
//<système de compression des urls>
//*******************************************************************************
function OuvreIndex(){
global $compression_Activee, $FichierDeCompression, $IndexIni, $Index ;
if($compression_Activee){
if( ! isset($IndexIni)){
// teste si le fichier de compression existe et si il est rempli.
$Taille = (is_file($FichierDeCompression)) ? @filesize($FichierDeCompression) : 0 ; //echo $Taille;
if($Taille > 0) {
$IndexLigne = @file($FichierDeCompression) ; // récupère le contenu du fichier de compression dans un tableau (/par lignes)
$IndexLigne = array_map('MyStripSlashes', $IndexLigne); // gere les magic quotes
foreach($IndexLigne as $ligne) {
$DecoupeLigne = explode('|', $ligne, 2) ;
$IndexIni[$DecoupeLigne[0]] = ereg_replace("\n$",'',$DecoupeLigne[1]) ; // retire le retour de chariot en fin de ligne
};
//echo '$IndexIni<pre>';print_r($IndexIni) ;echo '</pre>';
//return($IndexIni) ;
}else $IndexIni = null ; // return($IndexIni = null);}; // soit le fichier n'existe pas (encore), soit il est vide !
}; //else return($IndexIni);
}; //else return(true); // la compression n'est pas activée
if( ! isset($Index)) $Index = $IndexIni ;
return(true) ;
};
function TrouveIndex($DossierOuFichier){
global $Index, $MAJ ;
// recherche la clef un fichier ou dossier demandé dans l'index correspondant. si l'index ou la clef n'existe pas, on la crée.
// si le dossier est '25145' : on ne pourra pas savoir lors de la decompression si c'est un dossier compressé, donc on le compresse toujours tel quel.
//"3" car on ne comprime que si c'est interessant.(on aurait pu, pour être plus juste mettre un global $clefs et remplacer 3 par strlen($clefs) mais ça ralenti inutilement le serveur :
// on se base dans l'optique arbitraire qu'il y a moins de 1000 fichiers + dossier sur le site).
if( is_numeric($DossierOuFichier) || strlen($DossierOuFichier) > 3) {
OuvreIndex();
if($Index == null ){ // L'index n'est pas définit : le fichier de compression n'existe pas ou est vide
$clef = 1 ; // ne pas commencer à la clef 0 !! car elle est équivalente à false et provoque des erreur plus loin !
$Index[$clef ] = $DossierOuFichier ; $MAJ .= "$clef|$DossierOuFichier\n" ;
}elseif( ! ($clef = array_search($DossierOuFichier, $Index))){
//si le dosier ou fichier n'est pas présent dans le fichier de compression : on l'ajoute :
$Index[] = $DossierOuFichier ;
$clef = array_search($DossierOuFichier, $Index); $MAJ .= "$clef|$DossierOuFichier\n" ;
};
return ($clef) ;
}else return false ;
};
function FermeIndex(){
// si FermeIndex retourne false : la compression a échouée : on recommence tout sans compression
global $compression_Activee, $FichierDeCompression, $IndexIni, $MAJ ;
if($compression_Activee){
// met à jour l'ensemble des ajouts dans le fichier txt contenant l'index : écrit $MAJ à la fin du fichier
//echo '$IndexIni<pre>';print_r($IndexIni);echo'</pre>';echo '$Index<pre>';print_r($Index);echo'</pre>';echo '$MAJ<pre>';echo $MAJ;echo'</pre>';
if( $MAJ != '' ) {
// Ouvre en lecture et écriture; place le pointeur de fichier à la fin du fichier. a+ --> Si le fichier n'existe pas, on tente de le créer.
if( ! $fp = @fopen($FichierDeCompression, 'a+')) return false ; // echec ouverture fichier
$succesMAJ = ( fwrite($fp, $MAJ)) ? true : false ;// écrit la MAJ :
fclose ($fp); // on ferme puis on envoie (return)
return ($succesMAJ);
}else return (true) ; // aucune MAJ n'est nécéssaire
}else return(true); // la compression n'est pas activée
};
function CompresseNom($nomFichier){
global $compression_Activee ;
if($compression_Activee){
return ($clef = TrouveIndex($nomFichier)) ? $clef : $nomFichier ;
}else return($nomFichier); // la compression n'est pas activée
};
function DeCompresseNom($clef){
global $compression_Activee, $Index ;
if($compression_Activee){
if(is_numeric($clef)) {
OuvreIndex();
return (array_key_exists($clef,$Index)) ? $Index[$clef] : false ;
}else return($clef); // ce n'est pas un nom compressé
}else return($clef); // la compression n'est pas activée
};
//*******************************************************************************
//<divers>
//*******************************************************************************
function my_obstart()
{
$encoding = getenv("HTTP_ACCEPT_ENCODING");
if (eregi("gzip",$encoding))
{
ob_start("ob_gzhandler");
}else
{
ob_start(); //supprimer cette ligne, si vous ne souhaitez pas le bufforing
}
};
function SansAccuent($chaine) {
return strtr($chaine,
"ÀÁÂÃÄÅàáâãäåÒÓÔÕÖØòóôõöøÈÉÊËèéêëÇçÌÍÎÏìíîïÙÚÛÜùúûüÿÑñ",
"AAAAAAaaaaaaOOOOOOooooooEEEEeeeeCcIIIIiiiiUUUUuuuuyNn" );
};
function TexteWml($chaine) {
global $remplacementlien, $langage ;
return ($langage == 'wap') ? strtr(SansAccuent($chaine), $remplacementlien) : SansAccuent($chaine) ;
};
function RenamePourWml($FichierOuDossiers){
global $AutoriseRenommageFichiers, $langage, $remplacementRename, $SlashOuAntiSlash, $Patch, $from ;
// certain caractères font planter la pagewap (les accents en particulier), il faut les enlever du code wml :
//ATTENTION certain fichiers pourront être renommer !
if($AutoriseRenommageFichiers == 'oui' and $langage == 'wap'){
$renommePourWml = SansAccuent($FichierOuDossiers);
$renommePourWml = strtr($renommePourWml, $remplacementRename) ;
if($renommePourWml != $FichierOuDossiers)
$PatchTemp = $from.$SlashOuAntiSlash.$renommePourWml ;
if(rename($Patch, $PatchTemp))
return($renommePourWml);
else return($FichierOuDossiers);
}else return($FichierOuDossiers);
};
// Ajoute $char à la fin (droite) de $str si ce caractère n'existe pas déjà. Si $str est vide, le caractère n'est pas ajouté.
function addEnd($str, $char)
{
if (((substr($str, -1) != $char) || ($str == '')) && $str != '')
$str .= $char;
return $str;
}
//Add a <kbd>/</kbd> at the end, if <kbd>$wpath</kbd> don't end by a slash.
function addEndSlash($wpath)
{ return addEnd($wpath, '/');}
//*******************************************************************************
//<gere les MagicQuotes des variables gpc (cad : get/post/cookie)>
//*******************************************************************************
// gere les MagicQuotes
function MyStripSlashes($chaine) { // pour data base et fichier
return( get_magic_quotes_runtime() == 1 ?
stripslashes($chaine) :
$chaine );
}
function MyAddSlashes_gpc($chaine ) {
return( get_magic_quotes_gpc() == 1 ?
$chaine :
addslashes($chaine) );
}
function MyStripSlashes_gpc($chaine) {
return( get_magic_quotes_gpc() == 1 ?
stripslashes($chaine) :
$chaine );
}
function getmicrotime() {
list($usec, $sec) = explode(
" ",microtime());
return ((float)$usec +
(float)$sec);
}
/*
// assert_options()
if(ini_get('ASSERT_ACTIVE') != 1) ini_set('ASSERT_ACTIVE', 1); // active l'évaluation de la fonction assert()
if(ini_get('ASSERT_WARNING') != 1) ini_set('ASSERT_WARNING', 1); // génère une alerte PHP pour chaque assertion fausse
if(ini_get('ASSERT_BAIL') != 0) ini_set('ASSERT_BAIL', 0); // termine l'exécution en cas d'assertion fausse (0 -> inactivé)
?>
Conclusion :
A noter : la page i-mode peut être lue par par un navigateur web (IE et autes).
Système plus souple, aucune installation,
- sytème de compression des url, permettant d'afficher plus de liens pour une même taille de page générée.
- possibilités de controles (à implimenter très facilement) : interdire le download, compter le nombre de téléchargements par fichier, enregistrer la navigation suivies, etc...
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.