1.) Einführung

Was sind überhaupt Sockets?

Ein Socket (deutscht: Sockel, Stecker) ist ein eine einheitliche Schnittstelle zwischen der Internet und Transportschicht aus dem Internetmodell (Bsp.: TCP/IP) und der Anwedungsschicht (Bsp.: HTTP). Wenn wir also ein Programm schreiben wollen, dass mittels Netzwerk mit einem anderem Programm auf dem anderen Computer kommunizieren sollte, müssen wir auf Sockets zurückgreifen.

2.) Geschichte

Die Entwicklung des Socket-Interfaces lies nicht lange auf sich warten. Es bestand früher das Problem, dass man keine konkreten Parameter und Befehle für die Kommunkationsumsetzung der verschiedenen Protokolle hatte. Und dies hat deutlicht die Programmierung für Netzwerkanwendungen erschwert. Schließlich entstand Anfang der 80er, im University of California in Berkeley als Ergebnis der langjährigen Forschungsarbeiten ein neues System: BSD-Unix. Es enthielt die API-Socket, die sich schon recht bald als De facto-Standart etablierten. Auch Microsoft übernahm schon recht bald das Socket-Konzept und modellierte daraufhin, das einwenig veränderte Windows Socket (Winsock), dass heute in der zweiten Version vorliegt und die Grundlage der Netzwerkprogrammierung der Windows Betriebssystemen bildet.

3.) Allgemeines

Ein Socket stellt die Kommunikationsschnittstelle zwischen zwei Pogrammen auf der Netzwerkbasis dar. Es gibt insgesamt zwei Socket-Klassen: Client und Server. Beide werden vom Betriebssystem verwaltet und beide können sowohl Daten verschicken, als auch Daten empfangen.

Die Sockets unterstützen das gängige Netzwerkkonzept:

• Verbindungsaufbau

• Datenaustausch

• Verbindungsende

Sie sind definiert durch die Identifikationsnummer (IP) des Remote, Local-Host und die Portnummer des Remote, Local-Host.

Außerdem arbeiten die Berkley-Sockets auf dem so genannten everything-is-a-file- Konzept. Das heißt die Sockets können wie gängige Dateien gesehen werden, die per Eingabe/Ausgabe-Behandlung (I/O) behandelt werden können. Genau das verschaffte den Berkley-Sockets soviel Durchsetzungvermögen und Erfolg. Dabei werden die Sockets wie normale Dateien geöffnet (dafür verwendet man jedoch nicht open(), sondern socket() ) und können wie normale Dateien mit close() geschlossen werden.

2

Die Daten senden und die Daten empfangen kann man dann mittels write() und read().

Unter Windows haben sich jeodoch die send() and recv() Methoden mehr etabliert. Außerdem muss man beim Windows, bevor man den Socket öffnet ihn mittels des Befehls WSAStarup „aufwärmen“.

4.) Socket Typen

Die Sockets lassen sich jedoch auch noch weiter unterteilen. Es gibt zwei Typen von Sockets die auf der Transportschicht arbeiten: Stream Sockets und Datagram Sockets. Stream Sockets sind dabei die Verbindungsorientieren und sicheren und werden meistens durch das Protokoll TCP vertretten. Datagram Sockets sind die verbindungslosen Sockets und verwenden meistens das Protokoll UDP.

Die Schritte die man dabei vorgeht, sind wie folgt aufgebaut (WINSOCK):

5.) Prozessverwaltung

Eines der wichtigen Sachen bei den Sockets stellt das sogenannante handling() auf. Wolle man nun mit dem Server nicht einen Client, sondern 100 gleichzeitig verwalten, reicht da ein Socket nicht aus. Hierfür stehen andere Möglichkeiten zur Verfügung: zum einen könnte man mehrere Socketprozesse kreieren, die einzeln die eingehenden Verbindungen annehmen. Zum anderen könnte man einfach mit dem Befehl select() mehrere Prozesse überwachen und einzeln auf ihre Anfragen reagieren.

Was man jedoch bei den beiden Möglichkeiten beachten sollte, ist die Sicherheit. Denn es ist nämlich ziemlich leicht einen schlecht programmierten, mehrprozessigen Server durch Buffer Overlow (Zu groß verschickte Daten / Zu viele Verbindungen) zum Absturz zu bringen..

3

6.) Beispiel-Programm

Nun schrieben wir ein kleines Beispiel-Client-Programm. Dabei gehen wir alle wichtigen Schritte von oben bis unten durch. Genau so wie im [C-Worker] Tutorial. Das Programm soll sich am Anfang mit dem Server verbinden, vom ihm erst einmal die Daten empfangen und dann ihm „Hello World“ sendet. Die Umsetzung erfolgt mit dem Dev-C++ Compiler unter Windows. Achtung! Bevor man zu programmieren anfängt muss man unter Projekte->Projekt Optionen->Parameter->Linker "-lwsock32" einfügen, um die Winsock Komponente benutzbar zu machen.

1. ) Als erstes wird der Winsock gestartet:

4

2.) Jetzt erstellen wir den Socket:

5

3.) Jetzt bauen wir die Verbindung zum Server auf:

6

Erklärung zu SOCKADDR:

(Da wir TCP/IP benutzten, benutzten wir statt SOCKADDR, SOCKADDR_IN )

7

4.) Jetzt werden die Daten vom Server empfangen

8

5.) Jetzt werden die Daten vom Server gesendet

9

6.) Jetzt wird der Socket geschlossen und der Winsock „aufgeräumt“(quasi wie „return 0“ bei einem main Programm).

Somit ist eure Client-Anwendung fertig. Zur besseren Übersicht, findet ihr den kompletten Quellcode auf der nächsten Seite.

Um eine Server-Anwedung zu schreiben, muss man lediglich den Punkt 2 und 3 anderes gestallten.

Dieses Thema wird jedoch hier nicht weiter behandelt. Wer jedoch Interesse hat, kann sich bei [Fromm], [C-Worker] sehr gut weiter informieren.

10

7.) Quellcode

#include #include #include #include "s_header.h"

#define IP "127.0.0.1" // Zielrechner ist unser eigener Rechner mit "" #define PORT 25 //Auf welchem Port soll zugregriffen werden

using namespace std; int main() { long rc;

SOCKADDR_IN addr; //Ein Pointer für die IP-Adresse Übergabe SOCKET s; //Socket das wir später erstellen

rc=startWinsock();

if(rc!=0)

{ cout<

return 1;

} else { cout<<"Winsock gestartet!"< }

//-------------------------------------------------------------Socket erstellen

s=socket(AF_INET,SOCK_STREAM,0);

if(s==INVALID_SOCKET) { cout<<"Fehler: Der Socket konnte nicht erstellt werden, fehler code: "< return 1;

} else { cout<<"Socket erstellt!"< }

//--------------------------------------------------------------Connecten

memset(&addr,0,sizeof(SOCKADDR_IN)); // zuerst alles auf 0 setzten

addr.sin_family=AF_INET; addr.sin_port=htons(PORT); addr.sin_addr.s_addr=inet_addr(IP); rc=connect(s,(SOCKADDR*)&addr,sizeof(SOCKADDR)); if(rc==SOCKET_ERROR)

{ cout<<"Fehler: connect gescheitert, fehler code: "< return 1;

} else

11

{ cout<<"Verbunden mit 127.0.0.1..\n"< }

//---------------------------------------------------------Daten empfangen char buf[256];

rc=recv(s,buf,sizeof(buf),0); cout<

//------------------------------------------------Daten senden

strcpy(buf,"HELO WORLD\r\n"); rc=send(s,buf,strlen(buf),0);

cout<<"Daten gesendet"<

system ("PAUSE");

//-------------------------------Am Ende muss der Socket geschlossen werden closesocket(s);

WSACleanup();

return 0;

}

12

8.) Literaturverzeichnis

[Wiki] http://de.wikipedia.org/wiki/

[Fromm] http://www-rnks.informatik.tu-

cottbus.de/de/materials/ws2002psInternet/dirk.pdf

[Willimers] http://www.willemer.de/informatik/unix/unprsock.htm

[C-Worker] http://www.c-worker.ch/tuts/wstut_op.html

[Opatz] http://www.pc-adviser.de/socket_programmierung.html

[Tangent] http://tangentsoft.net/wskfaq/

13