Vorbereitungen

Im Wesentlichen besteht ein WordPress-Plugin aus einem Ordner im “wp-content/plugins”-Ordner der WordPress-Installation. Der Ordnername sollte dem des Plugins entsprechen. In diesem Ordner legen wir nun eine PHP-Datei, ebenfalls mit dem Plugin-Namen, an. Unser Beispielplugin wird “wp-catpics” heissen, es ergibt sich also folgende Ordnerstruktur innerhalb der WordPress-Installation:

/wp-content/plugins/wp-catpics
/wp-content/plugins/wp-catpics/wp-catpics.php

Besonders wichtig bei WordPress-Plugins sind zunächst die Meta-Informationen zu Beginn der PHP-Datei, die WordPress dem Benutzer bei der Installation anzeigt. Damit PHP diesen Teil der Datei nicht ausführt, werden alle Meta-Informationen in einem PHP-Kommentarblock abgelegt. Die wp-catpics.php sollte also wie folgt beginnen:

/*
Plugin Name: wp-catpic
Plugin URI: http://www.alldeals.de/
Description: Kategorie-Bilder nach Tags einfügen
Author: M.E.
Version: 0.0.1
Author URI: http://www.alldeals.de
*/

Wie ihr seht sind hier wichtige Informationen für WordPress hinterlegt. Neben dem Plugin-Namen und dessen Homepage wird auch eine kurze Beschreibung sowie die Version und URL des Autors angegeben. WordPress liest diese Informationen automatisch aus und bereitet sie für den Benutzer auf.

Bilder in Artikel einfügen

Nachdem wir alle Vorbereitungen für unser Plugin getroffen haben, werden wir nun die eigentliche Funktionalität implementieren. Wir werden diese in eine PHP-Funktion kapseln, warum das sinnvoll ist, werden wir am Ende des Artikels sehen. Fangen wir direkt mit dem Quellcode an, den ich im Anschluss näher erläutern werde:

function add_pics($content)
{
	$d = '/var/www/img/cat/';
	$tags = get_the_tags();

	if(is_array($tags))
	{
		foreach($tags as $tag)
		{
			if ($dh = opendir($d))
			{
				while (($file = readdir($dh)) !== false)
				{
					list($name, $ext) = explode('.', $file);

					if($ext == 'jpg')
					{
						if($name == $tag->name)
						{
							$content = '<img src="/img/cat/'.$file.'" title="'.$tag->name.'" align="left" style="padding-right:8px;padding-top:4px;padding-bottom:8px;"> '.$content;
							closedir($dh);
							return $content;
						}
					}
				}
			}
			closedir($dh);
		}
	}
	return $content;
}

Zunächst legen wir den absoluten Pfad zum Verzeichnis mit unseren Kategoriebildern fest. Diesen benötigen wir, da das Plugin in diesem Ordner nach den passenden Bildern suchen soll. Das Problem lässt sich natürlich auch mit einer Datenbank lösen, doch so ist es wesentlich einfacher. Mit Hilfe der WordPress-Funktion get_the_tags() bekommen wir von WordPress einen Array mit Tag-Objekten. Wir prüfen zunächst ob für den aktuellen Artikel überhaupt Tags vergeben wurden (is_array). Ist dies der Fall iterieren wir durch alle Tags und versuchen für jeden Tag ein passendes Bild zu finden. Da wir pro Artikel lediglich ein einziges Bild einfügen wollen, brechen wir die komplette Funktion beim ersten Treffer ab (Dies ist beim Einsatz des Plugins zu beachten, falls mehrere Bilder möglich sind wählt das Plugin immer den ersten Treffer). Um Treffer zu finden öffnen wir das Verzeichnis mit den Bildern und iterieren hier durch alle Dateien, handelt es sich bei der aktuellen Datei um ein jpg vergleichen wir den Namen des Bildes und den des Tags (selbstverständlich lässt sich das Plugin auch für PNGs oder GIFs umbauen). Sind Name und Tag identisch hängen wir einen passenden IMG-Tag vor den Content und geben diesen zurück. Andernfalls wird das nächste Bild verglichen.
Soweit so gut, doch wie bewegen wir WordPress dazu unsere Funktion zum passenden Zeitpunkt aufzurufen und das auch noch mit dem Inhalt des Artikels als Parameter? Ganz einfach, für solche Anwendungsfällt lassen sich in WordPress so genannte Filter installieren, die die Ausgaben des Blogs vorab filtern und verändern können. In unserem Fall können wir einen solchen Filter wie folgt aktivieren:

add_filter('the_content', 'add_pics');

Im Klartext bedeutet dies das WordPress den Content eines jeden Artikels an die Funktion add_pics übergeben soll. Anschließend wird der Artikel-Content mit dem Rückgabewert der add_pic Funktion ersetzt. Einfach oder? Wenn ihr nun in den Adminbereich eures Blogs schaut, sollte dort euer Plugin auftauchen. Ihr könnt es wie gewohnt aktivieren und deaktivieren.

Abschließende Worte

Die erfahreneren PHP-Programmierer unter euch werden es sicherlich schon gemerkt haben, der Code des Plugins ist nicht perfekt. So wäre es z.B. sinnvoller vorab eine Liste mit den Bilddateien zu erstellen, anstatt jedesmal das Dateisystem zu beanspruchen. Die Plugin-Version, die sich bei mir im Einsatz befindet habe ich bereits entsprechend erweitert. Da ich hier aber gerne die absoluten Grundlagen für die ersten eigenen WordPress-Plugins vorstellen wollte, habe ich mich entschieden diese sehr simple Implementierung zu veröffentlichen. In meinen Augen ist diese ein wesentlich besserer Startpunkt für die WordPress-Plugin-Enwicklung als ein deutlich komplexeres Beispiel. Wer möchte kann seine Verbesserungen aber gerne in den Kommentaren vorstellen. Viel Spaß beim Ausprobieren und Erweitern!

Einem Twitter-User folgen (followen)

Mit der Twitter-API können wir selbstverständlich nicht nur die Liste der Follower und Friends abrufen, sondern diese auch verändern. Zunächst möchte ich die API-Funktion zum Folgen eines anderen Twitter-Users implementieren:

http://twitter.com/friendships/create/(user_id).xml

Über diese URL lassen sich automatisiert Twitter-Freundschaften knüpfen. (user_id) muss hierbei mit der ID des Users ersetzt werden, dem wir folgen wollen. Weiterhin wird diese URL nicht mittels HTTP-Get aufgerufen, sonder als POST-Request realisiert. Dank unserer flexiblen call_twitter Funktion lässt sich dies allerdings sehr einfach durch das zweite, optionale Argument realisieren:

$result = twitter_call("http://twitter.com/friendships/create/".$user_id.".xml", "POST");
if(isset($followers->error))
{
	echo "Anfrage fehlgeschlagen: ".$result->error;
}
else
{
	echo "Freundschaft zu User-ID: ".$user_id." erstellt!";
}

Einen Twitter-Freund entfolgen (unfollow)

Genauso einfach wie das Hinzufügen von neuen Freunden lassen sich diese auch wieder aus dem Twitter-Account entfernen:

$result = twitter_call("http://twitter.com/friendships/destroy/".$user_id.".xml", "DELETE");
if(isset($followers->error))
{
	echo "Anfrage fehlgeschlagen: ".$result->error;
}
else
{
	echo "Freundschaft zu User-ID: ".$user_id." entfernt!";
}

Man beachte den Type-Parameter der twitter_call Funktion, hier setzt die Twitter-API einen DELETE Request-Typ vorraus. Skripts die einen HTTP-Request-Typ DELETE nicht unterstützen können hier allerdings auch einen POST-Request absenden. Es muss allerdings der Parameter “_method=DELETE” an die URL angehängt werden. Da unsere twitter_call Funktion dank cURL auch DELETE-Requests unterstützt verzichten wir an dieser Stelle aber hierauf.

Automatisches Follow- & Unfollow-Skript

Zum Abschluss dieses Teils der Twitter-Serie möchte ich nun aus allen uns bekannten Funktionen ein kleines Autofollow/Autounfollow-Skript erstellen. Da in der Twitter-API die Anzahl der Anfragen pro Stunde für viele Anfragen auf 150 begrenzt ist, muss hier mit bedacht programmiert werden. In unserem Skript werden wir zunächst die Liste unserer Follower und die unserer Freunde von der API abrufen. Mit Hilfe von PHP-Funktionen bestimmen wir dann die Unterschiede der Listen und Löschen danach die Freundschaften zu Usern, die uns nicht folgen. Im Anschluss erzeugen wir Freundschaften zu Usern noch nicht unsere Freunde sind, aber unseren Account bereits folgen. Genug der Worte, hier erstmal der notwendige Quellcode:

$login_info = twitter_call("http://twitter.com/account/verify_credentials.xml");
if(isset($login_info->error))
{
	die("Login fehlgeschlagen: ".$login_info->error);
}
else
{
	$followers = twitter_call("http://twitter.com/followers/ids.xml");
	$friends = twitter_call("http://twitter.com/friends/ids.xml");

	foreach(array_diff($friends, $followers) as $user_id)
	{
		//Entfolge User die uns nicht folgen
		$result = twitter_call("http://twitter.com/friendships/destroy/".$user_id.".xml", "DELETE");
		if(isset($followers->error))
		{
			echo "Anfrage fehlgeschlagen: ".$result->error." (User ID: ".$user_id.")<br>";
		}
		else
		{
			echo "Entfolge: ".$user_id."<br>";
		}
	}
	foreach(array_diff($followers, $friends) as $user_id)
	{
		//Folge Usern denen wir noch nicht folgen
		$result = twitter_call("http://twitter.com/friendships/create/".$user_id.".xml", "POST");
		if(isset($followers->error))
		{
			echo "Anfrage fehlgeschlagen: ".$result->error." (User ID: ".$user_id.")<br>";
		}
		else
		{
			echo "Folge: ".$user_id."<br>";
		}
	}
}

Da der größte Teil des Skripts bereits oben oder in den jeweiligen Teilen dieser Serie vorgestellt wurde, will ich hier nur auf die Neuerungen eingehen. Mit Hilfe der array_diff Funktion ermitteln wir über PHP die Unterschiede zwischen den Array mit den Freunden und dem der Follower. Je nachdem welcher Array als erstes Argument übergeben wird, erhalten wir eine Liste mit den Leuten denen wir folgen bzw. die wir entfolgen wollen. Mit der Foreach-Schleife setzen wir diese dann direkt in die Tat um und Entfernen alle User die uns nicht folgen aus unserer Freundesliste. Danach werden die Leute, die uns folgen zu unserer Freundesliste hinzugefügt. Zwar kann dieses Vorgehen auch das Twitter-Rate-Limit überschreiten, durch den Vergleich der Arrays werden allerdings sehr viele zeitintisive Abfragen gegenüber einer herkömmlichen Implementierung eingespart (herkommlich würde in diesem Fall bedeuten zunächst alle Freunde abzurufen und dann für jeden Freund mit Hilfe einer Abfrage zu Prüfen ob dieser in unserer Freundesliste ist).

Soviel zu dritten Teil der Twitter-Serie, heute haben wir zum ersten Mal ein mehr oder weniger sinnvolles Skript für die Twitter-API auf die Beine gestellt. Alle Leute die (wie ich) ihre Twitter-Zugangsdaten ungerne auf den diversen Twitter-Tools Webseiten eingeben können somit die beliebteste Funktion direkt auf dem eigenen Server realisieren. Alle anderen lernen hoffentlich etwas für eigene Twitter-Skripte, falls ihr eigene Skripte oder Ergebnisse vorweisen könnt postet gerne in den Kommentaren.

Twitter Follower

Um die Twitter-Follower eines Accounts über die API abzurufen genügt eine simple Anfrage mit Hilfe der twitter_call Funktion. Der Aufruf liefert aber lediglich die User-IDs aller Follower zurück. Selbstverständlich muss vor der Abfrage die Authentifizierung gegenüber der Twitter-API erfolgen. Wie das geht könnt ihr dem ersten Teil dieser Serie entnehmen.

$followers = twitter_call("http://twitter.com/followers/ids.xml");
if(isset($followers->error))
{
	echo "Anfrage fehlgeschlagen: ".$followers->error;
}
else
{
	echo count($followers->id)." Follower gefunden!";
}

Dank der XML-Umwandlung mit simple_xml, die bereits von der twitter_call Funktion durchgeführt wird, erhalten wir direkt einen Array mit den Benutzer-IDs, den wir z.B. mit Hilfe einer foreach-Schleife durchlaufen können. Falls ihr mehr Informationen über die einzelnen Follower benötigt, so könnt ihr selbstverständlich auch die User-Details über die API abfragen:

echo "<table><tr><td>ID</td><td>Picture</td><td>Username</td><td>Location</td></tr>";

foreach($followers->id as $id)
{
	$user_info = twitter_call("http://api.twitter.com/1/users/show.xml?user_id=".$id);
	echo "<tr>";
	echo "<td>".$user_info->id."</td>";
	echo "<td><img src='".$user_info->profile_image_url."'></td>";
	echo "<td>".$user_info->screen_name."</td>";
	echo "<td>".$user_info->location."</td>";
	echo "</tr>";
}
echo "</table>";

Der Beispielcode stellt hierbei die Informationen zu allen Followern in einer kleinen Tabelle dar. Zu beachten ist jedoch, dass Twitter die Anzahl der Anfragen an seine API begrenzt. Aktuell sind 150 Anfragen pro Stunde und Account erlaubt, was bei vielen Followern allerdings schnell überschritten werden kann. Auch die php.ini kann durch max_execution_time zum Problem werden, wenn viele Anfragen sehr lange dauern.

Twitter Friends

Um die Leute zu ermitteln, denen man selbst folgt, kann analog zum obigen Beispiel vorgegangen werden. Lediglich die URL der API ändert sich für den Aufruf:

$friends = twitter_call("http://twitter.com/friends/ids.xml");
if(isset($friends->error))
{
	echo "Anfrage fehlgeschlagen: ".$followers->error;
}
else
{
	foreach($friends->id as $id)
	{
		echo count($friends->id)." Freunde gefunden!";
	}
}

Auch hier gibt Twitter ein Array mit den IDs der Freunde zurück, dass wie oben durch eine foreach-Schleife durchlaufen werden kann. Soviel zu den Twitter Freunden und Followern, im nächsten Teil der Serie werde ich näher auf die Suche und das automatische Followen bzw. Unfollowen eingehen. Zusammen mit den heute vorgestellten Funktionen lassen sich dann bereits mächtige Twitter-Werkzeuge mit PHP erstellen. In einem der letzten Teile der Serie werden wir beispielhaft auch ein solches erstellen, also schaut wieder rein!

Die Twitter-API im Überblick

Die Twitter-API lässt sich in unterschiedlichen Formaten ansprechen, zur Auswahl stehen XML, JSON und RSS. Leider ist nicht jede Methode auch in allen drei Formaten verfügbar, aber alle drei lassen sich mit Hilfe von PHP sehr einfach weiterverwenden. Abgewickelt werden alle API-Anfragen über HTTP Requests. Hierbei kommen sowohl GET- als auch POST-Anfragen zum Einsatz. Weiterhin ist der Zugriff auf viele Methoden an das Vorhandensein eines Twitter-Accounts gebunden, deren Benutzername und Passwort bei der Anfrage mit übergeben werden. Grundsätzlich benötigen alle Methoden eine Authentifizierung, die sich mit Informationen eines Twitter-Accounts beschäftigen (z.B. das Abrufen von Followern oder der Timeline). Die Twitter-API Dokumentation findet ihr übrigens unter http://apiwiki.twitter.com/

Vorbereitungen

Der Einfachheit halber werden wir für die HTTP-Anfragen an die Twitter-Server die cURL Bibliothekt, die standardmäßig als Modul in PHP integriert ist. Selbstverständlich wäre es auch möglich die bereits an anderer Stelle präsentierten HTTP-GET Requests dafür zu verwenden. Da sämtliche Interaktion mit der Twitter-API über solche Anfragen abgewickelt wird, bietet es sich an den Code für die Kommunikation als eigene Funktion zu erstellen. In einem späteren Artikel dieser Serie werden wir die so erstellten Funktionen dann in eine eigene Twitter-Klasse kapseln. Vorerst werden wir uns allerdings mit einfachen Funktionen begnügen. Die Funktion für generelle Twitter-API-Anfragen sieht wie folgt aus:

define('TWITTER_USER', 'user');
define('TWITTER_PASS', 'passwort');

function twitter_call($url, $type='GET')
{
   //cURL Handle erzeugen
   $ch = curl_init();

   //Festlegen ob ein GET- oder POST-Request gesendet wird
   curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $type);

   //URL festlegen
   curl_setopt($ch, CURLOPT_URL, $url);

   //Daten als String zurückgeben und nicht direkt an den Browser senden
   curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 

   //Login-Informationen setzen
   curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
   curl_setopt($ch, CURLOPT_USERPWD, TWITTER_USER.":".TWITTER_PASS);

   //URL aufrufen und XML interpretieren
   $data = simplexml_load_string(curl_exec($ch));

   //Resourcen freigeben
   curl_close($ch);

   return $data;
}

Zur Verwendung von cURL wird mit der init-Methode zunächst ein Handle erstellt, sämtliche Einstellungen können im Folgenden in diesem Handle gespeichert werden. Sollen unterschiedliche Anfragen erstellt werden, können z.B. mehrere Handles erstellt werden. Mit Hilfe des curl_setopt Befehls lassen sich dann die angesprochenen Einstellungen vornehmen. Wir wählen zunächst einen Anfragetyp (GET oder POST) und wählen als Rückgabetyp die String-Ausgabe um diese an eine Variable zu übergeben (andernfalls würde cURL die Daten direkt an den Browser ausgeben). Im Anschluss werden dann Benutzername und Passwort gesetzt bevor der Befehl dann abgesetzt wird. Sollen viele Anfragen parallel durchgeführt werden, ist es unbedingt zu empfehlen das die durch cURL belegten Resourcen mit curl_close wieder freigegeben werden. Aufmerksamen Lesern wird aufgefallen sein das wir mit dieser Funktion immer die Benutzerdaten übergeben obwohl ich oben erwähnt habe, dass nicht alle Twitter-Funktionen diese Daten benötigen. Dies ist durchaus richtig, allerdings nimmt uns Twitter das nicht übel – So lange die Daten korrekt sind, wenn sie vorrausgesetzt werden.

Der erste Kontakt

Jetzt wo die Funktion für die Kommunikation mit Twitter bereits fertig ist, möchten wir nun erstmals Kontakt zur Twitter-API herstellen. Hierzu verwenden wir die oben erstellte Funktion:

$login_info = twitter_call("http://twitter.com/account/verify_credentials.xml");

if(isset($login_info->error))
{
   echo "Login fehlgeschlagen: ".$login_info->error;
}
else
{
   echo "Login erfolgreich!<br>";
   echo "Name: ".$login_info->name."<br>";
   echo "Twitter Name: ".$login_info->screen_name."<br>";
   echo "Ort: ".$login_info->location."<br>";
   echo "Info: ".$login_info->description."<br>";
}

Zunächst sendet das obige Programm eine Anfrage an die verify_credentials.xml auf dem Twitter-Server. Die Dateiendung .xml gibt hierbei übrigens das Rückgabeformat an, wollten wir die Daten im JSON-Format erhalten, so würde einfach .json als Endung verwendet. Ob der Login erfolgreich war, lässt sich über das error-Objekt herrausfinden. Dieses enthält die jeweilige Fehlermeldung wenn ein Fehler aufgetreten ist. Ist die Anfrage erfolgreich verlaufen existiert kein error-Objekt und Twitter liefert und umfangreiche Informationen zum verwendeten Account. Zu Demonstrationszwecken gibt das Skript einige hiervon an den Benutzer aus.

Ausblick

Heute haben wir die Grundlagen für die Verwendung der Twitter-API mit PHP geschaffen. Durch die flexible twitter_call-Methode müssen wir uns in den nächsten Teilen dieser Serie nicht mehr mit der reinen Kommunikation beschäftigen, sondern können direkt neue Twitter-Funktionen in unser Programm einbauen. Im zweiten Teil der Serie werde ich zeigen wie sich die eigene Timeline, Follower und Friends des eigenen Twitter-Accounts auslesen lassen. Bald gehts weiter, stay tuned…

Auf der Startseite listet der Appfuchs weiterhin alle aktuellen Änderungen im Appstore auf, beobachtet man diese Daten einige wird einem auch schnell bewusst wie viel sich im Appstore Tag für Tag ändert. Die aktuellen Charts für alle Kategorien und Unterkategorien sind selbstverständlich auch dabei. Eine umfangreiche Detailsuche erleichtert außerdem das Auffinden von neuen, interessanten Apps. Für die Zukunft habe ich natürlich noch eine Menge Erweiterungen auf dem Zettel, bis dahin schaut euch die aktuelle Version doch schon einmal an. Über Feedback würde ich mich freuen!

Lange Rede kurzer Sinn: Nach langem Probieren bin ich auf eine Lösung gestossen, die das Problem bei mir sofort behoben hat. Daher möchte ich sie an dieser Stelle mit allen Leidgenossen teilen, damit das Überwinden des inneren Schweinehunds nicht unnötig erschwert wird. Und so gehts:

1) In den iPhone Einstellungen unter Nike+ die Sprachausgabe komplett deaktivieren
2) Einstellungen beenden und das iPhone komplett ausschalten
3) Wenn das iPhone komplett abgeschaltet ist könnt ihr es erneut einschalten
4) Jetzt wieder unter Einstellungen -> Nike+ das Voice-Feedback (Sprachausgabe) aktiveren
5) Viel Spaß beim Training mit Motivation auf Knopfdruck!

Sollte die Lösung bei euch funktionieren würde ich mich über einen kleinen Kommentar freuen. Falls nicht könnt ihr auch gerne posten wie ihr das Problem in den Griff bekommen habt.

Das Formular

Für den Upload von Dateien durch den Besucher ist zunächst ein spezielles HTML Formular notwendig, dass das Hochladen von Dateien unterstützt. Im Prinzip unterscheidet es sich nicht groß von anderen Formularen, die ihr sonst so benutzt, aber der Teufel steckt wie immer im Detail:

<form action="upload.php" method="post" enctype="multipart/form-data">
Datei hochladen: <input type="file" name="meine_datei">
<inpupt type="submit" value="Hochladen>
</form>

Der einzige Unterschied zu normalen Formularen ist hier der zusätzliche Parameter „enctype“, der dem Browser mitteilt, wie er die angehängten Daten für die Übertragung kodieren soll. Damit der Benutzer komfortabel eine Datei von seinem System auswählen kann, verwenden wir außerdem ein Input vom Typ „file“, der im Browser einen Dialog zum Auswählen der Datei zur Verfügung stellt.

Ein erster Datei-Upload

Nun brauchen wir noch etwas PHP Code um die Daten vom Formular zu verarbeiten und die Datei abzuspeichern. Hierfür existiert bei PHP die Funktion move_uploaded_file(), die zum einen Prüft ob es sich wirklich um eine hochgeladene Datei handelt und diese dann in einen Ordner unserer Wahl verschiebt. Da der Rückgabewert vom Typ bool ist, können wir den Aufruf direkt in eine if-Abfrage einbauen:

<?
$dir = getcwd().'/files';

if($_FILES['datei_upload']['size'] > 0)
{
	if(move_uploaded_file($_FILES['datei_upload']['tmp_name'], $dir.$_FILES['datei_upload']['name']))
	{
		echo "Der Upload der Datei war erfolgreich!";
	}
	else
	{
		echo "Irgendwas stimmt hier nicht, Upload nicht erfolgreich!";
	}
}
else
{
	?>
		<form action="upload.php" method="post" enctype="multipart/form-data">
		Datei hochladen: <input type="file" name="datei_upload">
		<inpupt type="submit" value="Hochladen>
		</form>
	<?
}
?>

Das Beispiel prüft also zunächst ob eine Datei größer 0 Byte übertragen wurde. Ist dies nicht der Fall wird unser Upload-Formular angezeigt. Andernfalls versucht das Skript die hochgeladene Datei in den Ordner „files“ zu verschieben. Hierzu muss dieser natürlich existieren und PHP muss Schreibrechte auf diesen besitzen (CHMOD 777). Hat alles geklappt findet ihr eure hochgeladene Datei nach dem Upload in diesem Verzeichnis.

Informationen über hochgeladene Dateien

PHP stellt uns zu jeder hochgeladenen Datei einige Informationen zur Verfügung, diese befinden sich im Array $_FILES. Über den Index wird hier die gewünschte Datei ausgewählt, da durchaus auch mehrere Dateien gleichzeitig hochgeladen werden können. Den Namen der Datei im Array legt man über den Namen des File-Input-Elements im Formular fest und in unserem Fall ist das „datei_upload“.
Hier eine kleine Übersicht über die verfügbaren Informationen zu den hochgeladenen Dateien im $_FILES Array:

$_FILES['datei_upload']['name']		Ursprünglicher Dateiname auf dem Rechner des Benutzers
$_FILES['datei_upload']['type']		Mime-Type der Datei, wenn der Browser ihn zur Verfügung stellt
$_FILES['datei_upload']['size']		Dateigröße in Bytes
$_FILES['datei_upload']['tmp_name']	Temporärer Dateiname zum Zugriff auf die Datei nach dem Upload
$_FILES['datei_upload']['error']	Fehlercode, wenn beim Upload ein Problem auftritt

Wichtig hierbei ist, dass der Mime-Type vom Browser des Clients übertragen wird. Das ist ja eigentlich sehr praktisch, aber leider übertragen wieder nicht alle Browser diese Information oder sie könnte vom Besucher absichtlich manipuliert worden sein. Daher sollte man sich nicht auf den Mime-Type im $_FILES Array verlassen. Für die Verarbeitung von Bildern empfiehlt es sich vielmehr die Funktion GetImageSize() zu verwenden, die unter Anderem auch den Mime-Type der Datei bestimmt.

Datei-Upload mit Einschränkungen

In der Praxis wollen wir aber sicherlich nicht jede beliebige Datei akzeptieren und müssen daher einige zusätzliche Einschränkungen implementieren, die aus den hochgeladenen Dateien diejenigen auswählen, die unseren Kriterien entsprechen. Das folgende Beispiel zeigt einige der Möglichkeiten, die häufig benötigt werden:

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

if($_FILES['datei_upload']['size'] > 0)
{
	if($_FILES['datei_upload']['size'] < 100000)
	{
		$info = GetImageSize($_FILES['datei_upload']['tmp_name']);

		if($info[2] != 0)
		{
			if($info[0] == 100 && $info[1] == 150)
			{
				if(move_uploaded_file($_FILES['datei_upload']['tmp_name'], $dir.$_FILES['datei_upload']['name']))
				{
					echo "Der Upload der Datei war erfolgreich!";
				}
				else
				{
					echo "Irgendwas stimmt hier nicht, Upload nicht erfolgreich!";
				}
			}
			else
			{
				echo "Bitte laden Sie nur Bilder mit einer Größe von 100x150 Pixeln hoch!";
			}
		}
		else
		{
			echo "Bitte laden Sie nur Bilder vom Typ .gif .jpg oder .png hoch!";
		}
	}
	else
	{
		echo "Die Maximalgröße für Uploads liegt bei 100kB";
	}
}
else
{
	?>
		<form action="upload.php" method="post" enctype="multipart/form-data">
		Datei hochladen: <input type="file" name="datei_upload">
		<inpupt type="submit" value="Hochladen>
		</form>
	<?
}

Die Funktion GetImageSize() liefert uns einen Array mit der Breite (Index 0), Höhe (Index 1) und dem Mime-Type (Index 2) des Bildes. Ist der Mime-Type gleich Null, so handelt es sich um kein (bekanntes) Bildformat (1 – GIF, 2 – JPG, 3 – PNG). Über den Array können wir so einschränken welche Bildgröße und Bildtypen erlaubt sind. Weiterhin prüfen wir mit dem $_FILES Array ob die Dateigröße unter 100kByte liegt. Ist einer der Werte nicht innerhalb unserer Vorgaben, so wird eine einfache Fehlermeldung ausgegeben.

Sicherheitsaspekte

Wie immer noch einige Worte zur Sicherheit: Bitte seid euch immer bewusst, dass ihr im Zweifelsfall fremden Leuten gestattet Dateien auf eurem Webserver abzulegen. Wenn möglich sollte kein direkter Zugriff auf den Upload-Ordner vom Internet aus bestehen oder dieser mit einem htaccess Passwort geschützt werden. Gelingt es einem Angreifer eine PHP Datei hochzuladen und über den Browser auf diese zuzugreifen, so hat er kompletten Zugriff auf euren Webspace. Daher immer alle Dateien sehr genau prüfen und am besten keinen direkten Zugriff auf hochgeladene Daten ermöglichen. Ist ein Zugriff zwangsläufig notwendig, so bietet es sich an den Zugriff selbst auch wieder über ein PHP-Skript zu gewährleisten, dass zusätzliche Sicherheit bietet. Eventuell schreibe ich hierzu in Zukunft auch nochmal einen Artikel.

Bis dahin viel Spaß mit den Dateiuploads!

Einfach nur Mailen

Wie eingangs erwähnt bringt PHP von Haus aus eine Funktion für den Emailversand mit, die PHP mail() Funktion:

bool mail(string $an, string $betreff, string $text);

Wie ihr seht ist der Umgang mit der Mail Funktion sehr einfach. Ein Aufruf genügt und schon versendet PHP das Email für euch an die angegebene Adresse. Emails an mehrere Empfänger sind auch kein Problem, es können mehrere Adressen an die Funktion über-geben werden, wenn die Adressen durch ein Komma getrennt werden. Da der Rückga-betyp bool ist, können wir auch direkt in einer if-Abfrage prüfen ob der Versand erfolg-reich war:

if(mail("user@email.de", "Testnachricht", "Hallo! Dies ist ein Test!"))
{
	echo "Nachricht erfolgreich versendet!";
}
else
{
	echo "Das Senden der Nachricht ist fehlgeschlagen!";
}

Wenn ihr euch mit dem obigen Skript mal ein Email sendet, wird euch aber schnell auf-fallen, dass z.B. der Absender etwas abenteuerlich ausschaut. Wie genau ist von Fall zu Fall unterschiedlich, da der Standardabsender von der Serverkonfiguration abhängt. Damit wollen wir uns aber natürlich nicht zufrieden geben und daher bietet die mail() Funktion eine Möglichkeit eine eigene Absenderadresse festzulegen. Leider ist dies nicht so einfach wie wir es sonst von PHP gewöhnt sind, aber kompliziert ist es auch nicht.

Eigene Absender festlegen

Die mail() Funktion bietet für einen optionalen Parameter an, mit dem sich bestimmte Header-Einstellungen für das Email umsetzen lassen. Hierrüber lässt sich der Absender, die Antwortadresse und vieles mehr einstellen:

$header = 'From: mirko@phpmail.de' . "\r\n" .
	  'Reply-To: kai@javamail.com' . "\r\n";

if(mail("user@email.de", "Testnachricht", "Hallo! Dies ist ein Test!", $header))
{
	echo "Nachricht erfolgreich versendet!";
}
else
{
	echo "Das Senden der Nachricht ist fehlgeschlagen!";
}

Das Beispielskript versendet nun ein Mail von der Adresse mirko@phpmail.de, da dies durch den „From“ Eintrag im Header festgelegt wird. Jedes Feld im Header muss durch einen doppelten Zeilenumbruch mit „\r\n“ abgeschlossen werden, wie wir es schon von unseren Headern bei den http Requests gelernt haben. Klickt der Empfänger jetzt auf Antworten um auf unser Email zu antworten, so wird sein Emailprogramm eine Antwort an kai@javamail.com senden. Dies lässt sich über den Header-Eintrag Reply-To festlegen. Dies sind nur zwei der vielen Möglichen Einstellungen für die Email-Header, aber es sind sicherlich die wichtigsten.

Sicherheitsaspekte

Die einfache Anwendung der mail() Funktion ist gleichzeitig auch ihre große Schwäche. Nur zu leicht kann man durch schlecht programmierte Skripte Spammern ein perfektes Werkzeug in die Hand geben um den eigenen Server zum Versenden von tausenden von Emails zu verwenden. Daher möchte ich an dieser Stelle ganz besonders auf einige wichtige Aspekte bei der Verwendung der mail() Funktion hinweisen:

1) Wenn die Empfängeradresse eine Benutzereingabe in eurem Skript ist, so solltet ihr diese sehr genau prüfen. So wie ihr Emails an mehrere Empfänger versenden könnt, so kann es auch jeder Besucher eurer Webseite, indem er mehrere Adres-sen durch ein Komma trennt.

2) Solltet ihr Benutzereingaben im Headerfeld zulassen, z.B. um eine Absenderad-resse zu ermöglichen, so solltet ihr noch vorsichtiger sein. Kann der Benutzer beliebigen Text in den Header einfügen, so ist es mögliche das Email komplett zu verändern. Über den Header können rein theoretisch auch Anhänge oder ein neuer Nachrichtentext realisiert werden.

Viele Server erlauben heutzutage zwar keine Absenderadressen für Domains mehr, für die sie nicht zuständig sind, jedoch kann man sich darauf nicht verlassen. Ich empfehle daher möglichst viele Parameter der Mail-Funktion statisch selbst vorzugeben. Wollt ihr z.B. ein Kontaktformular erstellen, dann muss die Emailadresse des Benutzers ja nicht unbedingt die Absenderadresse des Emails sein. Ihr könnt sie auch in den Nachrichten-text einbauen und somit zumindest Benutzereingaben im Headerbereich der Email ver-meiden.
Ein erster Schritt um wenigstens eine gewisse Grundsicherheit zu erreichen ist das Er-setzen der Steuerzeichen für Header und Adressen:

$benutzer_an = str_replace(',', '', $benutzer_an);
$benutzer_header = str_replace("\n", '', $benutzer_header);
$benutzer_header = str_replace("\r", '', $benutzer_header);

Selbstverständlich müssen die Ersetzungen nur auf die Benutzereingaben angewendet werden und nicht auf den gesamten Header. Andernfalls würden durch das Ersetzen auch die von uns gewünschten Einstellungen unwirksam.

Welche Sicherheitsmaßnahmen im Einzelfall noch nötig sind, muss separat geprüft werden, aber mit den oben genannten Ersetzungen wird schon einmal das schlimmste verteilt und man macht es einem möglichen Angreifer nicht all zu leicht.

Soviel zur PHP mail() Funktion, für anspruchsvollere Aufgaben im Bereich des automa-tisierten Mailings werde ich in nächster Zeit noch eine Email-Klasse vorstellen, die auch gut mit HTML Emails oder Anhängen zu recht kommt und ebenfalls sehr einfach zu bedienen ist. Bis dahin, viel Spaß mit der mail() Funktion!

Das Generieren von Passwörtern ist vor allem dort notwendig, wo sich z.B. neue Benutzer registrieren können und zunächst ein beliebiges Passwort gesetzt werden soll. Beliebig ist hierbei allerdings relativ, denn natürlich sollte das Passwort jedesmal unterschiedlich sein und gewissen Anforderungen an die Passwortlänge und die erlauben Zeichen genügen. Schließlich wollen wir unsere Benutzer nicht mit Passwörtern aus lauter Sonderzeichen vergraulen.

Hier nun vorab einmal das Skript, ich werde im Anschluss kurz auf die Besonderheiten eingehen:

function generatePassword($pwlen=5)
{
	mt_srand();
	$salt = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

	for($i=0;$i<$pwlen;$i++)
	{
		$pw .= $salt[mt_rand(0, strlen($salt)-1)];
	}

	return $pw;
}

Die obige Funktion generiert euch also zufällige Passwörter. Die Passwortlänge kann hierbei als Parameter übergeben werden, standardmäßig werden Passwörter mit fünf Zeichen erstellt. Die für die Passwörter zulässigen Zeichen können einfach in die Variable $salt mit eingetragen werden. Das Skript initialisiert zunächst den Zufallsgenerator, allerdings wäre es besser dies ganz zu Anfang der index.php zu erledigen und die Initialisierung aus der Funktion selbst zu entfernen. Da dann dieses Beispiel aber nicht so ohne Weiteres überall funktionieren würde, habe ich mich für diesen (nicht ganz optimalen) Weg entschieden.

Nach der Initialisierung wird die for-Schleife so oft durchlaufen, bis die gewünschte Passwortlänge erreicht wurde. Bei jedem Durchlauf wird hierbei ein zufälliges Zeichen aus der $salt Variable ausgewählt und an den $pw String angehängt, der später das generierte Passwort enthält, das zurückgegeben wird. Der Trick ist hierbei, dass die $salt Variable als Array aufgefasst werden kann um das gewünschte Zeichen zu extrahieren.

Viel Spaß beim Verwenden und Erweitern!

Zunächst möchte ich jedoch einen kleinen Trick für iPhone-Besitzer loswerden, die ein iPhone mit Jailbreak auf die neue Firmware 3.0 upgedated haben. Alternativ funktioniert der Trick auch wenn man ein Backup von einem iPhone 2G oder 3G auf ein 3GS einspielen will. Benutzt man, wie ich, ein Tool um nicht verwendete Apps zu verstecken (z.B. BossPrefs oder Categories) auf seinem Jailbreak iPhone und vergisst das Ausblenden vor einem Firmware-Update rückgängig zu machen, so sind die Apps auch nach dem Update unsichtbar. Eigentlich kein Problem möchte man meinen, die neue Firmware Jailbreaken, BossPrefs installieren und die Apps wieder sichtbar machen. Allerdings steht man vor einem Problem, wenn es noch keinen Jailbreak gibt (so wie für das aktuelle 3GS). Also habe ich die letzte Woche ohne SMS App verbracht, was manchmal ganz schön ärgerlich sein kann. Folgender Trick löst das Problem schnell und einfach, ohne Restore oder Jailbreak…

1. Unter Einstellungen -> Allgemein -> Einschränkungen gehen
2. Die Einschränkungen aktivieren
3. Pin festlegen
4. Pin bestätigen
5. Einstellungen beenden (Home Taste)
6. Wieder Einstellungen -> Allgemein -> Einschränkungen aufrufen
7. Einschränkungen deaktivieren (Pin eingeben)
8. Einstellungen beenden (Home Taste)

Und schon sollten wieder alle Apps sichtbar sein. Scheinbar realisiert Apple seinen Jugendschutz ebenfalls über das Ausblenden von Apps auf dem iPhone und beim Deaktivieren der Einschränkungen werden einfach alle Apps wieder auf sichtbar gestellt (auch wenn diese garnicht ausgeblendet wurden). Im Gegensatz zu machen anderen Methoden gehen hier keinerlei Einstellungen verloren und das Ganze funktioniert auch ohne Jailbreak.

Falls der Trick bei euch auch funktioniert (oder halt auch nicht) würde ich mich über einen Kommentar freuen – Happy Unhiding!