Vorlesung 9

Lernziele

Rückblick: bisher alles auf einem Rechner

In VL 8 liefen mehrere Prozesse/Threads nebeneinander — aber alle auf derselben Maschine, mit gemeinsamem Speicher.

Wie reden zwei Prozesse überhaupt? — IPC

Interprozesskommunikation (IPC) — abhängig davon, wo die Prozesse stehen:

Das Grundbild: Client fragt, Server antwortet

Fast jede Netz-Kommunikation folgt diesem Muster — wie im Restaurant: ihr bestellt, die Küche liefert.

Was ist ein Socket?

Ein Socket ist der Endpunkt einer Verbindung — eine „Steckdose", in die euer Programm Daten hineinschreibt und herausliest.

Die Adresse: IP + Port

Damit eine Nachricht das richtige Programm erreicht, braucht es zwei Angaben:

Ein Rechner, viele Türen — die Ports

Die IP führt zum richtigen Rechner. Aber dort laufen viele Programme gleichzeitig — der Port sagt, welches gemeint ist.

Zwei Transport-Wege: TCP & UDP

Auf Sockets gibt es zwei Grund-Protokolle — mit komplett unterschiedlicher Philosophie:

TCP — der Ablauf in Socket-Aufrufen

Server und Client durchlaufen feste Schritte. Der Server wartet, der Client verbindet sich.

Wie eine TCP-Verbindung entsteht: der 3-Wege-Handshake

Bevor auch nur ein Byte Nutzdaten fließt, begrüßen sich Client und Server in drei Schritten — wie ein Händedruck:

TCP-Server in C

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main(void) {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);   // 1. Socket erstellen

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port   = htons(8080);          // Port (Byte-Order!)
    addr.sin_addr.s_addr = INADDR_ANY;        // alle Netzwerk-Interfaces

    bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)); // 2. Port belegen
    listen(server_fd, 5);                                  // 3. Lauschen

    int client = accept(server_fd, NULL, NULL);  // 4. Auf Client warten

    char buf[1024];
    int n = recv(client, buf, sizeof(buf)-1, 0); // 5. schreibt Client-Bytes IN buf
    buf[n] = '\0';
    printf("Empfangen: %s\n", buf);
    send(client, buf, n, 0);                  // 6. Echo: dieselben Bytes aus buf zurück

    close(client);  close(server_fd);
    return 0;
}

TCP-Client in C

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main(void) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);      // 1. Socket

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port   = htons(8080);
    inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);   // Server-IP

    connect(sock, (struct sockaddr*)&addr, sizeof(addr)); // 2. Verbinden

    char *msg = "Hallo Server!";
    send(sock, msg, strlen(msg), 0);             // 3. Senden

    char buf[1024];
    int n = recv(sock, buf, sizeof(buf)-1, 0);  // 4. Antwort empfangen
    buf[n] = '\0';
    printf("Server antwortete: %s\n", buf);

    close(sock);
    return 0;
}

Server + Client im Zusammenspiel — der ganze Ablauf

So greifen die beiden Programme von vorhin ineinander. Lies von oben nach unten:

Warum htons()? — die Byte-Reihenfolge

Verschiedene CPUs speichern Zahlen in unterschiedlicher Byte-Reihenfolge. Über das Netz muss man sich auf eine einigen.

Kurzer Zwischenstand — wo stehen wir?

Bevor wir UDP anschauen — das habt ihr bis hier in der Hand:

UDP in C — verbindungslos, kürzer

UDP ist verbindungslos: man verschickt einzelne Pakete (Datagramme) — ganz ohne vorher eine Leitung aufzubauen. Darum ist der Code kürzer.

int s = socket(AF_INET, SOCK_DGRAM, 0);
// addr füllen (Port 9090, INADDR_ANY)
bind(s, (struct sockaddr*)&addr, sizeof(addr));

struct sockaddr_in cli;
socklen_t len = sizeof(cli);
char buf[1024];
int n = recvfrom(s, buf, 1023, 0,
       (struct sockaddr*)&cli, &len);
sendto(s, buf, n, 0,
       (struct sockaddr*)&cli, len); // Echo

int s = socket(AF_INET, SOCK_DGRAM, 0);
// addr füllen (127.0.0.1, Port 9090)

char *msg = "Hallo UDP!";
sendto(s, msg, strlen(msg), 0,
       (struct sockaddr*)&addr, sizeof(addr));

char buf[1024];
int n = recvfrom(s, buf, 1023, 0,
       NULL, NULL);

Warum „zuverlässig" vs. „schnell"? — die Pakete

TCP vs. UDP — wann was?

Was reist eigentlich durch den Socket?

Ein Socket transportiert nur rohe Bytes — er weiß nichts über deren Bedeutung. Sender und Empfänger müssen sich auf ein Format einigen.

{ "typ": "messung", "sensor": 3, "wert": 21.5 }

Sockets sind das Fundament — alles sitzt darauf

Was ihr in diesem Kurs schon gesehen habt, läuft unten über Sockets:

🔧 Selbst ausprobieren — in 30 Sekunden

Ihr braucht nicht mal den Client zu schreiben: startet den Echo-Server von vorhin und verbindet euch mit netcat (nc), das auf fast jedem System dabei ist.

$ gcc server.c -o server
$ ./server
# wartet auf Port 8080 ...
Empfangen: Hallo!

$ nc 127.0.0.1 8080
Hallo!          ← ihr tippt
Hallo!          ← Echo vom Server

🧠 Quiz

→ Klicke auf eine Antwort, um aufzulösen

Zusammenfassung

📚 Quellen & zum Ausprobieren