Mit welchem Tool kann ich mir die nötigen Dateien autom. erzeugen lassen?

ich denke, du meintest diese, oder?
gruß

@elise! Ja, selber bauen wäre natürlich auch möglich. Ich habe aber z.B. bei SQLite das gleiche Problem: die bieten zum Download auch nur eine DLL und eine soganannte DEF-Datei an. Ich wette, man kann daraus auch eine LIB erzeugen. Nur wie? Weil so macht es ja keinen Sinn, wenn die ganzen EmbeddedDB-Anbieter einem immer nur die DLL anbieten? Wenn man es eh selber bauen muß, dann können die sich doch den Extra-Download sparen?

Wenn Du noch die PDB-Datei hast, dann kann man da vielleicht was machen... aber LIB zu erzeugen, da hab ich meine Zweifel...

lib.exe /def:sqlite.def

Hat mich also die Info aus der MSDN nicht ganz getäuscht. Aber die Firebird-Jungs haben doch tatsächlich keine DEF Datei im Download. Die Header braucht man aber anscheinend doch.

Im Prinzip müssten die SQLite- und Firebird-Jungs drei Dateien in den Download legen:

1. die DLL
2. die DEF-Datei, dann kann man sich die LIB für seinen Compiler bzw. Linker automatisch bauen.
3. die wichtigsten Header-Dateien, die man als User braucht.

Wäre Compiler-unabhängig und man müsste sich nicht die kompletten Sourcen runter laden.

Habe mir jetzt den Source von Firebird 2 runter geladen, in dem Embedded-Unterprojekt liegen doch tatsächlich DEF-Dateien. Da liegen sie warm und trocken.

dumpbin namederdll.dll /Exports /Out:NamederModuledefinitionsdatei.def

anstelle von Exports kann natürlich auch Imports stehn.

Ich gehe jetzt davon aus das sich die cmd.exe & die *.dll im verzeichniss der dumpbin.exe befindet.

diese *.def datei must du jetzt bearbeiten, entweder liest du sie gleich aus dem Konsolenprog. aus dies setzt aber voraus das du dir ein eigenes programm schreibst was die dumbin- lib- link &o. undname.exe startet. oder aber du läst sie dir erstmal als textdatei mit der endung *.def erstellen. was dabei rauskommt sieht dann ungefähr so aus

Dump of file NamederDll.dll

File Type: DLL

Section contains the following exports for NamederDll.dll

0 characteristics
4294DCD9 time date stamp Wed May 25 22:15:21 2005
0.00 version
1 ordinal base
7497 number of functions
7497 number of names

ordinal hint RVA name

1 A 00007063 ??0AAmmunition@@QAE@ABV0@@Z
2 B 000087F6 ??0AAmmunition@@QAE@XZ
3 C 00008562 ??0AAntiPortalActor@@IAE@XZ

diese kauderwelsch ??0AAmmunition@@QAE@ABV0@@Z nennt sich ergänzter Name

was nun für dich interessant ist zu wissen sind die zahlen die in der spalte ordinal stehen und das was unter name steht. Du must nun die *.def datei die dir dumpbin erstellt hat so umbauen das sie wie unten aufgeführt aussieht. das ist sehr wichtig ansonsten frist sie kein weiterführendes prog. wie Lib- o. Link.exe

LIBRARY NameDerDll.DLL

EXPORTS
??0AAmmunition@@QAE@ABV0@@Z @ 1
??0AAmmunition@@QAE@XZ @ 2
??0AAntiPortalActor@@IAE@XZ @ 3
...

jeh nachdem was du oben entpackt hast Exports o. Imports Funktionen muss hier nätürlich auch wieder Exports o. Imports stehn.

wenn du nun die *.def richtig erstellt hast öffnest du wieder die cmd.exe (achtung ich gehe wieder davon aus das die cmd.exe sich im verzeichniss der lib.exe befindet) und gibst folgendes ein

lib /def:NamederModuledefinitionsdatei.def /out:NamederLib*.lib

wenn du alles richtig gemacht hast, erstellt dir die Lib.exe die gewünschte *.lib und die *.exp. Diese kannst du nun in dein Project einbinden.

Um dir nun daraus ne header zu basteln, wird das ganze noch ein wenig komplizierter, hierfür brauchst du nur die ergänzter Name
??0AAmmunition@@QAE@ABV0@@Z und die undname.exe
den ergänzten namen übergibts du an undname.exe wie unten folgt. (achtung ich gehe wieder davon aus das die cmd.exe im verzeichniss der undname.exe liegt) öffne die cmd.exe und gib dort ein.

undname -f ??0AAmmunition@@QAE@ABV0@@Z

und sie gibt dir zurück

public: __thiscall AAmmunition::AAmmunition(class AAmmunition const &);

du must das dann noch weiterverarbeiten, denn so kann kein prog damit was anfangen, und zwar in der form

public gibt dir den zugriffstatus der funktion zurück

AAmmunition:: gibt dir den classennamen bzw. den headernamen an

::AAmmunition(class AAmmunition const &) gibt dir den funktionsnamen an

so das wars wie man ne header erstellt nur dürfte klar sein das dies über die cmd.exe etwas schwierig zu lösen sein dürfte. und darin liegt nun die kunst. du wirst um dir ne header zu erstellen nicht darum kommen dir ein eigenes programm zu schreiben das dir alle ergänzten namen an die undname.exe übergibt und gleichzeitig das zurückgegeben wieder ausliest und weiterverarbeitet.

eine andere möglichkeit wäre, an die ergänzten namen zu kommen, das ganze über
Portable Executable File Format zu erledigen, diesbezüglich bräuchtest du nicht den umweg über die dumbin.exe zu gehn sondern könntest direkt dir die *.def erstellen und alles an undname.exe übergeben.

Anbei sei noch vermerkt
es gibt nicht umsonst leute die 250$ und mehr für solche header zahlen. das eröffnet einem nämlich unteranderem unendliche möglichkeiten des cheatens

LowFly

Aber so kompliziert habe ich es mir nicht vorgestellt

hmm,
vor einem jahr hab ich noch zu denen gehört die steif & fest behauptet haben es wäre überhaupt nicht möglich. vor einigen monaten dachte ich noch das man studiert & den doctor title haben muss, um fähig zu sein, header aus ner dll zu erstellen.

im enddefect ist es aber nur das ausführen von programmen in der richtigen reihenfolge & pissbillige Stringbearbeitung das wars.

bzw. wenn man sich mal in Portable Executable File Format eingearbeitet hat geht das ganze noch viel einfacher & schneller & es bleibt zum schluß nur noch die Stringbearbeitung.

klar man muss sich mal etwas intensiver mit dem thema auseinander setzen als es eben mal so aus dem ärmel zu schüteln, jedoch geht es & das sogar recht einfach

LowFly

@ Jochen nein ich kann dir nicht glauben,
da ich mir son tool geschrieben und komischerweise kann ich ungefähr 5% aller dll's die ich auf der platte hab NICHT entpacken 95% aller dll's kann ich entpacken. die ich nicht entpacken kann sind meistens dll's die mit mfc.. anfangen. Fackt ist das ich die dll's enpacke und diese header in verbindung mit den lib's in ein project einbinde & nutzen kann. ob du es mir nun glaubst oder nicht is mir egal. nur bitte behaupte es nicht das es nicht geht wenn du selbst nicht versucht hast es erfolgreich nachzufollziehn.

so sieht zB das aus was ich von der undname bekomme. ich nenne es mal die vorläufige header

public: class UFluidVolumeInterface & __thiscall AFluidVolume::GetInterface(void);
public: float __thiscall USkeletalMeshInstance::GetKeyAlpha(int,struct MeshAnimChannel const &);
private: float __thiscall USkeletalMeshInstance::GetKeyAlphaInternal(int,struct MeshAnimChannel const &);
private: float __thiscall USkeletalMeshInstance::GetKeyAlphaOfHigherBlendsOnChannel(int,struct MeshAnimChannel const &);
public: double __thiscall UTexture::GetLastUpdateTime(void);
public: static void __cdecl USkinVertexBuffer::InternalConstructor(void *);
public: static void __cdecl USound::InternalConstructor(void *);
public: static void __cdecl USparkEmitter::InternalConstructor(void *);
public: static void __cdecl USpeechManager::InternalConstructor(void *);
public: static void __cdecl USpriteEmitter::InternalConstructor(void *);
public: static void __cdecl UStaticMesh::InternalConstructor(void *);
public: static void __cdecl UStaticMeshInstance::InternalConstructor(void *);
public: static void __cdecl UStaticShadow::InternalConstructor(void *);
public: static void __cdecl UTerrainMaterial::InternalConstructor(void *);
public: static void __cdecl UTerrainPrimitive::InternalConstructor(void *);
public: static void __cdecl UTerrainSector::InternalConstructor(void *);
public: virtual int __thiscall UModifier::IsTransparent(void);
public: virtual int __thiscall UShader::IsTransparent(void);
public: virtual int __thiscall UTexture::IsTransparent(void);
public: int __thiscall UTerrainSector::IsTriangleAll(int,int,int,int,int,unsigned char);
public: virtual bool __thiscall APawn::IsVisionEnabled(void);
public: int __thiscall AActor::IsVolumeBrush(void)const ;
public: virtual int __thiscall ADoor::IsWedged(void);
public: int __thiscall UViewport::IsWire(void);
public: bool __thiscall UMassiveAdClient::IsZoneLoaded(void);
public: virtual int __thiscall UEngine::Key(class UViewport *,enum EInputKey,unsigned short);
public: unsigned char __thiscall UInput::KeyDown(int);
public: virtual void __thiscall AEmitter::Kill(void);
public: int __thiscall USkeletalMesh::LODFootprint(int,int);

und das lass ich dann das tool daraus machen und erstell mir das als headerdatei auf der platte und binde dies in ein project.

class AActor
{

public:
AActor(class AActor const &);//
AActor(void);//
virtual ~AActor(void);//
static void * __cdecl operator new(unsigned int,class UObject *,class FName,unsigned long);//
static void * __cdecl operator new(unsigned int,enum EInternal *);//
class & operator=(class AActor const &);//
virtual int AddMyMarker(class AActor *);//
virtual int AnimGetSpecialChannel(void);//
virtual class * AssociatedLevelGeometry(void);//
void AttachProjector(class AProjector *);//
int AttachToBone(class AActor *,class FName);//
void BeginTouch(class AActor *);//
virtual void BoundProjectileVelocity(void);//
virtual int CanCoverPlaneBillboard(void)const;//
void execSetTweenMode(struct FFrame &,void * const);//
void execSimulateSoundOnDedicatedServer(struct FFrame &,void * const);//
................
virtual void initialiseHavokDataObject(void);//
int moveSmooth(class FVector);//
virtual void performPhysics(float);//
virtual void physFalling(float,int);//
void physProjectile(float,int);//
void physRootMotion(float);//
void physTrailer(float);//
void physicsRotation(float);//
virtual void processHitWall(class FVector,class AActor *);//
virtual void processLanded(class FVector,class AActor *,float,int);//
virtual void setPhysics(unsigned char,class AActor *,class FVector);//
int setRelativeLocation(class FVector);//
int setRelativeRotation(class FRotator);//
virtual void stepDown(class FVector const &,struct FCheckResult &);//
virtual void stepUp(class FVector,class FVector,class FVector,struct FCheckResult &);//

protected:

private:
static class PrivateStaticClass;//

/*Müll:

*/

};

Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen, da diese *nur* Namen (oder Ordinal) exportieren und Du weder Aufrufkonventionen noch Parameter kennst.

Es kann *nur* (ohne Zusatzinfos) gehen, wenn reine C++-Funktionen (also keine Klassen) exportiert werden, da hier in dem dekorierten Namen alles drin steht.

Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss.

indem zb die Dll deren funktion ich manipulieren will schon längst in einem process geladen ist und man eine weitere dll die die manipulierten funktionen enthält dort injeziert und man nur dafür sorge tragen muss das die injezierte dll vom laufenden process anerkannt & ausgeführt wird.

Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen

naja dann frag ich mich wieso es bei mir geht

da diese *nur* Namen (oder Ordinal) exportieren

falsch falsch falsch aber gleich sowas von falsch. diese ausssage zeigt mir das du anscheinend noch nie eine *.def via Dumpbin erstellt hast. denn dort bekommst du die ordinal zahl & den ergänzten name der Funktion & noch einiges mehr. um dir daraus ne *lib anzufertigen zu lassen must du allerdings die *.def umbauen die dir dumpbin erstellt. und die umgebaute *def übergibst du dann an die lib.exe. Ich hab alles beschrieben wies geht probier es aus, allerdings plauder ich nicht aus dem nähkästchen, mitdenken muss man & setz ich voraus. mehr sag ich nicht mehr dazu.

der andere weg ist wie gesagt über Portable Executable File Format und dort lass ich mir die ergänzten namen durch eine schleife in einer array plazieren und ihr platz in der Array +1 entspricht auch gleichzeitig ihrer ordinal zahl.

und Du weder Aufrufkonventionen noch Parameter kennst.

wie gesagt das zeigt das du es noch nie probiert hast den der aufruf einer classe passiert genau so wie normal auch, wenn du dich im ausführenden process einklingst

UTerrainSector::IsTriangleAll(int,int,int,int,int,unsigned char);

UTerrainSector *pUTS = new UTerrainSector();
pUTS->IsTriangleAll(0,1,2,3,4,_T("Test"));

na & die Parameternamen auf die du hinauswills interesieren absolut nicht in einer header es reicht der parametertyp und den bekommst ja oder bitte was ist das IsTriangleAll(int,int,int,int,int,unsigned char) in der *.cpp geb ich dir recht dort brauchst du den Parameternamen, nur kann der gänzlich anderst heisen wie in dem orginal.

kuck dir mal diese beispiele an,
http://www.codeproject.com/debug/LibView.asp
insbesondere dieses
http://www.codeproject.com/dll/Execute_DLL_Function.asp

ich sag auch nicht das man sich da mal schnell hinsetzt den code runtertippt und man header hat die sofort einsetztbar sind. bei den lib's egal was du sagst funzt es bei mir (man muss die *.def RICHTIG umbaun) und mit den headern rumspielen. dann klapp das auch (mit dem nachbarn )

LowFly

Ich verstehe genau was du da machst, ist mir alles klar, bloss weiss ich deswegen auch dass das was dabei rauskommt vielleicht reicht mit einer DLL ein wenig blöd rumzuspielen, aber nicht wenn man vernünftig damit arbeiten will.

Im übrigen wird das was du tust dem OP nixe bringen, er will ja nicht eine "ersatz-dll" schreiben oder irgendwelche Funktionen patchen, sondern eine DLL von der er keine Headers hat selbst verwenden. Und das geht nicht.

Ein .lib File zusammenpfuschen ist eine Sache, eine vollständig verwendbare Header Datei eine gänzlich andere.
Sag was du willst, aber du *kannst* aus einer DLL (mit oder ohne .def File) keine Headers erstellen mit denen man vernünftig arbeiten kann. Es geht nicht. Punkt.

Ich verstehe genau was du da machst, ist mir alles klar, bloss weiss ich deswegen auch dass das was dabei rauskommt vielleicht reicht mit einer DLL ein wenig blöd rumzuspielen, aber nicht wenn man vernünftig damit arbeiten will

verstehn und es selbst probieren sind zwei paar stiefel die sich gänzlich unterscheiden. und pfuschen tut hier keiner. die aussage zeigt das man(n) sich nicht ernsthaft damit beschäftig, zuwas und wofür gedacht ist die Dumpbin- lib- & link.exe zu nutzen.

anhand eurer ausssagen sehe ich das ihr es bislang nie ernsthaft versucht habt dies zu bewerkstelligen und spätestens dann aufgehört habt als die ersten stollpersteine kamen o. euch das verständniss dafür fehlt. bzw. nur aus eurem wissen (was ich an dieser stelle keinem streitig machen will) vermutungen anstellt wie etwas zu sein hat. womit ihr beide aber sowas von daneben liegt.

sondern eine DLL von der er keine Headers hat selbst verwenden. Und das geht nicht

ich kann mich nur wiederholen es zeigt wieviel ahnung du hast, hättest du nur einmal in das beispiel gekuckt. Es zu verstehen versucht, hättest du dir diese aussage verkniffen da wird zum teil genau das gemacht was du behauptest das es nicht geht.

aber nochmal langsam zum mitschreiben.

1; erstelle dir eine *.lib von der dll deren funktion du nutzen willst & binde sie in dein project ein.

2; wenn nötig erstelle dir eine header aus dem was dir undname.exe anhand der ergänzten namen zurückgibt & binde diese in dein Project.

die header ist nur notwenig damit der compiler nicht motzt es würden irgendwo nichtaufgelöste externe symbole geben. zu nix anderem ist die header notwendig.

3; hier gibt es zwei wege zum erfolg
entweder injeziere die dll die funktionen manipulieren soll in den laufenden process & aktiviere sie
oder
lade die gewünschte dll beim start des programms via LoadLibary(...) in deinen Project und du erhälst zugriff auf alle funktionen die in der dll zu finden sind.

nun kannst du natürlich weiter behaupten das es nicht geht.

dann frag ich mich aber warum klappt es bei mir egal wie, ob ich nun etwas in einen process injeziere oder die gewünschte dll beim start in mein project lade.

warscheinlich hab ich nen zauberpc

Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss.

indem zb die Dll deren funktion ich manipulieren will schon längst in einem process geladen ist und man eine weitere dll die die manipulierten funktionen enthält dort injeziert und man nur dafür sorge tragen muss das die injezierte dll vom laufenden process anerkannt & ausgeführt wird.

Was hat denn das mit meiner Frage zu tun!? Und wer will hier was manipulieren? Weder ich noch der OP...

LowFly schrieb:

Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen

naja dann frag ich mich wieso es bei mir geht

da diese *nur* Namen (oder Ordinal) exportieren

falsch falsch falsch aber gleich sowas von falsch. diese ausssage zeigt mir das du anscheinend noch nie eine *.def via Dumpbin erstellt hast.

Ich vermute eher mal, dass Du es noch nie mit Windows-DLLs probiert hast!
Ein Dumpbin von kernel32.dll liefet z.B.:

Dump of file C:\WINDOWS\SysWOW64\kernel32.dll

File Type: DLL

  Section contains the following exports for KERNEL32.dll

    00000000 characteristics
    42435E2F time date stamp Fri Mar 25 01:41:19 2005
        0.00 version
           1 ordinal base
         978 number of functions
         978 number of names

    ordinal hint RVA      name

          1    0 000219F6 ActivateActCtx = _ActivateActCtx@8
          2    1 00023F79 AddAtomA = _AddAtomA@4
          3    2 00043A11 AddAtomW = _AddAtomW@4
          4    3 00081C71 AddConsoleAliasA = _AddConsoleAliasA@12
          5    4 00081C33 AddConsoleAliasW = _AddConsoleAliasW@12
          6    5 00068005 AddLocalAlternateComputerNameA = _AddLocalAlternateComputerNameA@8
          7    6 00067F1E AddLocalAlternateComputerNameW = _AddLocalAlternateComputerNameW@8

So: Und jetzt erklär mir mal bitte, wie Du ohne Infos über die Funktionen eine h-Datei und eine LIB-Datei erzeugen willst!?
Dir sind weder Parameter/Aufrufkonventionen noch sonstwas bekannt...

Wie gesagt: Wenn Du die Header irgendwo hast, dann geht es... aber wenn Du *nur* die DLL hast (wie es beim OP geheisen hat), dann ist es IMHO zu 99% unmöglich.

im fall der kernel zB hat man keine ergänzten namen sondern bekommt gleich den funktionsnamen allerdings OHNE Parameter angabe das ist richtig. aber willst du mir vieleicht erzählen das man für die kernel irgendwelche aufrufkonventionen braucht, ich hoffe nicht.

und für die Parameter der windows- kernelfunktionen reicht erstens ein rechtsklick auf parametertyp bzw ein blick in die MSDNActivateActCtx

und für die die windows dll's die keine *.lib's und header in SDK's bereitstellen klappt das beschrieben verfahren. und wenns eben nicht klappt fallen die unter die besagten 5%

LowFly

Das man mit Hilfe von Tools und ewig rumraten und pfriemeln vielleicht in ein paar sehr sehr einfachen Fällen Erfolg hat - ja, ok, wen interessierts, das geht nämlich sogar ganz ohne Tool. (Ok, .lib File schreib ich nicht mit Hand, aber .def File, und mit dem mach ich dann mein .lib File). Bloss ist das ein gänzlich anderes Thema.

Wie willst du bitte bei einer C++ DLL sizeof(X) rausbekommen? Wie willst du zu den Klassen kommen die gänzlich inline implementiert sind? Zu den Templates? Wie willst du die Funktionen/Methoden aufrufen deren Parameterliste eine komplett inline implementierte Klasse enthält?

Du redest hier von spezialfällen, und ignorierst fest das wir anderen das nicht tun.

BTW: das "MessageBoxA" Beispiel ist wohl komplett lächerlich. Davon abgehesen: das dort vorgestellte Tool erfordert erst recht wieder das man die Parameterliste mit Hand eingigt. Und nun sag mir wie du die Parameterliste von MessageBoxA erraten willst wenn du sie eben nicht weisst, und nicht nachgucken kannst? Hm? Blubb.

@ hustbaer
ich habs fast vermutet aber nein ich bin nicht mächtig schlau & auch nicht allwissend oder was dir sonst noch für neckerein einfallen. wenn du diese stufe der komunikation benutzen must bist du geistig noch ärmer als ich vermutet hab.

All die fragen die du stellst "Wie willst du bitte bei einer C++ DLL sizeof.." hab ich beantwortet,

wie jetzt schon so oft gesagt du/ihr versucht garnicht es ansatzweise zu verstehn. Es ist immer am leichtesten zu schrein das geht nicht, weil man sich dann nicht die mühe machen muss es zu verstehn oder herauszufinden.

mir egal ob ihr es nun glauben wollt oder nicht ich bin kein mesias & auch kein prediger der versucht euch zu bekeheren. Ich für meinen teil weis das es geht, ich habs schwarz auf weis vor mir liegen, die leute die es nachvollziehen wollen haben genug material und links durch den thread an der hand um dies erfolgreich nachvollziehen & sich dann selbst ein urteil bilden zu können ob es nun möglich ist oder nicht.

Da nun leider der thread langsam aus dem ruder läuft (hustbaer ) und weiterführende diskusionen mit sicherheit im streit enden. gibt der vernünftigere bekanntlich nach.

Somit,
ja ihr hab recht, (es ist unmöglich eine header & lib aus einer dll zu machen, es ist kompletter schwachsinn was ich da erzählt hab) & ich meine ruh.

LowFly

und für die Parameter der windows- kernelfunktionen reicht erstens ein rechtsklick auf parametertyp bzw ein blick in die MSDNActivateActCtx

Ja, mit Zusatzinformationen kannst du alles erreichen. Aber was machst du, wenn du NUR diese DLL vorliegen hast (oder eine ähnlich aufgebaute DLL, die irgendein fremder Programmierer (z.B. Jochen) dir in die Hand gedrückt hat)?

Die ergänzten Namen enthalten nur in Spezialfällen genug Informationen, um daraus den Funktions-Prototyp rekonstruieren zu können. Und afaik gibt es in der DLL auch keine Informationen darüber, welche Member die verwendeten Klassen enthalten (nochmal in verständlichem Deutsch: Woher willst du diese Informationen nehmen?) Und daß es bei dir bislang immer geklappt hat, ist vermutlich auf eine glückliche Auswahl der Test-DLLs zurückzuführen.

PS: Und die Tatsache, daß auch deine Methode in "5% aller Fälle" versagt, bestätig doch auch die Aussage "es geht nicht generell"

Und die Tatsache, daß auch deine Methode in "5% aller Fälle" versagt, bestätig doch auch die Aussage "es geht nicht generell"

hab ich nie behauptet

wie schon gesagt ihr habt recht ich meine ruh

LowFly schrieb:

da ich mir son tool geschrieben und komischerweise kann ich ungefähr 5% aller dll's die ich auf der platte hab NICHT entpacken 95% aller dll's kann ich entpacken.

(Daß du von diesen 5% zufälligereweise ein paar Zusatzinformationen hast, tut jetzt nichts zur Sache - versuch' doch mal, aus der kernel32.dll einen Header zu erstellen, OHNE die MSDN zu verwenden).

aber nun gut, anscheinend must du das rad jedes mal neu erfinden. ich zähle zu den 95% der dll's die ich enpacken kann nicht die dazu von denen es in SDK's libs & header gibt. warum auch die muß man nicht enpacken.

aber wie gesagt man kann immer einen hacken finden an dem man sich aufhängt.

such mal weiter findest bestimmt noch ein paar.