Open-Paste-Server [Tutorial]

Home

Add

Edit

Without Linenumbers

Code in Textfield

T S N E _ V 2
Netzwerk Modul

"TSNE" steht für "TCP Socket Network Event" und bedeutet frei übersetzt "TCP/IP Netzwerk Modul mit Eventsteuerung".

Diese Anleitung soll einen freeBASIC Programmierer in die Welt der Netzwerk-Programmierung helfen und durch beispiele den Umgang mit dem TSNE_V2 Modul erleichtern.

Grundvorraussetzung
Ich setzte einmal vorraus, das derjenige, welcher diese Anleitung liest sich mit dem freeBASIC Compiler und die Programmierung mit diesem auskennt und bedienen kann.
Desweiteren werde ich nicht expliziet auf den Sourcecode von TSNE eingehen, sondern deren Umgang und Benutzung anhand von beispielen durchsprechen.

Sollten noch fragen offen bleiben, können diese gerne im Forum gestellt werden: QBasic / Freebasic Forum. Ich werde mich bemühen alle offenen Fragen zu beantworten.
Zusätzlich setze ich vorraus, das der neueste Compiler (aktuell 0.18.5b) installiert ist!

Komponentenbeschaffung
Zuerst legen wir einen neuen Projektordner an. Nennen wir ihn einfach mal "tsne". In diesem Ordner werden wir später all unsere Beispiele rein packen, Compilieren, und ausführen. (Hilft bei der übersicht)
Um TSNE zu benutzen brauchen wir diese ersteinmal. TSNE kann hier bezogen werden: freeBASIC-Portal.
Wir laden die Version: TSNE_V2.bi (fbc 0.18.5b) [Gültig AB: 22.04.2008] herunten oder kopieren den Quelltext und speichern das ganze im zuvor erstellten Ordner mit dem namen "TSNE_V2.bi" ab. (Gross udn kleinschreibugn beachten!)

Inbetriebnahme
Wir erstellen einen neuen Unterordner und benennen ihn "start". Folglich sollte unsere ordnerstrucktur nun wie folgt aussehen: "tsne/start/" bzw, unter windows "tsne\start\".
Dort erstellen wir ein leeres Dokument und nennen es "start.bas".
Nachdem wir mit einem Editor unserer Wahl die datei "start.bas" geöffnet haben, müssen wir zuerst das Modul includieren.
Dies machen wir mit folgendem Code:

```
#INCLUDE Once "../TSNE_V2.bi"
```

"#Include" fügt nun den Quelltext der sich in "TSNE_V2.bi" befindet in unseren Quellcode ein. Dabei wird durch "once" angegeben, das wir diesen Quelltext nur einmal hinzufügen möchten.
Sollten wir später noch einmal die TSNE_V2.bi includieren wollen, so überspringt der Compiler das hinzufügen. Dadurch kommt es später nicht zum doppelten Quelltext welcher Fehler veruhrsachen würde.

Nun Compilieren (übersetzen) wir unseren Quelltext, um zu überprüfen ob das Modul fehlerfrei arbeitet. Dazu klicken wir auf "Compilieren", sofern das unser Editor unterstützt, oder geben in einer Commandozeile folgendes ein:

fbc start.bas

bzw. wechseln wir erst in das Projektverzeichniss (tsne/start/) und führen dort die übersetzung durch. (Bei Windows haben wir wieder "\" anstat "/").

Sollten hier Fehler entstehen, dann würde ich euch bitten im oben genannten Forum diesen Zu melden.

Sollte die übersetzung fehlerfrei durchgeführt werden, dann funktioniert TSNE_V2 fehlerfrei und wir können unser erstes "echtes" Programm schreiben.

Erstes Programm [Client]
Dieses erste kleinen Programm wird im wesentlichen daraus bestehen eine Verbindugn zum Google-Server herzustellen, und die "index.html" Seite herunter zu laden.

Wir erstellen in "tsne/" einen neuen Unterordner mit der Bezeichnung "google" und erstellen auch hier wieder eine leere Datei mit der Bezeichnung "googel.bas".
Diese Datei wird wie schon zuvor mit einem Editor unserer Wahl geöffnet.

Um Die Netzwerk-Funktionen nutzen zu können müssen wir auch hier die TSNE_V2 includieren. Nur Sie stellt uns die einfachen Funktionen zur Verfügung, die uns die Netzwerkkommunikation ermöglicht.

TSNE_V2 arbeitet mit sogenannten "Callback's". Das sind im grunde nur Funktionen oder Sub-Routinen, die TSNE_V2 automatisch aufruft, um uns über Zustandsänderungen zu Informieren. Je nachdem, welche Art von Funktion wir benötigen brauchen wir untershciedliche Routinen mit unterschiedlichen Parametern die wie folgt zu definieren sind:

Sub TSNE_Disconnect(Byval V_TSNEID As Uinteger)

```
End Sub
```

Diese Sub-Routine signalisiert uns, das eine Verbindung deren Kennnummer in V_TSNEID steht beendet wurde. Daraufhin sind keine weiteren Funktionsaufrufe an die Verbindung mit dieser Nummer mehr möglich. Sollten dennoch Aufrufe statfinden, werden Fehlermeldungen zurückgegeben. Aber dies erkläre ich später genauer.

Sub TSNE_Connected(Byval V_TSNEID As Uinteger)

```
End Sub
```

Dieses Signal meldet uns den erfolgreichen aufbau einer Verbindung. Dabei gibt auch hier V_TSNEID die Kennnummer der Verbindung an, welche die Verbindung erfolgreich hergestellt hat.

Sub TSNE_NewData(Byval V_TSNEID As Uinteger, Byref V_Data As String)

```
End Sub
```

Hier meldet uns TSNE_V2 das neue Daten empfangen wurden. Von welcher Kennnumer die Daten kommen steht wieder in V_TSNEID. Die Neuen Daten ansich werden uns in V_Data übermittelt.

Sub TSNE_NewConnection(Byval V_TSNEID As Uinteger, Byval V_RequestID As Socket, Byval V_IPA As String)

```
End Sub
```

Diese Routine signalisiert, das jemand anderes eine Verbindugn mit uns wünscht. V_TSNEID enthält hierbei die Kennnummer der Verbindung, welcher die Anfrage empfangen hat. V_RequestID enthält eine Kennnummer die den Anfragenden identifiziert. In V_IPA findet sich die IP-Adresse des Anfragenden.

Sub TSNE_NewConnectionCanceled(Byval V_TSNEID As Uinteger, Byval V_IPA As String)

```
End Sub
```

Diese Routine meldet im grunde das selbe wie die Routine zuvor. Jedoch wurde der Verbindungs wunsch automatisch abgelehnt da sich die IP-Adresse auf einer "Schwarzen Liste" (BlackList) befindet. Verbindungen deren IP-Adresse sich auf dieser Liste befinden werden automatisch abgelehnt. Dabei wird kein "NewConnection" aufgerufen, sondern immer diese Routine!

Diese 5 Routinen stellen das Grundgerüst der TSNE Nutzung dar. Mit diesen Callback-Routinen (Auch "Event's" genannt) lassen sich alle Statusmeldungen empfangen und auswerten. Selbtverständlich wäre es auch möglich jede Verbindung nacheinander durch zu gehen und zu überprüfen welchen Status die Verbindugn besitzt. Der Nachteil liegt jedoch in der einschränkugn der Programm-Flexibilität und der benötigten Zeit dies durchführen zu können.
TSNE verwendet sogenannte "Thread's". Man kann dies am einfachsten mit einem kleinen Programm vergleichen, das im Hintergrund arbeitet, und diese Aufgaben für uns übernimmt. Sollte sich ein Zustand ändern, "benachrichtigt". Und TSNE durch einen Aufruf einer dieser Routinen. Die aktuelle ausführung unseres Programms wird dadurch kurz unterbrochen, da es zuerst diesen Aufruf abarbeiten muss bevor es seine normale Tätigkeit wieder aufnehmen kann.

Grundsätzlich gibt es 2 arten von Netzwerkprogramme. Zum einen den sogenannten "Client" und zum anderen den "Server". Ein Server erstellt eine Verbindung, die auf einem angegebenen anschluss nach Verbindungswünschen lauscht, diese annimmt oder ablehmt, und Daten oder andere Funktionen bereit stellt.
Ein Client hingegen ist das Gegenstück zum Server. Er ist derjenige, der den Ersten schritt zum Aufbau einer Verbindung durchführt. Er Kontaktirt den Server und fragt ihn ob ein Verbindugnsaufbau möglich ist. Wenn der Server dies bestätigt, kann der Client seinen Wunsch an den Server richten. Der Server wiederum empfängt diesen, wertet ihn aus, und sendet, wenn erforderlich, eine ANtwort zum CLient zurück.

Ihr könnt natürlich auch andere Bezeichnungen für diese Funktionen Verwenden, oder deren Parameter. Wichtig ist nur, das die Datentypen udn die Anzahl der Parameter passen!!! GANZ WICHTIG, IST DAS!!!

Aber lassen wir das Theoretische erstmal etwas beiseite und steigen gleich in die Praxis ein.

Wie schon zuvor erwähnt soll unser erstes Programm eine Verbindung zu Google aufbauen. Damit dies Funktioniert haben wir bereits das TSNE_V2.bi Modul includiert. Jetzt müssen wir noch unsere Callback-Routinen hinzufügen.

```
#INCLUDE Once "../TSNE_V2.bi"
```

Sub TSNE_Disconnect (Byval V_TSNEID As Uinteger)

```
End Sub
```

Sub TSNE_Connect (Byval V_TSNEID As Uinteger)

```
End Sub
```

Sub TSNE_NewData (Byval V_TSNEID As Uinteger, Byref V_Data As String)

```
End Sub
```

Wie Ihr sicher erkannt habt, sind hier nur 3 Callbacks vorhanden. Das liegt an der Natur eines Clienten. Als Client muss sich dieser nicht um Anfragen kümmern (kann auch aus technischer sicht auch garnicht), sondern muss nur mit einer bestehenden Verbindung Kommunizieren.
Dabei möchten wir über eine erfolgreich hergestellte Verbindung sowie über eine beendete Verbindung informiert werden. Da wir auch Daten empfangen möchten brauchen wir, logischerweise .), auch das "NewData" Callback.

Als nächsten Schritt müssen wir eine Verbindung herstellen. Da, wie schon so oft erwähnt, wir denn ersten Schritt machen müssen brauchen wir eine Funktion, die uns eine Verbindung aufbaut.

TSNE_Create_Client(Byref B_TSNEID As Uinteger, Byval V_IPA As String, Byval V_Port As Ushort, Byval V_EventDisconPTR As Any Ptr, Byval V_EventConPTR As Any Ptr, Byval V_EventNewDataPTR As Any Ptr) As Long

Diese Funktion befindet sich bereits fertig aufgebaut im TSNE_V2.bi Modul. Darum müssen wir hier keien zusätzliche Definition in unser Programm einfügen, sondern können bequem diese Funktion aufrufen.
"TSNE_Create_Client" erstellt, wie der name schon vermuten läst, eine neue Verbindung des Types "Client", als der Aktör.
Die Funktion benötigt allerdings einige Parameter, damit TSNE weis, mit wehm eine Verbindung aufgebaut werden soll. Zum einen ist dies die IP-Adresse oder ein Hostname und zum anderen der Port (Die Tür).
Als IP-Adresse, bzw Hostname wählen wir "www.google.de". Die "Tür" an der wir "anklopfen müssen ist "80".

Damit TSNE auch weis, wie die Callback-Routinen heisen, die es aufrufen soll, wenn sich der Status ändert, müssen wir diese auch übergeben. Sie sind "V_EventDisconPTR", "V_EventConPTR" und "V_EventNewDataPTR".
Bei der übergabe der Routinen ist darauf zu achten, das sie als Pointer (Zugriffspunkte) übergeben werden! (Zu erkennen anhand eines voranstehenden @)

Wenn TSNE erfolgreich den Verbindungsaufbau vorbereitet hat, gibt sie uns eine Kennnummer zurück, die sich anschliessend in B_TSNEID befindet.
Sollten jedoch Fehler dabei auftreten, bleibt B_TSNEID gleich "0". Zusätzlich liefert die Funktion uns eine Fehlernummer zurück. Bei erfolgreicher Vorbereitung bleibt die Rückgabe 0 und zeigt so an, das keine Fehler entstanden sind.

Nun aber zurück zu unserem Quellcode. Das Grundgerüst steht. Wir müssen nun die Verbindung aufbauen. Dazu fügen wir die soeben besprochene Funktion hinzu, und füllen sie mit Daten.

```
#INCLUDE Once "../TSNE_V2.bi"
```

Sub TSNE_Disconnect (Byval V_TSNEID As Uinteger)

```
End Sub
```

Sub TSNE_Connect (Byval V_TSNEID As Uinteger)

```
End Sub
```

Sub TSNE_NewData (Byval V_TSNEID As Uinteger, Byref V_Data As String)

```
End Sub
```
```
Dim T_TSNEID As Uinteger
```
```
Dim T_GuruCode As Long
```

T_GuruCode = TSNE_Create_Client(T_TSNEID, "www.google.de", 80, @TSNE_Disconnect, @TSNE_Connect, @TSNE_NewData)

über dem Funktionsaufruf haben wir noch 2 Variablen Dimensioniert. Die erste speichert die TSNEID welche bei erfolgreicher vorbereitung erstellt wurde, die andere (T_GuruCode) speichert die Rückgabe der Funktion.
Sie enthält die Fehlernummer, wenn vorhanden. Ansonsten enthält sie den Wert 0. Um zu überprüfen ob der AUfruf wirklich erfolgreich war, sollten wir anschliessen den GuruCode auswerden.

```
Dim T_TSNEID As Uinteger
```
```
Dim T_GuruCode As Long
```

T_GuruCode = TSNE_Create_Client(T_TSNEID, "www.google.de", 80, @TSNE_Disconnect, @TSNE_Connect, @TSNE_NewData)

```
If T_GuruCode <> 0 Then
```

    Print "["; T_GuruCode; "] "; TSNE_GetGURUCode(T_GuruCode)

```
    End -1
```
```
End If
```
```
Print "Erfolgreich!"
```

Aus Platzgründen habe ich darauf verzichtet die Callbacks hinzu zu fügen. Zusätzlich ist es sicher auf übersichtlicher, als wenn ich ständig den grösserwerdenden Code Poste.
Wir Prüfen also nun, ob sich in T_GuruCode ein Wert ungleich 0 befindet. Ist dies der Fall, dann entstand irgend ein Fehler. Um herauszufinden welcher Fehler das war existiert eine weitere Funktion im TSNE_V2.bi Modul. Sie kann uns aus einem Fehlercode einen Fehlertext erstellen.

TSNE_GetGURUCode(Byref V_GURUID As Long) As String

Dabei brauchen wir nur den GuruCode (Fehlercode) der Funktion übergeben. Im Gegenzug gibt uns die Funktion den Fehlertext zurück. Dies ist darum praktisch, da wir nicht einen ganzen Text vergleichen müssen, um zu erfahren was die Uhrsache war (spart auch speicher und massig Rechenzeit).

Diesen Fehlertext geben wir schlussendlich auf der Konsole aus, und beenden das Programm mit der Fehlernummer -1 (End -1).
Wurde hingegen eine 0 zurückgegeben, dann geben wir den Text "Erfolgreich!" aus. und führen unser Programm weiter aus.

Jetzt müssten wir eigentlich auf eines der Callback-Signale warten, um den erfolgreichen oder fehlgeschlagenen Aufbau auszuwerten. Wir könnten dies durch eine einfache Do: Loop schleife lössen, allerdings gibt es auch hierfür eine Routine in TSNE_V2, die sogar noch etwas leistungsfehiger ist als eine normale Do: Loop Schleife.

TSNE_WaitClose(Byref V_TSNEID As Uinteger)

Nachdem wir diese Routine aufgerunfen und Ihr eine Kennnumme rübergeben haben, wird solange gewartet, bis die Verbindung mit der angegebenen Kennnummer beendet wurde. Erst dann wird diese Funktion verlassen, udn wir können unser Programm weiter ausführen.

```
Dim T_TSNEID As Uinteger
```
```
Dim T_GuruCode As Long
```

T_GuruCode = TSNE_Create_Client(T_TSNEID, "www.google.de", 80, @TSNE_Disconnect, @TSNE_Connected, @TSNE_NewData)

```
If T_GuruCode <> 0 Then
```

    Print "["; T_GuruCode; "] "; TSNE_GetGURUCode(T_GuruCode)

```
    End -1
```
```
End If
```
```
Print "Erfolgreich!"
```

Print "Warte auf Zustands&auml;nderung..."

```
TSNE_WaitClose(T_TSNEID)
```
```
Sleep
```
```
End 0
```

Zuerst geben wir einen Text aus, der uns über den Zustand des Programms informiert. Anschliessend Warten Wir auf das Ende der zuvor erfolgreich vorbereiteten Verbindung dessen Kennnummer sich in T_TSNEID befindet.
Nachdem die Verbindung beendet wurde, warten wir mit "sleep" auf einen Tastendruck des Benutzers und verlassen anschliessend das Programm mit dem Fehlercode 0 (Keine Fehler).

Ihr fragt euch jetzt sicher, wo denn nun die Kommunikaiton statfindet, bzw wo wir Daten übertragen können?!
Nun ... Alles weitere, was mit dem Netzwerk, bzw mit den Verbindungen zu tun hat, wird von jetzt an in den CallBack-Routinen geregelt. Als wir die Verbindung vorbereitet haben, wurde bereits der Wunsch des Verbindungsaufbaus zum Server versand.
Nachdem der Server die Verbindung akzeptiert hat, wird uns das durch den Aufruf von "TSNE_Connected" mitgeteilt. Sollte sie abgelehnt werden, wird statdessen "TSNE_Disconnect" aufgerufen. Das heist, das eine dieser beiden Events zuerst aufgerufen werden und wir folglich hier weiter arbeiten müssen.

Wir gehen einmal von einem Netten Server aus, der uns die Verbindung erlaubt. Folglich ruft TSNE die "TSNE_Connected" Routine auf. Dies bedeutet gleichzeitg, das die Verbindugn vollständig hergestellt wurde, und beide (Server und Client) bereit sind Daten untereinander auszutauschen.

Um unser Programm nicht aus den Augen zu verliehren; Wir wollten die "index.html" Webseite von Google herunterladen.
Diese Seite ist generell die Hauptseite einer jeden Internetseite.
Ich möchte euch jetzt aber nicht mit den gegebenheiten des HTTP-Protokolls vertraut machen, da wir hier nur ein Beispiel durcharbeiten. Darum verzeit mir bitte, wenn ich nicht ganz so ausführlich die nächsten Zeilen (Expliziet das, was zum Server versand wird) erkläre.

Zuerst müssen wir die Daten vorbereiten, die wir zum Server übermitteln möchten. Glücklicherweise ist dies kein Grosser aufwand, und läst sich in ein paar Zeilen übersichtlich unterbringen

Sub TSNE_Connected(Byval V_TSNEID As Uinteger)

```
Print "[Verbunden]"
```
```
Dim T_ZuSenden As String
```

T_ZuSenden += "GET /index.html HTTP/1.1" & Chr(13, 10)

T_ZuSenden += "Host: www.google.de" & Chr(13, 10)

T_ZuSenden += "Connection: close" & Chr(13, 10)

```
T_ZuSenden += Chr(13, 10)
```
```
End Sub
```

Um euch nicht ganz so "dumm" dastehen zu lassen gibt es hier eine kleine Beschreibung des HTTP-Protokolls: Wikipedia: HTTP
Noch kurz aus eigenem Munde erklärt: In der Ersten zeile geben wir an das wir eine Seite haben möchten (GET). Danach sagen wir dem Server welche Seite das ist (/index.html) sowie die Version des Protokolls, das wir verwenden (HTTP/1.1). Ein Zeilenumbruch [chr(13, 10)] markiert das Ende der ersten Zeile.
Die nächste Zeile gibt an, welchen Hostname wir verwand haben. Auch hier ist ein Zeilenumbruch nötig.
Die dritte Zeile teilt dem Server mit, das wir nach erhalt der Antwort die Verbindung nicht weiter benötigen, und der Server diese beenden soll.
Die 4te Zeile ist eien leere Zeile, und zeigt dem Server dadurch, das es keine weiteren Informationen gibt. und er jetzt die Antwort senden soll.
Diese Form der Daten nennt man auch "Header" für "Kopf" oder "Kopfzeilen".

Wir geben zuerst einmal auf der Konsole aus, das die Verbingung erfolgreich hergestellt wurde, und nachdem auch die Daten vorbereitet haben, die zum Server gesand werden sollen, müssen wir diese natürlich auch hin schicken. Hierfür gibt es folgende Funktion:

TSNE_Data_Send(Byval V_TSNEID As Uinteger, Byref V_Data As String) As Long

Diese Funktion Benötigt wie fast alle anderen auch, eine Kennummer (V_TSNEID) und hier im speziellen die Daten welche versand werden sollen. Als Rückgabe erhalten wir wieder einen GuruCode, der uns anzeigt, ob die übertragugn der Daten erfolgreich war.

Sub TSNE_Connected(Byval V_TSNEID As Uinteger)

```
Dim T_ZuSenden As String
```

T_ZuSenden += "GET /index.html HTTP/1.1" & Chr(13, 10)

T_ZuSenden += "Host: www.google.de" & Chr(13, 10)

T_ZuSenden += "Connection: close" & Chr(13, 10)

```
T_ZuSenden += Chr(13, 10)
```
```
Dim T_GuruCode As Long
```

T_GuruCode = TSNE_Data_Send(V_TSNEID, T_ZuSenden)

```
If T_GuruCode <> 0 Then
```
```
If T_GuruCode <> 0 Then
```

    Print "["; T_GuruCode; "] "; TSNE_GetGURUCode(T_GuruCode)

```
    TSNE_Disconnect(V_TSNEID)
```
```
Else
```
```
    Print "Versand erfolgreich!"
```
```
End If
```
```
End Sub
```

Auch hier prüfen wir wieder den GuruCode. Jedoch dürfen wir keinesfalls die das Programm beenden, sollte ein Fehler aufgetreten sein, da dies sonst zu Blockierenden verbindungen führt.
Es ist zwar nicht weiter schlimm, allerdings würde es bei reger Netzwerkaktivität irgend wann keien Freien Ports mehr geben, mit denen wir eien Verbindung herstellen können.
Darum werden wir einfach die Verbindung beenden, und nutzen hierfür wiedermal eine vorgefertigte Routine. (Wie praktisch, das alles schon fertig ist :])

TSNE_Disconnect(Byval V_TSNEID As Uinteger) As Long

Diese Routine beendet eine Bestehenden, Fehlerhaft, oder sonst eine halb-Aktive Verbindung, vollständig. Auch hier wird ein GuruCode zurückgegeben, den man auswerten kann, wenn man mag. Aber um erlich zu sein ist es relativ egal, was da zurück kommt, da ein Fehler keinen wirklich negativen effekt mehr hätte. Es ist also reine Dokumentaiton oder Logführung, für die ganz verrückten utner euch .)

Zu eurer Beruhigung kann ich jedoch sagen, das nach ca. 60sek. Der Port automatisch wieder freigegeben wird und Ihr euren Computer nicht neu starten braucht .)

Ein Erfolgreicher Versand wird ebenfalls gemeldet. Wir wollen ja nichts vergessen .)

Für Fall 2: Verbidnung wurde abgelehnt oder wurde von uns nach einem Fehler beim Senden beendet, wäre es sinvoll, das "TSNE_Disconnected" Callback auch gleich mit Code zu bestücken.

Sub TSNE_Disconnected(Byval V_TSNEID As Uinteger)

```
Print "Verbindung wurde beendet!"
```
```
End Sub
```

Hier gibt es eigentlich nicht viel zu sagen. Nach dem Aufruf dieser Funktion durch TSNE wird uns eigentlich nur mitgeteilt, das TSNE die Verbindung erfolgreich beendet hat.

Ganz fertig sind wir jedoch noch nicht. Eine Kleinigkeit fehlt nämlich noch, und das ist "TSNE_NewData". Schliesslich wollen wir ja auch die Daten welcher der Server uns übermittelt auswerten, bzw. Anzeigen.
Dazu fügen wir eine kleine Zeile in das entsprechende Event ein.

Sub TSNE_NewData(Byval V_TSNEID As Uinteger, Byref V_Data As String)

```
Print V_Data
```
```
End Sub
```

Unser Programm sollte nun wie folgt aussehen:

```
#INCLUDE Once "../TSNE_V2.bi"
```

Sub TSNE_Disconnect (Byval V_TSNEID As Uinteger)

```
Print "Verbindung wurde beendet!"
```
```
End Sub
```

Sub TSNE_Connect (Byval V_TSNEID As Uinteger)

```
Dim T_ZuSenden As String
```

T_ZuSenden += "GET /index.html HTTP/1.1" & Chr(13, 10)

T_ZuSenden += "Host: www.google.de" & Chr(13, 10)

T_ZuSenden += "Connection: close" & Chr(13, 10)

```
T_ZuSenden += Chr(13, 10)
```
```
Dim T_GuruCode As Long
```

T_GuruCode = TSNE_Data_Send(V_TSNEID, T_ZuSenden)

```
If T_GuruCode <> 0 Then
```
```
If T_GuruCode <> 0 Then
```

    Print "["; T_GuruCode; "] "; TSNE_GetGURUCode(T_GuruCode)

```
    TSNE_Disconnect(V_TSNEID)
```
```
Else
```
```
    Print "Versand erfolgreich!"
```
```
End If
```
```
End Sub
```

Sub TSNE_NewData (Byval V_TSNEID As Uinteger, Byref V_Data As String)

```
Print V_Data
```
```
End Sub
```
```
Dim T_TSNEID As Uinteger
```
```
Dim T_GuruCode As Long
```

T_GuruCode = TSNE_Create_Client(T_TSNEID, "www.google.de", 80, @TSNE_Disconnect, @TSNE_Connected, @TSNE_NewData)

```
If T_GuruCode <> 0 Then
```

    Print "["; T_GuruCode; "] "; TSNE_GetGURUCode(T_GuruCode)

```
    End -1
```
```
End If
```
```
Print "Erfolgreich!"
```

Print "Warte auf Zustands&auml;nderung..."

```
TSNE_WaitClose(T_TSNEID)
```
```
Sleep
```
```
End 0
```

Die Daten, welche wir empfangen haben stehen uns in V_Data zur Verfügung. Wir brauchen sie also nicht grossartig umherkopieren, oder erst besorgen und dann noch x andere funktionen aufrufen, sondern können Sie bequem weiterverwenden.
In unserem Fall geben wir sie direkt auf der Konsole aus.

Und damit wären wir fertig. Wir Compilieren das Programm wie gewohnt, und Starten es anschliessend. Unter Windows mit "start.exe" und unter Linux mit "./start".