TCP/IP: Was ist das, Protokollstapel und Datenübertragung

Was ist TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) ist ein Protokollstapel, der in den 1970er Jahren für ARPANET entwickelt wurde und zum De-facto-Standard für das globale Internet geworden ist. Er definiert, wie Daten in Pakete aufgeteilt, adressiert, übertragen und auf der Empfängerseite wieder zusammengesetzt werden.

Die TCP/IP-Architektur ist nach dem Mehrschichtprinzip aufgebaut, bei dem jede Schicht bestimmte Funktionen abstrahiert. Die Anwendungsschicht arbeitet mit Anwendungsdaten, die Transportschicht gewährleistet Zuverlässigkeit, die Netzwerkschicht übernimmt das Routing und die Verbindungsschicht verwaltet die physische Übertragung. Modularität ermöglicht den Austausch von Protokollen innerhalb einer Schicht, ohne benachbarte Schichten zu beeinträchtigen.

In der mobilen Entwicklung wird TCP/IP von jeder Anwendung verwendet, die Netzwerkanfragen stellt. Bibliotheken wie URLSession, OkHttp, AFNetworking und Alamofire arbeiten auf diesem Stapel und verbergen die Details der Paketverpackung und Weiterleitung vor dem Entwickler. Das Verständnis von TCP/IP ist jedoch für die Leistungsoptimierung erforderlich: Die Konfiguration von TCP-Parametern über URLSessionConfiguration ermöglicht die Verwaltung von Zeitüberschreitungen, die Aufrechterhaltung von HTTP-Persistent-Verbindungen und die Einrichtung von Proxys für Unternehmensumgebungen.

Das Verständnis von TCP/IP ist für die Diagnose von Netzwerkproblemen unerlässlich: Wenn eine Anwendung keine Verbindung zu einem Server herstellen kann, kann das Problem auf jeder Schicht des Stapels liegen — vom physischen Kanal bis zum Anwendungsprotokoll. Tools wie tcpdump, Wireshark und Charles Proxy ermöglichen die Analyse des Datenverkehrs auf jeder Schicht und das Auffinden von Engpässen. Für mobile Entwickler bietet Xcode ein Network Debug Dashboard und Android Studio einen Network Inspector zur Analyse von TCP-Verbindungen in Echtzeit.

Schichten des TCP/IP-Modells

Das TCP/IP-Modell umfasst vier Schichten, die jeweils streng definierte Funktionen während der Datenübertragung ausführen. Das Verständnis dieser Hierarchie ist für die Diagnose von Netzwerkproblemen und die Optimierung von Anwendungen notwendig.

Anwendungsschicht

Auf der Anwendungsschicht arbeiten Protokolle, mit denen Anwendungen direkt interagieren: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Diese Schicht formatiert Daten in einer Weise, die die Anwendung versteht, und übergibt sie an die Transportschicht. Mobile Anwendungsentwickler arbeiten auf dieser Schicht über Netzwerkbibliotheken.

Transportschicht

Die Transportschicht gewährleistet die Datenübertragung zwischen Anwendungen auf verschiedenen Geräten. Die wichtigsten Protokolle sind TCP (zuverlässige Übertragung mit Bestätigung) und UDP (schnelle Übertragung ohne Garantien). TCP fügt den Daten Sender- und Empfängerports hinzu, verwaltet die Paketreihenfolge und kontrolliert die Netzwerküberlastung.

Netzwerk- und Verbindungsschicht

Die Netzwerkschicht wird durch das IP-Protokoll implementiert, das die Adressierung (IPv4, IPv6) und Paketweiterleitung definiert. Jedes Paket enthält die IP-Adressen des Senders und Empfängers, und Router entlang des Wegs treffen Entscheidungen über den nächsten Knoten basierend auf Routing-Tabellen. IPv4 verwendet 32-Bit-Adressen (etwa 4,3 Milliarden), während IPv6 128-Bit-Adressen verwendet, was das Problem der Adressknappheit löst.

Die Verbindungsschicht arbeitet mit dem physischen Übertragungsmedium: Ethernet, Wi-Fi, Bluetooth. Diese Schicht wandelt Pakete in Signale um und zurück, verwaltet den Zugriff auf das Übertragungsmedium über MAC-Adressen und erkennt Fehler der physischen Schicht mithilfe von Frame-Check-Sequenzen (FCS).

Auf der Verbindungsschicht arbeiten Protokolle wie ARP (Address Resolution Protocol), das IP-Adressen in MAC-Adressen von Geräten im lokalen Netzwerk umwandelt, und PPP (Point-to-Point Protocol), das in VPN-Verbindungen und mobilen Datennetzen verwendet wird.

Wie funktioniert das TCP-Protokoll

TCP (Transmission Control Protocol) ist eines der wichtigsten Protokolle der Transportschicht. Es gewährleistet die zuverlässige, geordnete und fehlergeprüfte Zustellung eines Bytestroms zwischen Anwendungen. Vor der Datenübertragung stellt TCP eine Verbindung durch einen Drei-Wege-Handschlag her.

Der Drei-Wege-Handschlag (Three-Way Handshake) beginnt mit dem Senden eines SYN-Pakets durch den Client. Der Server antwortet mit einem SYN-ACK-Paket und bestätigt den Empfang. Der Client schließt den Handschlag mit einem ACK-Paket ab, woraufhin die Datenübertragung beginnt. Dieser Prozess stellt sicher, dass beide Parteien für den Austausch bereit und hinsichtlich der Sequenznummern synchronisiert sind.

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))
sock.send(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
response = sock.recv(4096)
print(response.decode())
sock.close()

Im Beispiel wird ein TCP-Socket mit dem Typ SOCK_STREAM erstellt, der beim Aufruf von connect automatisch den Drei-Wege-Handschlag durchführt. Die send-Methode überträgt eine HTTP-Anfrage und recv empfängt die Antwort. Nach Abschluss sendet close ein FIN-Paket, um die Verbindung ordnungsgemäß zu schließen.

TCP-Server mit Client-Verarbeitung

Betrachten wir ein Beispiel eines TCP-Servers in Python, der mehrere Clients über Threads akzeptiert. Jede Verbindung wird in einem separaten Thread verarbeitet, sodass mehrere Clients gleichzeitig bedient werden können, ohne die Hauptschleife zu blockieren.

import socket
import threading

def handle_client(conn, addr):
    print(f'Client verbunden: {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'Client {addr} getrennt')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('TCP-Server gestartet auf Port 9090')

while True:
    conn, addr = server.accept()
    thread = threading.Thread(target=handle_client, args=(conn, addr))
    thread.start()

Der TCP-Server verarbeitet jede Verbindung in einem separaten Thread, indem er accept in einer Endlosschleife aufruft. Die Funktion handle_client empfängt Daten, wandelt sie in Großbuchstaben um und sendet sie über sendall zurück. Wenn die recv-Schleife endet (wenn der Client die Verbindung schließt), wird der Thread beendet und der Socket automatisch geschlossen. In mobilen Anwendungen wird diese niedrige Socket-Ebene nicht direkt verwendet — mobile HTTP-Bibliotheken verwalten Verbindungen über Thread-Pools und verwenden TCP-Verbindungen automatisch wieder.

Unterschiede zwischen TCP und UDP

Die Wahl zwischen TCP und UDP ist eine der wichtigsten Entscheidungen beim Entwurf der Netzwerkkommunikation. TCP garantiert Zustellung, Reihenfolge und Datenintegrität auf Kosten zusätzlicher Latenz. UDP opfert Zuverlässigkeit für minimale Latenz und geringere Kanalbelastung.

Für mobile Anwendungen hängt die Protokollwahl vom Szenario ab: REST-APIs und Daten laden erfordern TCP, während Videoanrufe und Online-Spiele von der Geschwindigkeit von UDP profitieren. Einige Anwendungen kombinieren beide Protokolle — TCP für die Steuerung und UDP für den Medienstream. Das moderne QUIC-Protokoll, das über UDP läuft und in HTTP/3 verwendet wird, kombiniert die Vorteile beider Ansätze und wird auf iOS und Android bereits automatisch über URLSession unterstützt.

TCP/IP-Codebeispiele

Betrachten wir ein Beispiel eines TCP-Clients in Python mit Fehlerbehandlung und Zeitüberschreitung. Dieser Ansatz wird in mobilen Anwendungen für eine zuverlässige Serververbindung verwendet.

import socket
import sys

def tcp_client(host, port):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(10)
        sock.connect((host, port))
        print(f'Verbunden mit {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Verbindungsfehler: {err}')
        sys.exit(1)

sock = tcp_client('api.example.com', 443)
sock.close()

Die Funktion tcp_client nimmt einen Host und Port entgegen, erstellt einen Socket mit einem Timeout von 10 Sekunden und versucht, eine Verbindung herzustellen. Bei einem Verbindungsfehler — z. B. Server nicht verfügbar oder Firewall-Blockierung — wird eine Ausnahme mit einer Problembeschreibung ausgelöst. In mobilen Anwendungen ist der Verbindungs-Timeout kritisch: zu kurz führt zu falschen Fehlern in langsamen Netzwerken, zu lang führt zum Einfrieren der Benutzeroberfläche. Der empfohlene Wert für mobile Netzwerke liegt bei 10–15 Sekunden für timeoutIntervalForRequest und 30–60 Sekunden für timeoutIntervalForResource in der URLSession-Konfiguration.