Die Ausgabe sieht dann beispielsweise so aus:

us: 00.9900%
ni: 00.0000%
sy: 00.4950%
id: 98.5148%

Die nachfolgende PHP-Klasse erzeugt eine zufällige Adresse. Dazu werden die Textdateien benötigt, in welchen ich in Handarbeit Namen, Straßennamen sowie Postleitzahlen und Orte (unabhängig voreinander) zusammengesammelt habe. Aus diesem Pool generiert die PHP-Klasse einen zufällige Namen mit Postanschrift.

Bei diesen so erzeugten Adressen paßt jeweils die Postleitzahl auch zum Ort. Möchte jemand die Echtheit einer solchen Fake-Adresse überprüfen bzw. feststellen ob dies ein Fake ist, bräuchte er eine gute Datenbank über alle Straßennamen vor Ort bzw. echte Adressdaten zum Abgleich. Es läßt sich also mit hoher Wahrscheinlichkeit nicht technisch feststellen, ob es sich um eine echte Adresse handelt. Natürlich wird es auch seltene Fälle geben wo die Person und deren Adresse wirklich stimmt. Das bleibt allerdings dem Zufall überlassen.

Folgende Datensätze sind enthalten

• 1249 männliche Vornamen
• 1695 weibliche Vornamen
• 3421 Nachnamen
• 7275 Straßennamen
• 13749 (deutsche) Ortsnamen mit Postleitzahl

Damit sind rein rechnerisch ~1.000.000.000.000.000 verschiedene Personen generierbar, wenn man die Hausnummern noch nicht einmal in die Rechnung mit einbezieht.

Bei den Vor- und Nachnamen habe ich versucht darauf zu achten, dass sie nicht all zu exotisch sind. Ich hoffe es ist gelungen. Wer die Daten einsetzt, sollte prüfen ob sein Namen darin vorkommt und ihn nötigenfalls nachtragen.

Lizenz gibt es keine – macht damit was ihr wollt. Ich würde mich allerdings über einen Link auf meine Seite freuen.

• Testseite ansehen
• Download PHP-Klasse (inkl. Daten)
• Adressgenerator als CSV exportieren

Viel Spaß beim Spielen ;)

Quellcode der PHP-Klasse

<?php
 
class Adresse {
 
    // Dateien sind in uft-8
    var $fileVornamenFrau    = './vornamen_frau.txt';
    var $fileVornamenMann    = './vornamen_mann.txt';
    var $fileVornamenEgal    = './vornamen_egal.txt';
    var $fileNachnamen        = './nachnamen.txt';
    var $fileStrassen        = './strassen.txt';
    var $filePlzOrt            = './plz-ort.txt';
 
    // $geschlecht=0 -> egal
    // $geschlecht=1 -> Mann
    // $geschlecht=2 -> Frau
    // return array
    function get($geschlecht=0) {
        return array(
            'vorname'=>$this->getVorname($geschlecht),
            'nachname'=>$this->getNachname(),
            'strasse'=>$this->getStrasse(),
            'nummer'=>$this->getHausnummer(),
            'ort'=>$this->getPlzOrt()
        );
    }
 
    // $geschlecht=0 -> egal
    // $geschlecht=1 -> Mann
    // $geschlecht=2 -> Frau
    // return string
    function getHTML($geschlecht=0) {
        return '<address>'."\n".
             $this->getVorname($geschlecht).' '.$this->getNachname().'<br />'."\n".
            $this->getStrasse().' '.$this->getHausnummer().'<br />'."\n".
            $this->getPlzOrt()."\n".
            '</address>'."\n";
    }
 
    /* ---------------------------------- internal -------------------------------------- */
 
    // $geschlecht=0 -> egal
    // $geschlecht=1 -> Mann
    // $geschlecht=2 -> Frau
    // return string
    function getVorname($geschlecht=0) {
        switch ($geschlecht) {
            case 1:
                return $this->_getRandomLine($this->fileVornamenMann);
                break;
            case 2:
                return $this->_getRandomLine($this->fileVornamenFrau);
                break;
            default:
                return $this->_getRandomLine($this->fileVornamenEgal);
        }
    }
 
    // return string
    function getNachname() {
        return $this->_getRandomLine($this->fileNachnamen);
    }
 
    // return string
    function getHausnummer($min=1,$max=99) {
        $result = rand($min,$max);
        if (rand(0,100)<=20) {
            // fügt mit 20% Wahrscheinlichkeit 
            // einen Buchstaben zur Nummer hinzu
            $buchstaben = array('a','b','c');
            $result .= $buchstaben[rand(0,(count($buchstaben)-1))];
        }
        return $result.'';
    }
 
    // return string
    function getStrasse() {
        return $this->_getRandomLine($this->fileStrassen);
    }
 
    // return string
    function getPlzOrt() {
        return $this->_getRandomLine($this->filePlzOrt);
    }
 
    // return string
    function _getRandomLine($file) {
        $list = @file($file);
        if (!is_array($list) || count($list) < 1) return false;
        return trim($list[rand(0,(count($list)-1))]);
    }
}
 
?>

ata3.00: cmd c8/00:08:43:c6:c1/00:00:00:00:00/e0 tag 0 cdb 0x0 data 4096 in
res 51/40:08:43:c6:c1/00:00:00:00:00/e0 Emask 0x9 (media error)

Kurz darauf crashte der Rechner komplett. Nach einem Hardreset bootet der Rechner auch nicht mehr. Also Festplatte hinüber.

Ran an die Datenrettung. Als Erstes habe ich von einer Knoppix-CD gebootet. Hier ist zu beachten das einige Knoppix-CDs erkannte Swap-Partitionen automatisch mounten. Dies sollte man unbedingt per Bootparameter verhindern, sonst wird womöglich die defekte Platte gleich wieder benutzt. Auch benötigt man die grafische Oberfläche nicht, also startet man Knoppix am Bootprompt am besten mit

knoppix 2 noswap

Also Knoppix hochgefahren war, habe ich als Nächstes erst einmal mit

smartctl -a /dev/sda

die defekte Platte untersucht. (komplettes Log). Der Wert Current_Pending_Sector, welcher die defekten Sektoren angibt, war meiner Meinung nach auffällig hoch.

Ein anschliessendes

badblocks -v /dev/sda

bestätigte dies und lieferte jede Menge defekte Sektoren zurück (ca. 200). Bis auf eine Partitionen konnte ich alle mounten und die Daten sichern. Eine XFS-Partition war jedoch nicht mehr zum Mounten zu bewegen. (Defekter Superblock?)

Ein Reparaturversuch direkt auf der defekten Platte kam für mich nicht in Frage. Also benutze ich benutze dd_rescue um diese Partition als Image auf meinem Raid (gemountet unter /RAID) auszulesen.

dd_rescue /dev/sda5 /RAID/sda5.img

Das kann je nach Partitionsgröße eine ganze Weile dauern. Es sollte natürlich entsprechend Platz auf dem Ziellaufwerk vorhanden sein. Anschliessend habe ich das Image kopiert um den Reparatur-Versuch abzusichern.

cp /RAID/sda5.img /RAID/sda5.img.org

Anschliessend ein

xfs_repair /RAID/sda5.img

Es gab keine Fehlermeldungen und ich konnte anschliessend das Image mounten und die Daten darauf sichern.

mount -o ro,loop /RAID/sda5.img /mnt/...

Anschliessend habe ich mir erstmal ein Bier gegönnt und so das Überleben meiner Daten gefeiert. ;)

Hier ein einfacher FIFO-Cache in LSL (Linden Scripting Language) mit dem es möglich ist ankommende Daten zwischenzuspeichern um sie später sequenziell abzuarbeiten. Sinnvoll ist soetwas überall dort wo es durch Ereignisse (z.B. Benutzereingaben oder Sensoren) recht schnell viele Daten entstehen können, die man jedoch (durch Beschränkungen in LSL) nur relativ langsam abarbeiten kann. Man schafft sich damit einen Buffer bei “Lastspitzen”.

Je nach Datentyp muss das Script entsprechend angepaßt werden, dieses Beispiel ist für Keys.

list LIST_KEYS;
 
addCache(key uuid) {
     integer found = llListFindList(LIST_KEYS, [uuid]);
     if (found < 0) {
         LIST_KEYS += [uuid];
     }
}
 
key getCache() {
    if (llGetListLength(LIST_KEYS)) {
        key result = llList2Key(LIST_KEYS,0); 
        LIST_KEYS = llDeleteSubList(LIST_KEYS, 0, 1);
        return result;
    } else {
        return NULL_KEY;
    }
}


Die Benutzung ist recht einfacht. Mit addCache(key) wird ein Key in den Cache geschrieben und mit getCache() der nächste Key aus dem Cache geholt (und dort gelöscht). Ist der Cache leer wird NULL_KEY zurückgegeben.

In addCache() befindet sich zudem eine Prüfung ob der Schlüssel schon im Cache vorhanden ist. Diese IF-Adfrage kann auch weggelassen werden, kann aber auch recht sinnvoll sein um z.B. nur Schlüssel in den Cache einzufügen die noch nicht dort vorhanden sind (z.B. um Doppelbestellungen durch falsches Klicken bei Vendoren zu verhindern)

Man sollte beachten, der Speicher bei einem LSL Script ist beschränkt. Die Anzahl der maximalen Einträge im Cache (bevor es zu einem Speicherüberlauf) kommt kann recht unterschiedlich sein. Daher sollte der Cache immer schnellstmöglich abgearbeitet werden.

Dazu benötigt man FreePOPs, ein Programm das diverse Ressourcen (z.B. auch RSS) via POP3 zur Verfügung stellen kann und das StudiVZ Plugin. Damit kann man mit jedem beliebigen Mailprogramm Nachrichten aus StudiVZ wie E-Mails empfangen. Das Plugin ist laut Entwickler kompatibel zu StudiVz, MeinVz und SchülerVz. Auch Nachrichten direkt aus dem Mailprogramm schreiben ist möglich, habe ich jedoch nicht getestet.

Ich hatte etwa 1200 Nachrichten zu exportieren, nach jeweils ca. 200 kam es immer zum Abbruch, aber nach einem Neustart fuhr es fort wo es aufgehört hatte.

Zu beachten ist, heruntergeladene Nachrichten werden auf StudiVZ gelöscht und stehen dann dort nicht mehr zu Verfügung.

Wem die Nachrichten sehr wichtig sind, der sollte sich nach einem Anbieter mit IMAP Postfach umsehen (GMX, Web.de,…) und die heruntergeladenen Nachrichten wieder dort (als E-Mails) ablegen. Da geht dann auch nichts verloren wenn der eigene Rechner den Geist aufgibt und/oder die Backup-CD plötzlich nicht mehr lesbar ist.