TCP/IP: mi ez, protokollverem és adatátvitel

Mi az a TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) egy protokollverem, amelyet az 1970-es években fejlesztettek ki az ARPANET számára, és amely a globális internetes hálózat de facto szabványává vált. Meghatározza, hogy az adatok hogyan kerülnek csomagokra bontásra, címzésre, továbbításra és összeállításra a fogadó oldalon.

A TCP/IP architektúra többrétegű elvre épül, ahol minden réteg bizonyos funkciókat absztrahál. Az alkalmazási réteg az alkalmazás adataival dolgozik, a szállítási réteg biztosítja a megbízhatóságot, a hálózati réteg az útválasztást végzi, a kapcsolati réteg pedig a fizikai közegen keresztüli továbbítást. A modularitás lehetővé teszi a protokollok cseréjét egy rétegen belül anélkül, hogy a szomszédos rétegeket meg kellene változtatni.

A mobilfejlesztésben a TCP/IP-t minden olyan alkalmazás használja, amely hálózati kéréseket hajt végre. Az URLSession, OkHttp, AFNetworking és Alamofire könyvtárak ezen a vermen működnek, elrejtve a fejlesztő elől a csomagok becsomagolásának és útválasztásának részleteit. Azonban a TCP/IP megértése szükséges a teljesítmény optimalizálásához: a TCP paraméterek konfigurálása a URLSessionConfiguration segítségével lehetővé teszi az időtúllépések kezelését, a HTTP Persistent Connections fenntartását és a proxy beállítását vállalati környezetekben.

A TCP/IP megértése szükséges a hálózati problémák diagnosztizálásához: ha az alkalmazás nem tud csatlakozni a szerverhez, a probléma a verem bármely rétegében lehet — a fizikai csatornától az alkalmazási protokollig. Az olyan eszközök, mint a tcpdump, a Wireshark és a Charles Proxy, lehetővé teszik a forgalom elemzését minden rétegben és a szűk keresztmetszetek megtalálását. Mobil fejlesztők számára az Xcode Network Debug Dashboard-ot, az Android Studio pedig Network Inspector-t biztosít a TCP kapcsolatok valós idejű elemzéséhez.

A TCP/IP modell rétegei

A TCP/IP modell négy réteget foglal magában, amelyek mindegyike szigorúan meghatározott funkciókat lát el az adatok továbbítása során. Ennek a hierarchiának a megértése szükséges a hálózati problémák diagnosztizálásához és az alkalmazások optimalizálásához.

Alkalmazási réteg

Az alkalmazási rétegben olyan protokollok működnek, amelyekkel az alkalmazások közvetlenül interakcióba lépnek: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Ez a réteg az alkalmazás számára érthető formátumba alakítja az adatokat, és továbbítja a szállítási rétegnek. A mobilalkalmazás-fejlesztők pontosan ezen a rétegen dolgoznak a hálózati könyvtárakon keresztül.

Szállítási réteg

A szállítási réteg biztosítja az adatok továbbítását a különböző eszközökön futó alkalmazások között. Főbb protokollok: TCP (megbízható továbbítás visszaigazolással) és UDP (gyors továbbítás garanciák nélkül). TCP hozzáadja az adatokhoz a feladó és a címzett portját, kezeli a csomagok sorrendjét és szabályozza a hálózati torlódást.

Hálózati és kapcsolati réteg

A hálózati réteget az IP protokoll valósítja meg, amely meghatározza a címzést (IPv4, IPv6) és a csomagok útválasztását. Minden csomag tartalmazza a feladó és a címzett IP-címét, az útvonalon lévő routerek pedig az útválasztási táblák alapján döntenek a következő csomópontról. Az IPv4 32 bites címeket használ (körülbelül 4,3 milliárd), az IPv6 pedig 128 bites címeket, ami megoldja a címkimerülés problémáját.

A kapcsolati réteg a fizikai átviteli közeggel dolgozik: Ethernet, Wi-Fi, Bluetooth. Ez a réteg a csomagokat jelekké alakítja és vissza, kezeli az átviteli közeghez való hozzáférést MAC-címeken keresztül, és érzékeli a fizikai réteg hibáit keret-ellenőrző összegek (FCS) segítségével.

A kapcsolati rétegben olyan protokollok működnek, mint az ARP (Address Resolution Protocol), amely az IP-címeket a helyi hálózat eszközeinek MAC-címeivé alakítja, és a PPP (Point-to-Point Protocol), amelyet VPN-kapcsolatokban és mobil adatátviteli hálózatokban használnak.

Hogyan működik a TCP protokoll

TCP (Transmission Control Protocol) a szállítási réteg egyik fő protokollja. Megbízható, rendezett és hibaellenőrzött bájtfolyam-kézbesítést biztosít az alkalmazások között. Az adatok továbbítása előtt a TCP kapcsolatot létesít egy háromlépcsős kézfogással.

A háromlépcsős kézfogás (three-way handshake) a kliens SYN csomagjának elküldésével kezdődik. A szerver SYN-ACK csomaggal válaszol, megerősítve a vételt. A kliens ACK csomaggal fejezi be a kézfogást, ami után megkezdődik az adatok továbbítása. Ez a folyamat garantálja, hogy mindkét fél készen áll a cserére és szinkronizálva van a sorszámok tekintetében.

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

A példában egy SOCK_STREAM típusú TCP socket jön létre, amely a connect meghívásakor automatikusan végrehajtja a háromlépcsős kézfogást. A send metódus HTTP-kérést küld, a recv fogadja a választ. Befejezés után a close FIN csomagot küld a kapcsolat megfelelő lezárásához.

TCP szerver kliensfeldolgozással

Nézzünk egy példát TCP szerverre Pythonban, amely több klienst fogad szálakon keresztül. Minden kapcsolat egy külön szálban kerül feldolgozásra, ami lehetővé teszi több kliens egyidejű kiszolgálását anélkül, hogy a főciklus blokkolódna.

import socket
import threading

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

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('TCP szerver elindítva a 9090-es porton')

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

A TCP szerver minden kapcsolatot egy külön szálban dolgoz fel, az accept-et egy végtelen ciklusban hívva. A handle_client függvény fogadja az adatokat, nagybetűssé alakítja, és a sendall segítségével visszaküldi. Amikor a recv ciklus véget ér (amikor a kliens bezárta a kapcsolatot), a szál befejeződik és a socket automatikusan bezárul. Mobilalkalmazásokban az ilyen alacsony szintű socket-munka nem használatos közvetlenül — a mobil HTTP könyvtárak szálkészleteken keresztül kezelik a kapcsolatokat és automatikusan újrahasznosítják a TCP kapcsolatokat.

A TCP és az UDP közötti különbségek

A TCP és az UDP közötti választás az egyik kulcsfontosságú döntés a hálózati interakció tervezésekor. TCP garantálja a kézbesítést, a sorrendet és az adatok integritását további késleltetés árán. UDP feláldozza a megbízhatóságot a minimális késleltetés és a kisebb csatornaterhelés érdekében.

Mobilalkalmazások esetében a protokollválasztás a forgatókönyvtől függ: a REST-API és az adatletöltés TCP-t igényel, míg a videohívások és az online játékok az UDP sebességéből profitálnak. Egyes alkalmazások mindkét protokollt kombinálják — TCP-t a vezérléshez és UDP-t a médiafolyamhoz. A modern QUIC protokoll, amely az UDP felett működik és a HTTP/3-ban használatos, egyesíti mindkét megközelítés előnyeit, és már automatikusan támogatott iOS-en és Androidon az URLSession-en keresztül.

TCP/IP kódpéldák

Nézzünk egy példát TCP kliensre Pythonban hibakezeléssel és időtúllépéssel. Ezt a megközelítést használják a mobilalkalmazások a szerverhez való megbízható csatlakozáshoz.

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'Csatlakozva a {host}:{port} címhez')
        return sock
    except socket.error as err:
        print(f'Kapcsolódási hiba: {err}')
        sys.exit(1)

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

A tcp_client függvény hostot és portot fogad, létrehoz egy socketet 10 másodperces időtúllépéssel, és megpróbál csatlakozni. Kapcsolódási hiba esetén — például a szerver elérhetetlensége vagy tűzfalblokkolás — egy kivétel dobódik le a probléma leírásával. Mobilalkalmazásokban a kapcsolódási időtúllépés kritikus: túl rövid hamis hibákhoz vezet lassú hálózatokon, túl hosszú a felület lefagyásához. Az ajánlott érték mobil hálózatokhoz 10–15 másodperc a timeoutIntervalForRequest és 30–60 másodperc a timeoutIntervalForResource számára az URLSession konfigurációban.