• socket und close
• Server: bind, listen und accept
• Clientaufruf: connect
• Datenaustausch: send und recv
• Namensauflösung
• Zahlendreher ntoh und hton
• Rahmenprogramm
• Sockets parallel abfragen
• IPv6
• Performance

Sockets werden wie Dateien behandelt

Start des Servers

Start des Client

Übersicht über die Systemaufrufe

read oder recv

Kommunikationsendpunkt: socket und close

#include <sys/socket.h> int IDMySocket; IDMySocket = socket(AF_INET, SOCK_STREAM, 0); ... if (IDMySocket>0) close(IDMySocket);

Jeder eröffnete Socket muss auch wieder geschlossen werden. Dies ist an sich eine Binsenweisheit. Eine Nachlässigkeit an dieser Stelle kann sich bitter rächen, da insbesondere bei statuslosen Serverprozessen Verbindungen sehr oft eröffnet werden und das Fehlen weiterer Sockets zum Stillstand des kompletten Systems führt.

Socket schließen unter UNIX mit close

Serveraufrufe: bind, listen und accept

bind

listen()

accept()

struct sockaddr_in AdrMySock, AdrPartnerSocket; ... AdrMySock.sin_family = AF_INET; AdrMySock.sin_addr.s_addr = INADDR_ANY; /* akzept. jeden */ AdrMySock.sin_port = PortNr; /* per getservbyname bestimmt */ bind(IDMySocket, &AdrMySock, sizeof(AdrMySock)); listen(IDMySock, 5); do { IDPartnerSocket = accept(IDMySocket, &AdrPartnerSocket, &len);

Nicht zu vergessen: die IDPartnerSocket muss nach Ende der Kommunikation geschlossen werden, obwohl sie nicht explizit geöffnet wurde.

Clientaufruf: connect

connect schlägt die Verbindung zum Server

struct sockaddr_in AdrSock; AdrSock.sin_addr = HostID; AdrSock.sin_port = PortNr; connect(IDSocket, (struct sockaddr*)&AdrSock, sizeof(AdrSock));

connect() liefert als Rückgabe eine 0, wenn alles funktioniert und im Fehlerfall eine -1.

Datenaustausch: send und recv

Namensauflösung

struct hostent *RechnerID; struct servent *Service; /* Bestimme den Rechner namens server */ RechnerID = gethostbyname("server"); /* Bestimme den Port für hilfe */ Service = getservbyname("hilfe","tcp");

gethostbyname()

getservbyname()

Zahlendreher ntoh und hton

Um beispielsweise den Port des POP3 (110) in die sock_add_in-Struktur zu schreiben, würde man hton verwenden. Wird an dieser Stelle getservbyname verwendet, erledigt sich die Notwendigkeit von hton.

struct sockaddr_in AdrSock; AdrSock.sin_port = hton(110);

Rahmenprogramm eines Client-Server Paars

#include <sys/types.h>
#ifdef WIN32
#include <winsock.h>
// link with Ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netdb.h>
#include <sys/signal.h>
#include <unistd.h>
#define closesocket close
#endif

#define MAXPUF 1024
#define WELLKNOWNPORT 5000

#include <iostream>

int main()
{
#ifdef WIN32
    // Windows muss da erst initialisieren!
    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed: %d\n", iResult);
        return 1;
    }
#endif

    char Puffer[MAXPUF];
    int IDMySocket = socket(AF_INET, SOCK_STREAM, 0);
    if (IDMySocket == 0)
    {
        std::cout << "socket liefert 0 "  << std::endl;
        return 1;
    }
    // Socket-Parameter festlegen
    struct sockaddr_in AdrMySock = { 0 };
    AdrMySock.sin_family = AF_INET;
    AdrMySock.sin_addr.s_addr = INADDR_ANY; // akzept. jeden
    AdrMySock.sin_port = htons(WELLKNOWNPORT);
    // Die Partner-Socket-Struktur wird bei accept ermittelt
    struct sockaddr_in AdrPartnerSocket;
    // int AdrLen = sizeof(struct sockaddr);
    socklen_t AdrLen = sizeof(struct sockaddr);

    // Das Casting auf (sockaddr*) ist bei Windows erforderlich
    int error = bind(IDMySocket, (sockaddr*)&AdrMySock, sizeof(AdrMySock));
    if (error<0)
    {
        std::cout << "bind: " << error << std::endl;
    }
    error = listen(IDMySocket, 5);
    if (error<0)
    {
        std::cout << "listen: " << error << std::endl;
    }
    do {
        // Das Casting auf (sockaddr*) ist bei Windows erforderlich
        int IDPartnerSocket = accept(IDMySocket, (sockaddr*)&AdrPartnerSocket, &AdrLen);
        int MsgLen = recv(IDPartnerSocket, Puffer, MAXPUF, 0);
        if (MsgLen>0)
        {
            // tu was mit den Daten
            Puffer[0] = 'A'; // nur zum Test
        }
        send(IDPartnerSocket, Puffer, MsgLen, 0);
        closesocket(IDPartnerSocket); // Wichtig! Sonst gehen die Sockets aus
    } while (1); // bis zum St. Nimmerlein
    closesocket(IDMySocket);
}

Das Listing wurde ein klein wenig aktualisiert, weil sich ein paar Kleinigkeiten am Syntax von C und in den includes geändert haben. Die Ausgaben (std::cout, std::endl, include <iostream>) sind zwar C++. Der Rest ist aber noch reines C. Da einige Leute auch unter Windows programmieren müssen, sind die Besonderheiten von Windows mit ifdef WIN32 eingebaut.

Sequentielles Abarbeiten

#include <sys/types.h>
#ifdef WIN32
#undef UNICODE
#include <ws2tcpip.h> // getaddinfo
#include <winsock2.h>
// link with Ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netdb.h>
#include <unistd.h>
#define closesocket close
#include <string.h> // memcpy
#endif

#include <iostream>

#define MAXPUF 1024
#define WELLKNOWNPORT 5000
#define ZIELSERVER "127.0.0.1"

int main()
{
    struct sockaddr_in AdrSock;

    // struct servent *Service; // für Zugriff auf die /etc/services
    char Puffer[MAXPUF];

    int error;
#ifdef WIN32
    // Windows muss da erst initialisieren!
    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed: %d\n", iResult);
        return 1;
    }
    AdrSock.sin_addr.s_addr = inet_addr(ZIELSERVER);
#else
    struct hostent *RechnerID;
    RechnerID = gethostbyname(ZIELSERVER);
    if (RechnerID == 0)
    {
        std::cout << "Rechner " << ZIELSERVER << " unbekannt" << std::endl;
        return 1;
    }
    // bcopy(src, dest, len) -> memcpy(dest, src, len)
    memcpy(&AdrSock.sin_addr, RechnerID->h_addr, RechnerID->h_length);
#endif

    // Bestimme Port per Name aus der /etc/services
    //Service = getservbyname("servicename", "tcp");
    //AdrSock.sin_port = Service->s_port;
    // ... oder direkt ...
    AdrSock.sin_port = htons(WELLKNOWNPORT);
    AdrSock.sin_family = AF_INET;

    int IDSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (IDSocket <= 0)
    {
        std::cout << "Socketfehler - IDSocket: " << IDSocket << std::endl;
    }
    error = connect(IDSocket, (struct sockaddr *)&AdrSock, sizeof(AdrSock));
    if (error<0)
    {
        std::cout << "connect-Fehler" << std::endl;
    }
    error = send(IDSocket, "Uhu", 4, 0);
    if (error<0)
    {
        std::cout << "send-Fehler" << std::endl;
    }
    int len = recv(IDSocket, Puffer, MAXPUF, 0);
    std::cout << Puffer[0] << "/" << len << std::endl;
    closesocket(IDSocket);
}

Variablen

Parallelität

do { IDPartnerSocket = accept(IDMySocket, &AdrPartnerSocket, &len); if (fork()==0) { MsgLen = recv(IDPartnerSocket, Puffer, MAXPUF, 0); /* tu was mit den Daten */ send(IDPartnerSocket, Puffer, MsgLen, 0); close(IDPartnerSocket); /* Sohn toetet sich selbst */ exit(0); } /* if fork.. */ close(IDPartnerSocket); /* der Vater schliesst Verbindung */ } while(1);

Parallelverarbeitung mit wenig Aufwand

Statusloser Server

Zombies vereiteln

signal(SIGCLD, SIG_IGN);

Mehrere Sockets parallel abfragen

#include <sys/time.h> #include <sys/types.h> #include <unistd.h> int select(int MaxHandle}, fd_set *Lesen, fd_set *Schreiben}, fd_set *OutOfBand, struct timeval *TimeOut);

Zentrale Objekte sind in diesem Zusammenhang die Dateideskriptorenarrays. Von diesen nimmt select() drei an. Da gibt es je einen Satz zum Lesen, zum Schreiben oder um Ausnahmen, wie Nachrichten außerhalb der Reihe zu beobachten. Will man nicht alle Kategorien beobachten, gibt man bei den uninteressanten Parametern NULL an. Sollen die Socket a und b zum Lesen beobachtet werden, dann muss ein fd_set angelegt und damit gefüllt werden:

fd_set lesesockets; FD_ZERO(&lesesockets); FD_SET(a, &lesesockets); FD_SET(b, &lesesockets); maxHandle = max(a, b) + 1; select(maxHandle, &lesesockets, NULL, NULL, NULL);

select() blockiert so lange, bis auf einem der Sockets Daten ankommen. Soll ein Timeout definiert werden, also eine Zeitspanne, nach der aufgegeben werden soll, so muss der letzte Parameter besetzt werden.

struct timeval myTime; ... myTime.tv_sec = 0; myTime.tv_usec = 100; select(maxHandle, &lesesockets, NULL, NULL, &myTime);

Ersatz für sleep

IPv6 aus Programmierersicht

struct in6_addr { uint8_t s6_addr[16];

Durch diese Änderung ist dann auch die Struktur sockaddr_in betroffen, die nun als sockaddr_in6 folgendermaßen definiert ist:

struct sockadd_in6 { sa_family_t sin6_family; in_port_t sin6_port; uint32_t sin6_flowinfo; struct in6_address sin6_addr; }

Die Umsetzung zwischen Hostname zu IP-Nummer wird nicht mehr mit den Funktionen gethostbyname() bzw. gethostbyaddr(), sondern durch die neuen Funktionen getnodebyname() bzw. getnodebyaddr() erledigt.\gpFussnote{vgl. Santifaller, Michael: TCP/IP und ONC/NFS - Internetworking mit UNIX. Addison-Wesley, 1998. S. 365}

Client-Server aus Sicht der Performance

Das Modell Terminal

Das Modell Plattenserver

Suche nach dem Teilungspunkt