TCP/IP: vad är det, protokollstack och dataöverföring

Vad är TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) är en protokollstack som utvecklades på 1970-talet för ARPANET och blev de facto-standard för det globala internetnätverket. Den bestämmer hur data delas upp i paket, adresseras, överförs och sätts samman hos mottagaren.

TCP/IP-arkitekturen är byggd på en flerskiktsprincip där varje lager abstraherar specifika funktioner. Applikationslagret arbetar med applikationsdata, transportlagret säkerställer tillförlitlighet, nätverkslagret hanterar routning och länklagret hanterar överföring via det fysiska mediet. Modularitet gör det möjligt att byta ut protokoll inom ett lager utan att ändra angränsande lager.

Inom mobilutveckling används TCP/IP av varje applikation som utför nätverksförfrågningar. Biblioteken URLSession, OkHttp, AFNetworking och Alamofire arbetar ovanpå denna stack och döljer detaljerna kring paketering och routning för utvecklaren. Att förstå TCP/IP är dock nödvändigt för prestandaoptimering: konfigurering av TCP-parametrar via URLSessionConfiguration gör det möjligt att hantera timeout, underhålla HTTP Persistent Connections och ställa in proxy för företagsmiljöer.

Förståelse av TCP/IP är nödvändig för att diagnostisera nätverksproblem: om applikationen inte kan ansluta till servern kan problemet finnas på vilket lager som helst i stacken — från den fysiska kanalen till applikationsprotokollet. Verktyg som tcpdump, Wireshark och Charles Proxy gör det möjligt att analysera trafik på varje lager och hitta flaskhalsar. För mobilutvecklare tillhandahåller Xcode en Network Debug Dashboard och Android Studio en Network Inspector för realtidsanalys av TCP-anslutningar.

Lagren i TCP/IP-modellen

TCP/IP-modellen omfattar fyra lager, som var och en utför strikt definierade funktioner vid dataöverföring. Förståelse av denna hierarki är nödvändig för att diagnostisera nätverksproblem och optimera applikationer.

Applikationslagret

På applikationslagret arbetar protokoll som applikationer direkt interagerar med: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Detta lager formaterar data i ett format som är begripligt för applikationen och skickar det till transportlagret. Utvecklare av mobila applikationer arbetar på detta lager via nätverksbibliotek.

Transportlagret

Transportlagret säkerställer dataöverföring mellan applikationer på olika enheter. Huvudprotokoll: TCP (tillförlitlig överföring med bekräftelse) och UDP (snabb överföring utan garantier). TCP lägger till avsändarens och mottagarens port till data, hanterar paketordning och kontrollerar nätverksöverbelastning.

Nätverks- och länklagret

Nätverkslagret implementeras av IP-protokollet, som bestämmer adressering (IPv4, IPv6) och paketroutning. Varje paket innehåller avsändarens och mottagarens IP-adress, och routrar på överföringsvägen beslutar om nästa nod baserat på routingtabeller. IPv4 använder 32-bitars adresser (cirka 4,3 miljarder) och IPv6 använder 128-bitars adresser, vilket löser problemet med adressutarmning.

Länklagret arbetar med det fysiska överföringsmediet: Ethernet, Wi-Fi, Bluetooth. Detta lager omvandlar paket till signaler och vice versa, hanterar åtkomst till överföringsmediet via MAC-adresser och upptäcker fel på fysisk nivå med hjälp av ramkontrollsummor (FCS).

På länklagret arbetar protokoll som ARP (Address Resolution Protocol), som omvandlar IP-adresser till MAC-adresser för enheter i det lokala nätverket, och PPP (Point-to-Point Protocol), som används i VPN-anslutningar och mobila dataöverföringsnätverk.

Hur TCP-protokollet fungerar

TCP (Transmission Control Protocol) är ett av huvudprotokollen i transportlagret. Det säkerställer tillförlitlig, ordnad och verifierbar leverans av en byteström mellan applikationer. Före dataöverföring etablerar TCP en anslutning genom en trevägshandskakning.

Trevägshandskakningen (three-way handshake) börjar med att klienten skickar ett SYN-paket. Servern svarar med ett SYN-ACK-paket och bekräftar mottagandet. Klienten slutför handskakningen med ett ACK-paket, varefter dataöverföringen börjar. Denna process garanterar att båda parter är redo för utbyte och synkroniserade när det gäller sekvensnummer.

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

I exemplet skapas en TCP-socket av typen SOCK_STREAM, som automatiskt utför trevägshandskakningen vid anrop av connect. Metoden send skickar en HTTP-förfrågan, recv tar emot svaret. Efter slutförande skickar close ett FIN-paket för korrekt stängning av anslutningen.

TCP-server med klienthantering

Låt oss titta på ett exempel på en TCP-server i Python som accepterar flera klienter via trådar. Varje anslutning bearbetas i en separat tråd, vilket gör det möjligt att betjäna många klienter samtidigt utan att blockera huvudloopen.

import socket
import threading

def handle_client(conn, addr):
    print(f'Klient ansluten: {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'Klient {addr} frånkopplad')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('TCP-server startad på port 9090')

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

TCP-servern bearbetar varje anslutning i en separat tråd genom att anropa accept i en oändlig loop. Funktionen handle_client tar emot data, konverterar dem till versaler och skickar tillbaka via sendall. När recv-loopen avslutas (när klienten har stängt anslutningen) avslutas tråden och socketen stängs automatiskt. I mobila applikationer används sådant lågnivåarbete med sockets inte direkt — mobila HTTP-bibliotek hanterar anslutningar via trådpooler och återanvänder automatiskt TCP-anslutningar.

Skillnader mellan TCP och UDP

Valet mellan TCP och UDP är ett av de viktigaste besluten vid design av nätverksinteraktion. TCP garanterar leverans, ordning och dataintegritet till priset av extra fördröjning. UDP offrar tillförlitlighet för minimal fördröjning och lägre belastning på kanalen.

För mobila applikationer beror protokollvalet på scenariot: REST-API och datanedladdning kräver TCP, medan videosamtal och onlinespel drar nytta av UDP:s hastighet. Vissa applikationer kombinerar båda protokollen — TCP för kontroll och UDP för mediaströmning. Det moderna QUIC-protokollet, som fungerar ovanpå UDP och används i HTTP/3, kombinerar fördelarna med båda metoderna och stöds redan automatiskt på iOS och Android via URLSession.

Kodexempel för TCP/IP

Låt oss titta på ett exempel på en TCP-klient i Python med felhantering och timeout. Denna metod används i mobila applikationer för tillförlitlig anslutning till servern.

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'Ansluten till {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Anslutningsfel: {err}')
        sys.exit(1)

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

Funktionen tcp_client tar emot host och port, skapar en socket med en timeout på 10 sekunder och försöker ansluta. Vid anslutningsfel — till exempel att servern inte är tillgänglig eller blockerad av brandvägg — kastas ett undantag med en beskrivning av problemet. I mobila applikationer är anslutningstimeout kritisk: för kort leder till falska fel på långsamma nätverk, för lång leder till att gränssnittet fryser. Rekommenderat värde för mobila nätverk är 10–15 sekunder för timeoutIntervalForRequest och 30–60 sekunder för timeoutIntervalForResource i URLSession-konfigurationen.