Sobald man irgendwo auf eine Seite mit Registrierung gelangt und man diese Seite öfer besucht, merkt man schnell, wie nervig es ist, selbst mit Firefox-Passwortmanager, ständig sich einzuloggen.
Als Programmeirer stellt sich schnell die Frage ob man eine Funktion ala “Eingeloggt bleiben” anbietet. Wie OWASP in ihren Top 10 empfehlen sollte jeder Entwickler auf diese aus Sicherheitsgründen verzichten.
Meiner Meinung nach sollte man jedoch gerade bei solch wichtigen Funktion usability vor Security stellen. Nun nicht falsch verstehen, natürlich sollte man auf Sicherheit achten. Aber gerade bei einem Login ist es wichtig, dass die Leute sich gerne wieder einloggen um Neuigkeiten zu erfahren. Ist der Login umständlich, so meldet man sich ungern noch einmal an, weil es eine geühlte Ewigkeit dauert.

Um troz einer Funktion “Eingeloggt bleiben” genug Sicherheit zu haben um auch das Cookie-Riding zu verhindern verweise ich also gerne auf diesen Eintrag.

Improved Persistent Login Cookie Best Practice

Das aktualisieren der Seite wird oftmals von Besuchern auch nach einem Forumular benutzt. Damit jedoch kein Doppelposting entsteht erkläre ich kurz eine Funktion.

Hierzu muss bereits am Anfang der php-Datei eine Session mit session_start(); gestartet werden.
Zusätzlich muss in das Formular ein zusätzliches Feld hinzugefügt werden. Der name kann natürlich Frei gewählt werden.

echo "<input name='rft' type='hidden' value='".random_form_token()."' />";

Bei der Verarbeitung des Formulars muss nun nurnoch vor dem Speichern dies hier abgeprüft werden.

if(random_form_token($_POST['rft'])){
  // Schreiben
}
else{
  // Doppelposting erkannt
}

Und nun hier noch die Funktion selbst.

function random_form_token($value=NULL){
	if($value == NULL){
		$token = hash("sha256","tanzmal".microtime());
		$_SESSION['random_form_token'] = $token;
		return $token;
	}
	else{
		if($value == $_SESSION['random_form_token']){
			unset($_SESSION['random_form_token']);
			return true;
 
		}
		else
			return false;
	}
}

Sobald man mehrere Sprachen unterstützt, ist es natürlich leicht den Besucher selbst aussuchen zu lassen welche Sprache er ansehen will.
Um die Standard-Sprache zu setzen habe ich auf selfhtml eine schöne Sprachfunktion gefunden.
Sinnvoll ist diese um eine Standardsprache auszuwählen und eine Menge an unterstützen Sprachen.

Ein Verzeichnis rekursiv mit PHP auszulesen bedarf es nicht viel.

Hier habe ich ein beispiel mit lediglich 3 kleinen Funktionen.

• Die Erste gibt eine lesbare Dateigröße aus
• Die zweite Funktion definiert, wie die Dateien angezeigt werden sollen
• Die Dritte Liest die Ordner aus und ruft gegebenenfalls Sich slebst mit neuem Parameter auf

function byteConvert($bytes){
	$symbol = array('B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB');
	$exp = 0;
	$converted_value = 0;
	if( $bytes > 0 ){
		$exp = floor( log($bytes)/log(1000) );
		$converted_value = ( $bytes/pow(1000,floor($exp)) );
	}
	return sprintf( '%.2f '.$symbol[$exp], $converted_value );
}
function file_detail($dir,$name){
	$stat = @stat($dir.$name);
	#print_r($stat);
	$returner .= "<td>$name</td>";
	$returner .= "<td>".byteConvert($stat['size'])."</td>";
	return $returner;
}
function rec_scan_dir($dir){
	$returner = "<table>\n";
	$files = scandir( $dir );
	sort($files);
	foreach($files as $file){
		if( $file!="." && $file!=".."){
			if(is_dir($dir.$file)){
				$returner .= "<tr><td class='dir'>$file</td></tr>\n";
				$returner .= "<tr><td><div class='dir_pad' style='padding-left:10px;'>".rec_scan_dir($dir.$file)."</div></td></tr>\n";
			}
			else{
				$returner .= "<tr>";
				$returner .= file_detail($dir,$file);
				$returner .= "</tr>\n";
			}
		}
	}
	$returner .= "</table>\n";
	return $returner;
}
 
$dir = './files/';
echo "<h1>$dir</h1>";
print_r(rec_scan_dir($dir));

Um Webseiten zu internationalisieren, benötigt es mehr als nur die übersetzten Texte. Ich erkläre hier die Grundlagen die man benötigt um eine erfolgreiche Internationalisierung vorzunehmen.

Nehmen wir an wir haben unsere normale Seite. Natürlich sind hier durchaus mehr Texte denkbar.

1
2

echo "Herzlich Willkommen"."\n";
echo "Link zum Gästebuch";

Um nun mehrere Sprachen zu unterstützen passen wir zuerst unsere Seite an

1
2

echo $message["welcome"]."\n";
echo $message["link_guestbook"];

Da wir zu einer erfolgreichen Internationalisierung auch andere Sprachen brauchen hier ein Beispiel hierfür.

// lang_de.php - Deutsche Sprache
$message["welcome"] = "Herzlich Willkommen";
$message["link_guestbook"] = "Link zum Gästebuch";

// lang_en.php - english language
$message["welcome"] = "Welcome";
$message["link_guestbook"] = "Link to guestbook";

Nun müssen wir in unsere Seite noch eine Abfrage machen welche Sprache benutzt werden soll.

1
2
3
4
5
6
7

switch($_GET['lang'){
	default:
	case "de": include("lang_de.php"); break;
	case "en": include("lang_en.php"); break;
}
echo $message["welcome"]."\n";
echo $message["link_guestbook"];

Manchmal kann es jedoch sein, dass man auch in Funktionen die Sprachblöcke benutzen will. Um ein

global $message

in jeder Funktion zu vermeiden. Benutzen wir anstatt eines Arrays globale Konstanten. Wie auf den PHP-Seiten zu erlesen ist sollte man für Konstanten immer GROSSBUCHSTABEN verwenden. Auch sollte den Konstantennamen kein $ voran gestellt werden. So erhalten wir eine Sprachdatei die zum Beispiel so aussieht.

// lang_de.php - Deutsche Sprache
define("WELCOME",		"Herzlich Willkommen");
define("LINK_GUESTBOOK", 	"Link zum Gästebuch");

Nun müssen wir nurnoch unsere Seite anpassen.

1
2
3
4
5
6
7

switch($_GET['lang'){
	default:
	case "de": include("lang_de.php"); break;
	case "en": include("lang_en.php"); break;
}
echo WELCOME."\n";
echo LINK_GUESTBOOK;

Immerwieder passiert es. Man hat Daten die man gerne in einem Diagramm darstellen möchte. Da dies mitunter recht schwer sein kann, habe ich mir meine eigene PHP-Funktion geschrieben, die es mir ermöglicht ein Array direkt mit einem Diagramm zu visualisieren.

Um eine solche Funktion zu Programmieren benötigen wir mehrere Teile.

0. Der Funktionskopf sieht so aus

function arraytograph($data,$w=300,$h=100,$show_keys = true,$label = '')

1. Prüfen ob die übergebenen Werte gefüllt sind. Des Weiteren prüfen wir, welche Achsenbeschriftung angezeigt werden soll. Auch definieren wir hier den Standard Abstand nach oben und unten.

	if (!isset($data) || empty($data))	{
		return FALSE;
	}
	if($label == 'value'){
		$show_precent = false;
		$show_number = true;
	}
	elseif($label == 'percent'){
		$show_precent = true;
		$show_number = false;
	}
	else{
		$show_precent = true;
		$show_number = false;
	}
	$pic_border_top = 5;
	$pic_border_bottom = 5;

2. Die Schlüssel des Arrays holen, um die Achsenbeschriftung zu zeichnen

	// getting the keys from array
	$keys = array_keys($data);

3. Um den Platz für die Achsenbeschriftung zu machen, wird der Längste Schlüssel gesucht. Um genug Platz zu haben, wird die pro Zeichen 6 Pixel gerechnet. Damit die Schrift nicht am Boden “aufsetzt” werden nochmals 12 Pixel hinzugerechnet.

	// the keys should be displayed, so add a stripe for displaying the keys
	// find the longest key. the length of string *6pixel per letter are added to the border bottom
	if($show_keys){
		$max = 0;
		for($i=0;$i

4. Damit die Möglichkeit besteht, nicht nur die relativen Prozentralen anzeigen zu lassen, suchen wir erneut den längsten String in dem Array. Diesmal jedoch auf die Werte bezogen. Pro Zeichen benutzen wir diesmal 8 Pixel. Wenn Prozentzahlen angezeigt werden sollen, so wird der obere freie Platz um 32 Pixel vergrößert.

	// the number should be displayed at the top of the diagramm
	if($show_number){
		$max_num = 0;
		for($i=0;$i$pic_border_top){
			$pic_border_top += $max_num*8;
		}
	}
	if($show_precent){
		$pic_border_top += 32;
	}

5. Um die relative Höhe auszurechnen suchen wir den größten Wert in dem Datenarray und setzten alle anderen Werte in Relation zu diesem Wert.

	//Convert the values to percent values
	$hundredp = max($data);
	$newarray = array();
	foreach ($data as $el) {
		$newarray[] = intval($el / $hundredp * 100);
	}

6. Um nun ein Diagramm zu erstellen, nehmen wir die Parameter $w und $h und rufen mit diesen die Funktion imagecreatetruecolor auf. Um später verschiedene Farben benutzen zu können definieren wir uns hier auch gleich ein paar Farben

	// let's start with the image-creation
	$im = imagecreatetruecolor($w, $h);
	//define colors.
	$col_background = imagecolorallocate($im, 0, 0, 0);
	$col_grid = imagecolorallocate($im, 0x53, 0x44, 0x01);
	$col_bars = imagecolorallocate($im, 0xb7, 0x6b, 0x1a);
	$col_text = imagecolorallocate($im, 200, 200, 200);

7. Um ein schönes Diagramm erstellen zu können muss es natürlich auch ein Raster geben. Hierzu werden zuerst die horizontalen Linien gezeichnet. Diese werden über die gesamte Breite des Bildes gezeichnet. Um natürlich die horizontalen Linien nur in dem Diagrammbereich zu zeichen, werden hier die Bereiche für die Schlüsselanzeige (unten) und die Werteanzeige(oben) subtrahiert/addiert.
Bei den vertikalen Linien geben wir soviele Linien aus wie es auch Balken geben wird. Auch hier wird nur im Diagrammbereich gezeichnet und der Bereich für die Beschriftungen weggelassen. Mit der Variable $space definieren wir auch gleich die Breite der einzelnen Balken. Da wir natürlich nur begrenzt Platz für die Werte haben, setzen wir diese in eine Relation.

	// drawing the grid
	//horizontal lines
		for ($i=1; $i<=10; $i++)	{
			imageline($im,
				0,
				$i*(($h-$pic_border_bottom-$pic_border_top)/10)+$pic_border_top,
				$w,
				$i*(($h-$pic_border_bottom-$pic_border_top)/10)+$pic_border_top,
				$col_grid);
		}
	//vertical
		$space = intval($w / count($newarray));
		for ($i=1; $i<=count($newarray); $i++)		{
			imageline($im,
				$i*$space,
				$pic_border_top,
				$i*$space,
				$h-$pic_border_bottom,
				$col_grid);
		}

8. Das Zeichnen der Balken
Nun gehen wir das neue Array von vorne beginnend durch und zeichnen jeden Balken.
Da wir wieder nur in dem Diagrammbereich zeichnen wollen, ziehen wir wieder die die $pic_border_top und $pic_border_bottom von den jeweiligen Werten ab. Hier gibt es auch die Möglichkeit die Werte relativ zueinander, also in Prozent, oder in absoluten Zahlen darzustellen. Mit der Variablen $show_percent werden relative Werte ausgegeben mit der Variablen $show_number werden absolute Zahlen angezeigt. Auch gibt es die Möglichkeit die Schlüssel mit anzeigen zu lassen, oder eben nicht

	// start drawing the datas
	for ($i=0; $i

9. Da bisher keine einzige Ausgabe stattfand, können wir nun den Header senden und spezifizieren das es sich um ein png bild handelt. Danach geben wir aus dem erstellten Bild ein PNG aus und zerstören dies auch sogleich. So wird es asugegeben, jedoch nicht in einer datei gespeichert.

	//tell the browser that this will be a png image.
	header("Content-type: image/png");
 
	//finally generate the image;
	imagepng($im);
	imagedestroy($im);

So nun haben wir eine fertige Funktion die uns ein Bild ausgibt, sobald wir diese aufrufen.
Da die Funktion mit dem Header arbeitet, können wir diese nicht einfach in den Quellcode einbinden, sondern müssen den Weg über eine neue Datei gehen.
Also erstellen wir uns eine neue Datei die wir als Bild von einer anderen Datei aufrufen können. Sollten keine Daten zum Anzeigen übergeben werden, bricht das Script ab. Ansonsten holt es sich das Datenarray aus der übergebenen URL. Mit serialize lassen sich Arrays in einen String codieren. mit der Funktion unserialize genau das Gegenteil, es wird also aus einem codierten String wieder ein Array geformt. Um die Verarbeitung zu erleichtern, wird nur ein Array übergeben das aus 3 Teilen besteht,

• den anzuzeigenden Daten
• der Höhe
• der Breite

if(!isset($_GET['data'])){
	die();
}
else{
	$data = unserialize(stripslashes($_GET['data']));
	$cont = $data['data'];
 
	if(isset($data['h']))
		$h = $data['h'];
	if(isset($data['b']))
		$b = $data['b'];
	if(isset($data['keys']))
		$keys = $data['keys'];
	if(isset($data['label']))
		$keys = $data['label'];
}

Sobald wir dies haben, können wir das ganze Zu einer kompletten Datei zusammensetzen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

<?php
function arraytograph($data,$w=300,$h=100,$show_keys = true,$label = ''){
	// Check if the array isn't empty
	if (!isset($data) || empty($data))	{
		return FALSE;
	}
	if($label == 'value'){	
		$show_precent = false;
		$show_number = true;
	}
	elseif($label == 'percent'){
		$show_precent = true;
		$show_number = false;
	}
	else{
		$show_precent = false;
		$show_number = false;
	}	
	$pic_border_top = 5;
	$pic_border_bottom = 5;
 
	// getting the keys from array
	$keys = array_keys($data);
 
 
	// the keys should be displayed, so add a stripe for displaying the keys
	// find the longest key. the length of string *6pixel per letter are added to the border bottom
	if($show_keys){
		$max = 0;
		for($i=0;$i<count($keys);$i++){
			if($max<strlen($keys[$i]))
				$max = strlen($keys[$i]);
		}
		$pic_border_bottom = $max *6+12;
	}
 
	// the number should be displayed at the top of the diagramm
	if($show_number){
		$max_num = 0;
		for($i=0;$i<count($keys);$i++){
			if($max_num<strlen($data[$keys[$i]]))
				$max_num = strlen($data[$keys[$i]]);
		}
		if(($max_num*7)+3>$pic_border_top){
			$pic_border_top += $max_num*8;
		}
	}
	if($show_precent){
		$pic_border_top += 32;
	}
 
	//Convert the values to percent values
	$hundredp = max($data);
	$newarray = array();
	foreach ($data as $el) {
		$newarray[] = intval($el / $hundredp * 100);
	}
 
	// let's start with the image-creation
	$im = imagecreatetruecolor($w, $h);
	//define colors.
	$col_background = imagecolorallocate($im, 0, 0, 0);
	$col_grid = imagecolorallocate($im, 0x53, 0x44, 0x01);
	$col_bars = imagecolorallocate($im, 0xb7, 0x6b, 0x1a);
	$col_text = imagecolorallocate($im, 200, 200, 200);
 
	//fill with background color
		imagefill($im, 0, 0, $col_background);
 
	// drawing the grid
	//horizontal lines
		for ($i=1; $i<=10; $i++)	{
			imageline($im,
				0,
				$i*(($h-$pic_border_bottom-$pic_border_top)/10)+$pic_border_top,
				$w,
				$i*(($h-$pic_border_bottom-$pic_border_top)/10)+$pic_border_top,
				$col_grid);
		}
	//vertical
		$space = intval($w / count($newarray));
		for ($i=1; $i<=count($newarray); $i++)		{
			imageline($im,
				$i*$space,
				$pic_border_top,
				$i*$space,
				$h-$pic_border_bottom,
				$col_grid);
		}
 
		// start drawing the datas
	for ($i=0; $i<count($newarray);$i++){
		$x1 = intval($space/2) -1 + $space*$i;
		$y_bottom = $h-$pic_border_bottom;
		$y_top = ($h-$pic_border_bottom)-(($newarray[$i])*((($h-$pic_border_bottom)-$pic_border_top)/100));
 
		imagefilledrectangle($im, $x1, $y_bottom, $x1+3, $y_top, $col_bars);
 
		if($show_number && !$show_precent){
			$number = $data[$keys[$i]];
			imagestringup($im, 2, $x1-5, $y_top-10,$number,$col_text);
		}
 
		if($show_precent && !$show_number)
			imagestringup($im, 2, $x1-5, $y_top-10, $newarray[$i].'%',$col_text);
 
		if($show_keys)
			imagestringup($im, 2, $x1-5, $h-10-(($max-strlen($keys[$i]))*6), $keys[$i],$col_text);
	}
	//tell the browser that this will be a png image.
	header("Content-type: image/png");
 
	//finally generate the image;
	imagepng($im);
	imagedestroy($im);
}
 
if(!isset($_GET['data'])){
	die();
}
else{
	$data = unserialize(stripslashes($_GET['data']));
	$cont = $data['data'];
 
	if(isset($data['h']))
		$h = $data['h'];
	if(isset($data['b']))
		$b = $data['b'];
	if(isset($data['keys']))
		$keys = $data['keys'];
	if(isset($data['label']))
		$label = $data['label'];
}
arraytograph($cont,$b,$h,$keys,$label);
?>

Nun sollte es möglich sein in einer neuen Datei, in der man das Diagramm anzeigen möchte unsere Diagrammdatei als Bildquelle einzubinden. Als zusätzliche Parameter an das Bild übergeben wir die oben genannten 3 Parameter (Daten, Höhe, Breite)

<?php
$datas['data'] = array("Stein"=>64,"Lehm"=>128,"Holz"=>256,"Nahrung"=>512,"Menschen"=>1024);
$datas['h'] = 200;
$datas['b'] = 150;
$datas['keys'] = true;
$datas['label'] = 'value';
echo "<img src='arraytograph.php?data='.urlencode(serialize ($datas)).'" alt="" /> ';
?>

Nun sehen wir in unserer Datei ein schönes Diagramm

Leicht lassen sich auch andere Möglichkeiten generieren

<?php
$datas['data'] = array("Stein"=>64,"Lehm"=>128,"Holz"=>256,"Nahrung"=>512,"Menschen"=>1024);
$datas['h'] = 200;
$datas['b'] = 150;
$datas['keys'] = true;
$datas['label'] = 'percent';
echo "<img src='arraytograph.php?data='.urlencode(serialize ($datas)).'" alt="" /> ';
?>

oder auch

<?php
$datas['data'] = array("Stein"=>64,"Lehm"=>128,"Holz"=>256,"Nahrung"=>512,"Menschen"=>1024);
$datas['h'] = 150;
$datas['b'] = 150;
$datas['keys'] = true;
$datas['label'] = 'value';
echo "<img src='arraytograph.php?data=".urlencode(serialize ($datas))."' > ";
?>

Viel Spass damit


Erweiterung von Gaming with PHP

Für eventuelle spätere Generationen, die diesen “Quatsch” auch mitmachen müssen, gibt es im Anhang Lösungen von Ben und mir zum Labsheet E (SS08).

Wenn ihr euch das ganze “Programm” ziehen wollt, findet ihr dieses auf der Homepage des Lehrstuhls.

So long,
Seb

Download Code

Da die Ausgabe des Algorithmus von Gestern noch nich das war, was ich eigentlich wollte, aber das Grundgerüst sehr gut war, habe ich diesen nun so modifiziert, dass er, wie schon der erste Versuch, eine Tabelle mit dem Seiten Index ausgibt.
Diesmal werden aber alle Unterordner und auch das root-Verzeichnis durchsucht. Nur Väter des root-Verzeichnisses werden nicht betrachtet.

Diesmal werde ich zuerst den kompletten Code präsentieren und danach einzelne Teile besprechen. Ich hoffe, dass man dadurch ein besseres Verständnis des Codes bekommt, da mir die Variante mit den Code-Schnipseln nicht so zugesagt hat.

Here we go:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

function createFileIndex( $start = '.')
{
    //catch error
    if(! is_dir($start))
		return false;
 
	//initalize stuff
	echo "<table cellpadding=0 cellspacing=0 border=1 rules=rows>";
	$dirs = array( $start);
 
	echo "<tr><th>NAME</th>
		<th style='width:50px'></th>
		<th align=center>SIZE</th>
		<th style='width:20px'></th>
		<th align =center>TYPE</th>
		<th style='width:20px'></th>
		<th align=center>DATE CREATED</th>
		</tr>";
 
	//search iterative
	while( NULL !== ($dir = array_pop( $dirs)))
	{
		$dh = opendir($dir);
		while( $file = readdir($dh) )
		{
			//skip current directory and php-files
			if( $file == '.' || $file == '..' || substr($file,-3)=="php")
				continue;
			$path = $dir . '/' . $file;
			//if path is an directory
			//=> write into array, else write the files attributes into the table
			if( is_dir($path) )
				$dirs[] = $path;
			else
			{
				//get file infos
				$ftime = gmdate("d.M.y",filemtime($path))
					. "&nbsp;&nbsp;&nbsp;"
					. gmdate("H:i:s",filemtime($path));
				$fsize = round(filesize($path) * .0009765625);
				$ftype = strtolower(substr(strrchr($file,'.'),1));
 
				//to table
				$output = "<tr>
				<td><a href='$path'>$file</a></td>
				<td></td>
				<td align=center>$fsize KB</td>
				<td></td>
				<td align=center>$ftype</td>
				<td></td>
				<td align=right>$ftime</td>
				</tr>";
				echo $output;
			}
		}
		closedir($dh);
	}
	echo "</table>";
}

Der Algorithmus funktioniert wie folgt:

1. Es wird ein Array “dirs” erstellt, in welches der Startpunkt (root) geschrieben wird.
2. Das letzte Element aus “dirs” (ein Verzeichnis) wird herausgeholt und dabei entfernt, sollte das Entnehmen eines Elementes aus dem Array nicht möglich sein, wird der Algorithmus beendet.
3. Das entnommene Verzeichnis wird nun auf der Suche nach Inhalten durchlaufen. Dabei wird unterschieden, ob es sich bei dem gefundenen Eintrag um ein Verzeichnis oder eine Datei handelt.
   • Fall 1 (Verzeichnis): Das gefundene Verzeichnis wird mit kompletten Pfad in das Array “dirs” geschrieben, um später auch in diesem Verzeichnis nach Datein zu suchen.
   • Fall 2 (kein Verzeichnis): Es wurde eine Datei gefunden. Also holen wir uns von der Datei alle Attribute, die wir wünschen (Name, Größe, Typ, Erstelldatum), und schreiben alles in eine Tabelle.
4. Wenn das Verzeichnis komplett durchlaufen wurde, geht es wieder zu Punkt 2.

Als Ausgabe erhält man zum Beispiel:

Wie man sieht wurde auch schon ein bisschen an der Optik gefeilt.
Es gibt das erste Mal eine Kopfzeile, anstatt in Bytes ist die Größenangabe in KB und auch das Erstelldatum ist ein Wenig übersichtlicher dargestellt.

Das wars mal wieder. Nächste Woche gehts weiter. Dann wird hoffentlich an der Optik gefeilt.

So long,
Seb

Download Code

Tja, da gibt man sich solche Mühe. Hat sich sogar schon einen Algorithmus zusammengebastelt und sucht nur noch die ganzen PHP-Methoden bzw. überprüft ob PHP das auch kann. Dann stöbert man ein bisschen in den Kommentaren zu den Funktionen..

..und was entdeckt man?
Einen drei Zeiler, der die Verzeichnisse komplett durchforstet und alle Unterverzeichnisse auflistet.
Klassischer Fall:

Der Vollständigkeit halber hier der Code-Schnipsel:

1
2
3
4
5
6
7
8
9
10
11
12

<?php
$it = new RecursiveDirectoryIterator('./');
// RecursiveIteratorIterator accepts the following modes:
//     LEAVES_ONLY = 0  (default)
//     SELF_FIRST  = 1
//     CHILD_FIRST = 2
foreach (new RecursiveIteratorIterator($it, 2) as $path) {
    if ($path->isDir()) {
        echo "$path\n";
    }
}
?>

Also hingenangen und ausprobiert.
Doch zu früh gefreut. Es gibt zwar alle Pfade aus, aber leider nur die tiefstens Pfade. Gibt es z.B. das Verzeichnis /partent mit den Unterverzeichnissen /child_1 und /child_2 gibt die Methode /partent/child_1 und /partent/child_2 aus. Da aber auch im /parten-Verzeichnis Daten sein können, funktioniert das schonmal nicht so, wie wir uns das vorstellen.
(Außerdem werden die Verzeichnisse mit \ ausgeben. Nicht sehr hilfreich.)

Aber nicht nur Romeo&Julia hat ein Happy End. Auch meine Geschichte hat ein gutes Ende. Denn beim weiteren Durchstöbern der PHP-Funktionen fand ich diesen Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php
     function get_leaf_dirs($dir)
      {
         $array = array();
         $d = @dir($dir);
         if($d)
         {
               while (false !== ($entry = $d->read()))
               {
                   if($entry!='.' && $entry!='..')
                   {
                       $entry = $dir.'/'.$entry;
                       if(is_dir($entry))
                       {
                           $subdirs = get_leaf_dirs($entry);
                           if ($subdirs)
                             $array = array_merge($array, $subdirs);
                           else
                             $array[] = $entry;
                       }
                   }
               }
               $d->close();
         }
         return $array;
      }
 
	  $dir = './';
	  print_r(get_leaf_dirs($dir));
?>

..und was soll ich sagen. Ich bin so glücklich. Ich könnte weinen. Aber ich tus nich! Bin ja schließlich nen Mann.

Der nächste Schritt ist also den alten Code anpassen.

So long,
Seb

Was PHP angeht bin ich eine alte  Jungfer. Zwar hab ich schon einen PHP-BOK-Kurs absolviert, aber da war ich mehr körperlich Anwesend (was bei meinem Aussehen durchaus eine Ehre für alle Anwesenden ist).

Doch seit dieser Woche besitze ich WebSpace und der soll nich leer rumliegen. Also habe ich beschlossen eine kleine Internetpräsenz aufzubauen. Wie genau die aussehen soll, weiß ich noch nicht. Aber PHP muss her. Immerhin is das ein guter Anreiz sich endlich mal mit dem ganzen Kram vertraut zu machen.

Da (aus sicherheitstechnischen Gründen) man sich den Index auf dem WebSpace nicht anzeigen lassen kann, aber direkte Pfadeingaben viel zu anstrengend sind, muss eine Indexansicht her.

Glücklicherweise hat der Simon sogar sowas schonmal programmiert. Also fix mal den Quellcode zeigen lassen und anhand dessen eine Indexanzeige geschrieben.

Damit alle etwas davon haben. Hier die einzelnen Teile des Programms:

1
2

$dir = './';
$files = scandir( $dir );

Das Verzeichnis in dem sich die PHP-Datei befindet, wird durchsucht und alle gefundenen Daten werden in ein Array geschrieben. Beispiel:

Array ( [0] => . [1] => .. [2] => directory_1 [3] => index.php)

Zur Übersicht werden alle Dateien die sich in den Verzeichnissen befinden in einer Tabelle dargestellt:

3

echo "<table border="0" cellspacing="0" cellpadding="0">";

Mit einer Schleife wird das Array durchlaufen.

4

for( $i=0; $i<=count($files); $i++ )

Allerdings wollen wir nur die direkten Unterverzeichnisse des aktuellen Verzeichnisses durchsuchen. Daten aus dem aktuellen Verzeichnis sollen nicht angezeigt werden (wie z.B. unsere PHP-Datei, welche die Verzeichnisse durchsucht).

5

if( $files[$i]!="." and $files[$i]!=".." and is_dir($files[$i])==true )

6
7
8
9
10
11
12
13
14

$dir = opendir( "./".$files[$i]."/" );
while( $file = readdir($dir) )
{
	if( substr($file,-3)!="php" and is_dir($file)==false )
	{
		//...
	}
}
closedir($dir);

Mit diesem Abschnitt schließlich öffnen wir die gefundenen Verzeichnisse und suchen dort nach allen Dateien. PHP-Dateien und weitere Verzeichnisse werden nicht berücksichtigt.
Zwar haben wir schon eine Tabelle erstellen, aber damit wir zusätzliche Informationen, wie Größe, Dateityp und Erstellungsdatum sehen können, müssen wir ihm Bauch der IF-Abfrage einige Operationen durchführen.

Es werden zuerst das Erstellungsdatum (Zeile 15) und danach die Dateigröße (Zeile 16 + 17) ermittelt.

15
16
17

$ftime = gmdate("d M Y H:i:s",filemtime("./$files[$i]/$file"));
$fsize = filesize("./$files[$i]/$file");
$fsize = number_format($fsize,0,".",".");

Damit man den Dateityp darstellen kann, muss man (leider, PHP stellt meines Wissens keine Funktion dafür bereit) einen kleinen Trick anwenden.

18
19
20

$fil2 = explode(".", $file);
$end = $fil2[count($fil2)-1];
if($end == $file ) { $end = "";}

Zu guter Letzt schreiben wir alle Daten der Datei in die Tabellenfehler und geben diese aus.

21
22
23
24
25
26
27
28
29

$output = "<tr>
<td><a href='$files[$i]/$file'>$file</a>
<td style='width:50pt'>
<td align=right>$fsize Byte</td>
<td width=\"40\" align =\"right\">$end</td>
<td width=\"175\" align=\"right\">$ftime</td>
</tr>";
 
echo $output;

Dies (Zeile 15 – 29) wird für jedes Verzeichnis durchgeführt. Mit einem

30

echo "</tbody></table>";

schließen wir die Tabelle wieder. Eine so erzeugte Tabelle könnte z. B. so aussehen:

Nicht sehr schön. Aber fürs Erste ausreichend. Verbesserungen kommen dann in späteren Einträgen. Wenn ihr Ideen habt, was eine Indexseite außer Suchen, alle Unterordner, usw. noch können muss, immer her mit den Vorschlägen!

So long,
Seb

Download Code