11.8 Aufbau des Serverprogramms
Jetzt benötigen Sie die Verbindung zur Gegenseite, zum Server. Der Unterschied zum Clientprogramm besteht im Wesentlichen nur darin, wie eine Verbindung zustande kommt. Daher wird ein Server immer in einen Wartezustand versetzt, um Verbindungswünsche von Clientprogrammen entgegenzunehmen. Die Datenübertragung hingegen verläuft genauso wie beim Client.
Das Serverprogramm muss auch zunächst herausfinden, an welchem Port es auf Verbindungswünsche warten soll. In unserem Beispiel wird die Portnummer erst fest im Quellcode einkompiliert. Ansonsten könnten Sie hierfür die Funktion getservbyname() zur Ermittlung eines Ports mittels dessen Namen verwenden (mehr dazu später).
Zuerst müssen Sie auch beim Server ein Socket mit socket() erzeugen, um überhaupt mit den Clientprogrammen kommunizieren zu können. (Oder: Was nützt der Rasierapparat ohne eine Stromsteckdose?)
Anschließend ist es an der Zeit, dem Betriebssystem mit der Funktion bind() mitzuteilen, welchem Port das Socket zugewiesen werden soll. Wenn hierbei ein Datenpaket empfangen wird, weiß das System anhand der Portnummer, für welches Socket das Paket gedacht ist. Sie können sich die Portnummer hierbei als Durchwahl einer Telefonnummer vorstellen, wie dies bei größeren Firmen der Fall ist. Hat eine Firma z. B. die Nummer 12345 und Herr Huber die Nummer 134, dann wäre die komplette Nummer mit Durchwahl 12345–134, und Herr Huber ist am Apparat. Umgesetzt auf die Socket-Programmierung ist die IP-Adresse die Nummer zur Firma und die Durchwahl die Nummer des Ports. Zurück zum Thema. Die Aufgabe von bind() ist es, das neu erzeugte Socket mit dem Port zu binden. Mit der Funktion bind() geben Sie die Endpunktadresse (IP-Adresse: Portnummer) an, unter der das Socket erreichbar sein soll. Das heißt, dass ein Socket, das mit bind(192.168.201.1, 8000) gebunden wurde, NIE aus dem Internet ansprechbar ist, während es mit bind(134.76.13.21, 8000) NIE aus dem internen Netzwerk erreichbar ist. Aber mit bind(INADDR_ANY, 8000) ist es überall erreichbar. An welche Adresse richtet sich dann die Anfrage? Für solch einen Fall (was meistens immer der Fall ist) wird die Konstante INADDR_ANY anstelle einer festen IP-Adresse verwendet. Dadurch wird der Server angewiesen, Verbindungen für jede IP-Adresse anzunehmen (die dem Server auch gehört).
struct sockaddr_in address;
...
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons (15000);
if (bind ( create_socket,
(struct sockaddr *) &address,
sizeof (address)) == 0)
printf ("Binding Socket erfolgreich\n");
Jetzt, da der Server bereit ist, auf eingehende Verbindungswünsche zu reagieren, können Sie mit der Funktion listen() eine Warteschlange einrichten, um mehreren Verbindungswünschen Einlass zu gewähren. Anschließend wird die Funktion accept() aufgerufen. Die Adressinformationen über den Client befinden sich danach im zweiten Parameter der Funktion accept(). Diese benötigen Sie, damit Sie überhaupt wissen, mit wem Sie es zu tun haben. Wichtig hierbei ist, dass die Verbindung von nun an über das neu erstellte Socket, das accept() als Rückgabewert bei Erfolg liefert, abgewickelt wird. Das »alte« Socket steht weiterhin für die weiteren Verbindungsaufbauwünsche zur Verfügung. Allerdings können Sie mit der jetzigen Codeform nur eine Verbindung zur gleichen Zeit bearbeiten. Wie Sie theoretisch mehrere Verbindungen parallel abarbeiten können, erfahren Sie ein paar Seiten später (geht auch mit einer CPU). Gewöhnlich werden Sie auch wollen, dass der Server sich nach einem Durchlauf nicht beendet. Daher sollten Sie hierfür accept() meistens in eine Endlosschleife verpacken, womit der Server dauerhaft Verbindungswünsche eingehen kann.
11.8.1 Zusammenfassung: Serveranwendung und Quellcode
Zusammengefasst besteht eine Serveranwendung gewöhnlich aus den folgenden Einzelteilen:
|
einen Socket erzeugen – socket() |
|
den eigenen Port festlegen – bind() |
|
auf Verbindungswünsche warten – listen() |
|
Verbindung annehmen – accept() |
|
Kommunikation – was auch immer (Daten empfangen oder versenden) |
|
Verbindung schließen – close() |
Hierzu der Quellcode des Servers:
/* server.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd. h.>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUF 1024
int main (void) {
int create_socket, new_socket;
socklen_t addrlen;
char *buffer = malloc (BUF);
ssize_t size;
struct sockaddr_in address;
const int y = 1;
printf ("\e[2J");
if ((create_socket=socket (AF_INET, SOCK_STREAM, 0)) > 0)
printf ("Socket wurde angelegt\n");
setsockopt( create_socket, SOL_SOCKET,
SO_REUSEADDR, &y, sizeof(int));
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons (15000);
if (bind ( create_socket,
(struct sockaddr *) &address,
sizeof (address)) != 0) {
printf( "Der Port ist nicht frei – belegt!\n");
}
listen (create_socket, 5);
addrlen = sizeof (struct sockaddr_in);
while (1) {
new_socket = accept ( create_socket,
(struct sockaddr *) &address,
&addrlen );
if (new_socket > 0)
printf ("Ein Client (%s) ist verbunden ...\n",
inet_ntoa (address.sin_addr));
do {
printf ("Nachricht zum Versenden: ");
fgets (buffer, BUF, stdin);
send (new_socket, buffer, strlen (buffer), 0);
size = recv (new_socket, buffer, BUF-1, 0);
if( size > 0)
buffer[size] = '\0';
printf ("Nachricht empfangen: %s\n", buffer);
} while (strcmp (buffer, "quit\n") != 0);
close (new_socket);
}
close (create_socket);
return EXIT_SUCCESS;
}
Jetzt wird es Zeit, das Client-Server-Beispiel zu testen. Hier die Client-Server-Anwendung bei der Ausführung. Da ich davon ausgehe, dass Sie dieses Beispiel auf dem lokalen Rechner testen wollen, sollten Sie den Client mit der IP-Adresse Ihres Heimrechners starten – was gewöhnlich 127.0.0.1 (localhost) ist. Falls Sie die Serveranwendung allerdings woanders eingerichtet haben als die Clientanwendung, so geben Sie hierfür eben die entsprechende IP-Adresse des Servers an. Sie unterhalten sich im Beispiel quasi über dieselbe IP-Adresse (127.0.0.1).
[tty1]$ gcc -o client client.c
[tty1]$ gcc -o server server.c
[tty1] $ ./server
Socket wurde angelegt
---[Terminal wechseln]---
[tty2]$ ./client 127.0.0.1
Socket wurde angelegt
Verbindung mit dem Server (127.0.0.1) hergestellt
---[tty1]---
Socket wurde angelegt
Der Client 127.0.0.1 ist verbunden ...
Nachricht zum Versenden: Hallo Client
---[tty2]---
Socket wurde angelegt
Verbindung mit dem Server (127.0.0.1) hergestellt
Nachricht erhalten: Hallo Client
Nachricht zum Versenden: Hallo Server
---[tty1]---
Socket wurde angelegt
Der Client 127.0.0.1 ist verbunden ...
Nachricht zum Versenden: Hallo Client
Nachricht empfangen: Hallo Server
Nachricht zum Versenden: Beende dich mit quit
---[tty2]---
Socket wurde angelegt
Verbindung mit dem Server (127.0.0.1) hergestellt
Nachricht erhalten: Hallo Client
Nachricht zum Versenden: Hallo Server
Nachricht erhalten: Beende dich mit quit
Nachricht zum Versenden: quit
$
---[tty1]---
Socket wurde angelegt
Der Client 127.0.0.1 ist verbunden ...
Nachricht zum Versenden: Hallo Client
Nachricht empfangen: Hallo Server
Nachricht zum Versenden: Beende dich mit quit
Nachricht empfangen: quit
[tty3] $ ./client 127.0.0.1
Socket wurde angelegt
Die Verbindung wurde "accepted" mit dem Server 127.0.0.1
---[tty1]---
...
Nachricht zum Versenden: Beende dich mit quit
Nachricht empfangen: quit
Der Client 127.0.0.1 ist verbunden ...
Nachricht zum Versenden:
...
Hinweis Mit der Funktion setsockopt() richten Sie das Socket so ein, dass mehrere Prozesse (Clients) denselben Port teilen – sprich: Mehrere Clients können innerhalb kürzester Zeit mit dem Server in Verbindung treten. Außerdem lösen Sie damit auch das Problem, dass der Server beim Neustart seinen lokalen Port erst nach zwei Minuten Wartezeit wieder benutzen kann. Dies werden Sie in fast allen Beispielen wieder finden. Mehr zur Funktion setsockopt() finden Sie in einem späteren Abschnitt (10.15) wieder.
|
Sie haben hier praktisch eine einfache Client-Server-Anwendung erstellt, womit Sie einfachen Text miteinander austauschen können. Natürlich habe ich es mir bei diesem Beispiel sehr leicht gemacht. Für solch ein Beispiel hätten Sie sich kein Buch kaufen müssen – aber zur Einführung ist dies genau das Richtige. Daher soll jetzt auf den folgenden Seiten noch tiefer in die Materie vorgedrungen werden. Jetzt haben Sie zwar eine Menge Sitzfleisch für das Kapitel aufwenden müssen – dafür haben Sie sich allerdings die Grundlagen zur Netzwerkprogrammierung gelegt. Daher wird auf den folgenden Seiten der Praxis-Anteil wieder gesteigert.
|