TCP/IP: какво е това, стек от протоколи и предаване на данни

Какво е TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) е стек от протоколи, разработен през 70-те години на XX век за ARPANET, който се превърна в де факто стандарт за глобалната интернет мрежа. Той определя как данните се разделят на пакети, адресират, предават и сглобяват от страна на получателя.

Архитектурата на TCP/IP е изградена на многослоен принцип, където всеки слой абстрахира определени функции. Приложният слой работи с данни на приложението, транспортният слой осигурява надеждност, мрежовият слой се занимава с маршрутизиране, а каналният слой — с предаване чрез физическа среда. Модулността позволява замяна на протоколи в рамките на един слой без промяна на съседните слоеве.

В мобилната разработка TCP/IP се използва от всяко приложение, което изпълнява мрежови заявки. Библиотеките URLSession, OkHttp, AFNetworking и Alamofire работят върху този стек, скривайки от разработчика детайлите по опаковане и маршрутизиране на пакети. Въпреки това, разбирането на TCP/IP е необходимо за оптимизиране на производителността: конфигурирането на TCP параметри чрез URLSessionConfiguration позволява управление на тайм-аути, поддържане на HTTP Persistent Connections и настройване на прокси за корпоративни среди.

Разбирането на TCP/IP е необходимо за диагностициране на мрежови проблеми: ако приложението не може да се свърже със сървъра, проблемът може да е на всеки слой от стека — от физическия канал до приложния протокол. Инструменти като tcpdump, Wireshark и Charles Proxy позволяват анализ на трафика на всеки слой и откриване на тесни места. За мобилни разработчици Xcode предоставя Network Debug Dashboard, а Android Studio — Network Inspector за анализ на TCP връзки в реално време.

Слоеве на модела TCP/IP

Моделът TCP/IP включва четири слоя, всеки от които изпълнява строго определени функции при предаване на данни. Разбирането на тази йерархия е необходимо за диагностициране на мрежови проблеми и оптимизиране на приложения.

Приложен слой

На приложния слой работят протоколи, с които приложенията взаимодействат директно: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Този слой формира данни във формат, разбираем за приложението, и ги предава на транспортния слой. Разработчиците на мобилни приложения работят именно на този слой чрез мрежови библиотеки.

Транспортен слой

Транспортният слой осигурява предаване на данни между приложения на различни устройства. Основни протоколи: TCP (надеждно предаване с потвърждение) и UDP (бързо предаване без гаранции). TCP добавя към данните порт на подателя и получателя, управлява реда на пакетите и контролира претоварването на мрежата.

Мрежов и канален слой

Мрежовият слой се реализира от протокола IP, който определя адресирането (IPv4, IPv6) и маршрутизирането на пакети. Всеки пакет съдържа IP адрес на подателя и получателя, а маршрутизаторите по пътя на предаване вземат решение за следващия възъл въз основа на таблици за маршрутизиране. IPv4 използва 32-битови адреси (около 4,3 милиарда), а IPv6 използва 128-битови адреси, което решава проблема с изчерпването на адреси.

Каналният слой работи с физическата среда за предаване: Ethernet, Wi-Fi, Bluetooth. Този слой преобразува пакетите в сигнали и обратно, управлява достъпа до средата за предаване чрез MAC адреси и открива грешки на физическия слой с помощта на контролни суми на кадри (FCS).

На каналния слой работят протоколи като ARP (Address Resolution Protocol), който преобразува IP адреси в MAC адреси на устройства в локалната мрежа, и PPP (Point-to-Point Protocol), използван в VPN връзки и мобилни мрежи за предаване на данни.

Как работи протоколът TCP

TCP (Transmission Control Protocol) е един от основните протоколи на транспортния слой. Той осигурява надеждна, подредена и проверима доставка на поток от байтове между приложения. Преди предаване на данни, TCP установява връзка чрез тристепенно ръкостискане.

Тристепенното ръкостискане (three-way handshake) започва с изпращане на SYN пакет от клиента. Сървърът отговаря с SYN-ACK пакет, потвърждавайки получаването. Клиентът завършва ръкостискането с ACK пакет, след което започва предаването на данни. Този процес гарантира, че и двете страни са готови за обмен и синхронизирани по отношение на поредните номера.

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

В примера се създава TCP сокет от тип SOCK_STREAM, който автоматично извършва тристепенно ръкостискане при извикване на connect. Методът send изпраща HTTP заявка, recv получава отговор. След приключване, close изпраща FIN пакет за коректно затваряне на връзката.

TCP сървър с обработка на клиенти

Нека разгледаме пример за TCP сървър в Python, който приема множество клиенти чрез нишки. Всяка връзка се обработва в отделна нишка, което позволява едновременно обслужване на много клиенти без блокиране на основния цикъл.

import socket
import threading

def handle_client(conn, addr):
    print(f'Клиентът се свърза: {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'Клиентът {addr} се изключи')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('TCP сървърът стартира на порт 9090')

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

TCP сървърът обработва всяка връзка в отделна нишка, извиквайки accept в безкраен цикъл. Функцията handle_client получава данни, преобразува ги в главни букви и ги изпраща обратно чрез sendall. Когато цикълът recv приключи (когато клиентът затвори връзката), нишката завършва и сокетът се затваря автоматично. В мобилните приложения такава нисконивова работа със сокети не се използва директно — мобилните HTTP библиотеки управляват връзките чрез пулове от нишки и автоматично пренасочват TCP връзки.

Разлики между TCP и UDP

Изборът между TCP и UDP е едно от ключовите решения при проектиране на мрежово взаимодействие. TCP гарантира доставка, ред и цялост на данните с цената на допълнително забавяне. UDP жертва надеждността за минимално забавяне и по-малко натоварване на канала.

За мобилни приложения изборът на протокол зависи от сценария: REST-API и изтегляне на данни изискват TCP, докато видеоразговорите и онлайн игрите се възползват от скоростта на UDP. Някои приложения комбинират и двата протокола — TCP за управление и UDP за медиен поток. Съвременният протокол QUIC, работещ над UDP и използван в HTTP/3, съчетава предимствата на двата подхода и вече се поддържа автоматично на iOS и Android чрез URLSession.

Примери за код на TCP/IP

Нека разгледаме пример за TCP клиент в Python с обработка на грешки и тайм-аут. Този подход се използва в мобилни приложения за надеждна връзка със сървъра.

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'Свързан към {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Грешка при свързване: {err}')
        sys.exit(1)

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

Функцията tcp_client приема хост и порт, създава сокет с тайм-аут от 10 секунди и се опитва да се свърже. При грешка при свързване — например недостъпност на сървъра или блокиране от защитна стена — се хвърля изключение с описание на проблема. В мобилните приложения тайм-аутът за свързване е критичен: твърде кратък води до фалшиви грешки в бавни мрежи, твърде дълъг води до замръзване на интерфейса. Препоръчителната стойност за мобилни мрежи е 10–15 секунди за timeoutIntervalForRequest и 30–60 секунди за timeoutIntervalForResource в конфигурацията на URLSession.