TCP/IP: co to jest, stos protokołów i transmisja danych

Co to jest TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) to stos protokołów opracowany w latach 70. XX wieku dla ARPANET, który stał się standardem de facto dla globalnej sieci internet. Określa, w jaki sposób dane są dzielone na pakiety, adresowane, przesyłane i składane po stronie odbiorcy.

Architektura TCP/IP opiera się na zasadzie wielowarstwowej, gdzie każda warstwa abstrahuje określone funkcje. Warstwa aplikacji pracuje z danymi aplikacji, transportowa zapewnia niezawodność, sieciowa odpowiada za routing, a warstwa łącza danych za transmisję w środowisku fizycznym. Modułowość pozwala na wymianę protokołów wewnątrz warstwy bez zmiany sąsiednich.

W tworzeniu aplikacji mobilnych TCP/IP jest używany przez każdą aplikację wykonującą zapytania sieciowe. Biblioteki URLSession, OkHttp, AFNetworking i Alamofire działają na tym stosie, ukrywając przed programistą szczegóły pakowania i routingu pakietów. Jednak zrozumienie TCP/IP jest niezbędne przy optymalizacji wydajności: konfiguracja parametrów TCP poprzez URLSessionConfiguration pozwala zarządzać timeoutami, utrzymywać HTTP Persistent Connections i konfigurować proxy dla środowisk korporacyjnych.

Zrozumienie TCP/IP jest niezbędne do diagnozowania problemów sieciowych: jeśli aplikacja nie może połączyć się z serwerem, problem może leżeć na dowolnej warstwie stosu — od fizycznego kanału po protokół aplikacji. Narzędzia takie jak tcpdump, Wireshark i Charles Proxy pozwalają analizować ruch na każdej warstwie i znajdować wąskie gardła. Dla programistów mobilnych Xcode udostępnia Network Debug Dashboard, a Android Studio — Network Inspector do analizy połączeń TCP w czasie rzeczywistym.

Warstwy modelu TCP/IP

Model TCP/IP obejmuje cztery warstwy, z których każda wykonuje ściśle określone funkcje podczas przesyłania danych. Zrozumienie tej hierarchii jest niezbędne do diagnozowania problemów sieciowych i optymalizacji aplikacji.

Warstwa aplikacji

Na warstwie aplikacji działają protokoły, z którymi bezpośrednio współpracują aplikacje: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Ta warstwa formuje dane w formacie zrozumiałym dla aplikacji i przekazuje je do warstwy transportowej. Programiści aplikacji mobilnych pracują właśnie na tej warstwie poprzez biblioteki sieciowe.

Warstwa transportowa

Warstwa transportowa zapewnia transmisję danych między aplikacjami na różnych urządzeniach. Główne protokoły: TCP (niezawodna transmisja z potwierdzeniem) i UDP (szybka transmisja bez gwarancji). TCP dodaje do danych port nadawcy i odbiorcy, zarządza kolejnością pakietów i kontroluje przeciążenie sieci.

Warstwa sieciowa i warstwa łącza danych

Warstwa sieciowa jest realizowana przez protokół IP, który określa adresację (IPv4, IPv6) i routing pakietów. Każdy pakiet zawiera adres IP nadawcy i odbiorcy, a routery na ścieżce transmisji podejmują decyzję o następnym węźle na podstawie tablic routingu. IPv4 używa 32-bitowych adresów (około 4,3 mld), a IPv6 — 128-bitowych, co rozwiązuje problem wyczerpania adresów.

Warstwa łącza danych współpracuje z fizycznym medium transmisyjnym: Ethernet, Wi-Fi, Bluetooth. Ta warstwa przekształca pakiety w sygnały i odwrotnie, zarządza dostępem do medium poprzez adresy MAC i wykrywa błędy warstwy fizycznej za pomocą sum kontrolnych ramki (FCS).

Na warstwie łącza danych działają takie protokoły jak ARP (Address Resolution Protocol), który przekształca adresy IP na adresy MAC urządzeń w sieci lokalnej, oraz PPP (Point-to-Point Protocol), używany w połączeniach VPN i mobilnych sieciach transmisji danych.

Jak działa protokół TCP

TCP (Transmission Control Protocol) to jeden z głównych protokołów warstwy transportowej. Zapewnia niezawodną, uporządkowaną i weryfikowalną pod względem błędów dostawę strumienia bajtów między aplikacjami. Przed transmisją danych TCP ustanawia połączenie poprzez trójstopniowe uzgadnianie.

Trójstopniowe uzgadnianie (three-way handshake) rozpoczyna się od wysłania przez klienta pakietu SYN. Serwer odpowiada pakietem SYN-ACK, potwierdzając otrzymanie. Klient kończy handshake pakietem ACK, po czym rozpoczyna się transmisja danych. Ten proces gwarantuje, że obie strony są gotowe do wymiany i zsynchronizowane pod względem numerów sekwencyjnych.

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()

W przykładzie tworzony jest gniazdo TCP typu SOCK_STREAM, które automatycznie wykonuje trójstopniowe uzgadnianie przy wywołaniu connect. Metoda send wysyła żądanie HTTP, recv odbiera odpowiedź. Po zakończeniu close wysyła pakiet FIN w celu poprawnego zamknięcia połączenia.

Serwer TCP z obsługą klientów

Rozważmy przykład serwera TCP w Pythonie, który przyjmuje wielu klientów poprzez wątki. Każde połączenie jest obsługiwane w osobnym wątku, co pozwala obsługiwać wielu klientów jednocześnie bez blokowania głównej pętli.

import socket
import threading

def handle_client(conn, addr):
    print(f'Podłączono klienta: {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'Klient {addr} rozłączony')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('Serwer TCP uruchomiony na porcie 9090')

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

Serwer TCP obsługuje każde połączenie w osobnym wątku, wywołując accept w nieskończonej pętli. Funkcja handle_client odbiera dane, przekształca je na wielkie litery i wysyła z powrotem przez sendall. Po zakończeniu pętli recv (gdy klient zamknął połączenie) wątek kończy się, a gniazdo jest automatycznie zamykane. W aplikacjach mobilnych taka niskopoziomowa praca z gniazdami nie jest używana bezpośrednio — mobilne biblioteki HTTP zarządzają połączeniami poprzez pule wątków i automatycznie ponownie wykorzystują połączenia TCP.

Różnice między TCP a UDP

Wybór między TCP a UDP to jedna z kluczowych decyzji przy projektowaniu komunikacji sieciowej. TCP gwarantuje dostawę, kolejność i integralność danych kosztem dodatkowych opóźnień. UDP poświęca niezawodność na rzecz minimalnego opóźnienia i mniejszego obciążenia kanału.

Dla aplikacji mobilnych wybór protokołu zależy od scenariusza: REST-API i pobieranie danych wymagają TCP, a rozmowy wideo i gry online korzystają z szybkości UDP. Niektóre aplikacje łączą oba protokoły — TCP do zarządzania i UDP do strumienia multimediów. Nowoczesny protokół QUIC, działający na UDP i używany w HTTP/3, łączy zalety obu podejść i jest już obsługiwany na iOS i Androidzie przez URLSession automatycznie.

Przykłady kodu TCP/IP

Rozważmy przykład klienta TCP w Pythonie z obsługą błędów i timeoutem. Takie podejście jest używane w aplikacjach mobilnych do niezawodnego połączenia z serwerem.

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'Połączono z {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Błąd połączenia: {err}')
        sys.exit(1)

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

Funkcja tcp_client przyjmuje host i port, tworzy gniazdo z timeoutem 10 sekund i próbuje się połączyć. W przypadku błędu połączenia — na przykład niedostępności serwera lub blokady przez firewall — zgłaszany jest wyjątek z opisem problemu. W aplikacjach mobilnych timeout połączenia jest krytyczny: zbyt krótki prowadzi do fałszywych błędów w wolnych sieciach, zbyt długi — do zawieszania interfejsu. Zalecana wartość dla sieci mobilnych to 10–15 sekund dla timeoutIntervalForRequest i 30–60 sekund dla timeoutIntervalForResource w konfiguracji URLSession.