---
title: "Warstwa transportowa: TCP, UDP i porty"
domain: networking
level: beginner
duration: "50 min"
objectives:
  - Wyjaśnić zadanie warstwy transportowej i to, jak porty identyfikują procesy (porty dobrze znane, zarejestrowane i efemeryczne).
  - Porównać TCP i UDP (połączenia, niezawodność, kolejność, narzut) i wybrać jeden z nich dla danej aplikacji.
  - Opisać trójetapowy handshake TCP, zamykanie połączenia, numery sekwencyjne i potwierdzeń, retransmisję oraz kontrolę przepływu.
  - Rozpoznawać gniazda nasłuchujące i stany połączeń (LISTEN, ESTABLISHED, TIME_WAIT) za pomocą `ss` lub `netstat`.
  - Diagnozować „connection refused” w odróżnieniu od „connection timed out”.
lang: pl
source_hash: 6d1886187aec
---

# Warstwa transportowa: TCP, UDP i porty

## Dlaczego to ważne
Wdrażasz małą aplikację webową na serwerze i próbujesz ją otworzyć z laptopa. Przeglądarka pokazuje *connection refused* (połączenie odrzucone). Kolega próbuje minutę później z domu i dostaje *connection timed out* (przekroczono czas połączenia). Oba komunikaty znaczą „nie działa”, ale wskazują na zupełnie różne problemy. Pierwszy mówi, że serwer odpowiedział: „nikt tu nie nasłuchuje”. Drugi mówi, że nie odpowiedziało nic, więc pakiety zostały gdzieś po drodze odrzucone. Jeśli umiesz je odróżnić, wiesz, czy szukać w aplikacji, czy w zaporze.

Ta sama wiedza wyjaśnia codzienne zagadki. Dlaczego rozmowa wideo trwa mimo słabego Wi-Fi, a pobieranie pliku staje? Dlaczego mocno obciążony serwer pokazuje tysiące połączeń w stanie o nazwie `TIME_WAIT`? Dlaczego jeden serwer może uruchamiać serwer WWW i serwer Secure Shell (SSH) pod tym samym adresem Internet Protocol (IP)? Wszystkie odpowiedzi leżą w warstwie transportowej, domu Transmission Control Protocol (TCP) i User Datagram Protocol (UDP), czyli w temacie tej lekcji.

## Cele nauki
- Wyjaśnić zadanie warstwy transportowej i to, jak porty identyfikują procesy (porty dobrze znane, zarejestrowane i efemeryczne).
- Porównać TCP i UDP (połączenia, niezawodność, kolejność, narzut) i wybrać jeden z nich dla danej aplikacji.
- Opisać trójetapowy handshake TCP, zamykanie połączenia, numery sekwencyjne i potwierdzeń, retransmisję oraz kontrolę przepływu.
- Rozpoznawać gniazda nasłuchujące i stany połączeń (LISTEN, ESTABLISHED, TIME_WAIT) za pomocą `ss` lub `netstat`.
- Diagnozować „connection refused” w odróżnieniu od „connection timed out”.

## Kluczowe pojęcia

### Porty: od hosta do procesu
Adres IP doprowadza pakiet do właściwego budynku. Nie mówi, do którego mieszkania. Serwer pod adresem `203.0.113.80` może jednocześnie uruchamiać serwer WWW, serwer SSH i bazę danych, a Twój laptop może mieć otwartych dwadzieścia kart przeglądarki. Coś musi zdecydować, do którego programu należy każdy pakiet.

To zadanie **warstwy transportowej** (warstwa 4 [modelu OSI](../04-osi-model/lesson.pl.md)). Przenosi dane między *procesami*, a nie tylko między hostami. W tym celu opatruje każdy komunikat dwoma numerami **portów**: źródłowym i docelowym. Port to liczba 16-bitowa, od 0 do 65535. Program, który chce odbierać ruch, prosi system operacyjny o port; od tej chwili system przekazuje mu wszystko, co przychodzi na ten port. Rozdzielanie danych przychodzących według portu nazywa się **demultipleksacją**; mieszanie danych wielu programów pod jednym adresem IP to **multipleksacja**.

RFC 6335 dzieli numery portów na trzy zakresy, a rejestr prowadzi Internet Assigned Numbers Authority (IANA):

| Zakres | Nazwa w RFC 6335 | Inaczej | Do czego służą |
|---|---|---|---|
| 0–1023 | Porty systemowe | **Porty dobrze znane** (well-known) | Usługi standardowe: 22 SSH, 53 Domain Name System (DNS), 443 HTTP Secure (HTTPS) |
| 1024–49151 | Porty użytkownika | **Porty zarejestrowane** | Usługi zarejestrowane w IANA: 3389 Remote Desktop Protocol (RDP), 5432 PostgreSQL |
| 49152–65535 | Porty dynamiczne i/lub prywatne | **Porty efemeryczne** | Tymczasowe porty źródłowe klientów, nigdy nieprzypisane do usługi |

Serwer nasłuchuje na stałym, dobrze znanym porcie, aby klienci wiedzieli, gdzie go szukać. Klientowi jest obojętne, którego portu używa, więc system operacyjny wybiera wolny **port efemeryczny** przy każdym otwarciu połączenia.

> [!NOTE]
> Nie wszystkie systemy operacyjne trzymają się dynamicznego zakresu z RFC 6335. Windows (od Visty) i macOS domyślnie używają 49152–65535, ale Linux używa 32768–60999. Sprawdź swój zakres poleceniem `cat /proc/sys/net/ipv4/ip_local_port_range` w Linuksie, `sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last` w macOS lub `netsh int ipv4 show dynamicport tcp` w Windows. Ma to znaczenie przy pisaniu reguł zapory dla ruchu powrotnego.

Punkt końcowy programu, czyli adres IP plus port plus protokół, nazywa się **gniazdem** (socket). Połączenie identyfikuje jego **czwórka** (4-tuple): źródłowy adres IP, port źródłowy, docelowy adres IP i port docelowy. Dodaj protokół, a otrzymasz **piątkę** (5-tuple), którą śledzą zapory i urządzenia Network Address Translation (NAT). Ponieważ port klienta jest inny, dwie karty przeglądarki mogą rozmawiać z tym samym portem serwera jednocześnie, nie mieszając swoich danych:

![Klient 192.0.2.10 uruchamia kartę 1 przeglądarki na porcie efemerycznym 50514, kartę 2 na 50515 i klienta SSH na 50600. Serwer 203.0.113.80 nasłuchuje na porcie 443 (serwer WWW) i porcie 22 (serwer SSH). Obie karty łączą się z 443, a klient SSH z 22. Trzy połączenia TCP to 192.0.2.10:50514 do 203.0.113.80:443, 192.0.2.10:50515 do 203.0.113.80:443 i 192.0.2.10:50600 do 203.0.113.80:22](../../../assets/diagrams/tcp-ports-sockets.pl.svg)

*Rysunek 1. Dwa połączenia mają wspólny cel `203.0.113.80:443`. Nadal są osobne, ponieważ ich czwórki różnią się portem źródłowym.*

Kilka portów, z którymi będziesz się stale spotykać:

| Port | Protokół | Usługa |
|---|---|---|
| 22 | TCP | Secure Shell (SSH) |
| 25 | TCP | Simple Mail Transfer Protocol (SMTP), serwer–serwer |
| 53 | UDP i TCP | DNS |
| 67 / 68 | UDP | Dynamic Host Configuration Protocol (DHCP), serwer / klient |
| 80 | TCP | Hypertext Transfer Protocol (HTTP) |
| 123 | UDP | Network Time Protocol (NTP) |
| 443 | TCP, a dla HTTP/3 UDP | HTTPS |
| 3389 | TCP i UDP | Remote Desktop Protocol (RDP) |

TCP i UDP mają oddzielne przestrzenie portów. Port TCP 53 i port UDP 53 to dwa różne gniazda, a program może nasłuchiwać na jednym bez drugiego.

> [!CHECK]
> Twój laptop otwiera jednocześnie dwa połączenia z `https://www.example.com`. Oba idą do `203.0.113.80:443`. Jak serwer rozróżnia ich dane?
>
> - [ ] Każde połączenie używa innego portu docelowego na serwerze
> - [x] Laptop używa innego efemerycznego portu źródłowego dla każdego z nich, więc obie czwórki się różnią
> - [ ] Serwer może obsługiwać naraz tylko jedno połączenie na adres IP klienta
> - [ ] Przeglądarka dodaje numer połączenia do nagłówka IP
>
> Port serwera pozostaje 443 w obu przypadkach. System operacyjny nadaje każdemu połączeniu własny efemeryczny port źródłowy, a czwórka (źródłowy IP, port źródłowy, docelowy IP, port docelowy) jednoznacznie identyfikuje każde połączenie.

### TCP i UDP w porównaniu
W Internecie na co dzień działają dwa protokoły transportowe. Robią przeciwstawne kompromisy.

**User Datagram Protocol (UDP)** (RFC 768) to opcja minimalna. Dodaje 8-bajtowy nagłówek (port źródłowy, port docelowy, długość i suma kontrolna) i wysyła komunikat. Każdy komunikat to **datagram**: dociera w całości albo wcale. UDP jest **bezpołączeniowy**: brak nawiązywania, potwierdzeń i retransmisji. Jeśli datagram zginie, zostanie zduplikowany lub wyprzedzi go późniejszy, UDP tego nie zauważy. To aplikacja decyduje, czy ma to znaczenie.

**Transmission Control Protocol (TCP)** (RFC 9293) robi znacznie więcej. Jest **połączeniowy**: obie strony uzgadniają rozmowę, zanim popłyną jakiekolwiek dane. Następnie dostarcza niezawodny, uporządkowany **strumień bajtów**: każdy bajt jest numerowany, potwierdzany i wysyłany ponownie, jeśli zginie, a program odbierający czyta bajty w kolejności, w jakiej je wysłano. TCP zwalnia też, gdy odbiorca lub sieć nie nadążają. Jego jednostką danych jest **segment** z nagłówkiem o długości 20–60 bajtów.

![Porównanie. Przed wysłaniem: TCP wykonuje trójetapowy handshake; UDP po prostu wysyła. Dostarczanie: TCP potwierdza dane i ponownie wysyła straty; UDP działa w trybie best effort, bez ACK. Kolejność: TCP to jeden uporządkowany strumień bajtów; UDP wysyła osobne datagramy. Kontrola przepływu i zatorów: wbudowana w TCP; brak w UDP, to zadanie aplikacji. Rozmiar nagłówka: TCP 20–60 bajtów, UDP 8 bajtów. Typowe zastosowania TCP: HTTPS 443, SSH 22, SMTP 25, IMAPS 993. Typowe zastosowania UDP: DNS 53, DHCP 67/68, NTP 123, QUIC 443](../../../assets/diagrams/tcp-vs-udp.pl.svg)

*Rysunek 2. TCP kupuje niezawodność i kolejność handshake'iem, potwierdzeniami i większym nagłówkiem. UDP daje szybkość i prostotę, a resztę zostawia aplikacji.*

Wybór między nimi sprowadza się do pytania, co boli bardziej: czekanie czy utrata danych.

| Aplikacja | Zwykły wybór | Dlaczego |
|---|---|---|
| Strony WWW, interfejsy programistyczne aplikacji (API), transfer plików, poczta, SSH | TCP | Każdy bajt musi dotrzeć, w kolejności. Krótkie opóźnienie jest do zaakceptowania. |
| Zapytania DNS | UDP (TCP dla dużych odpowiedzi i transferów stref) | Małe pytanie, mała odpowiedź. Zgubione zapytanie po prostu się powtarza. RFC 7766 wymaga, aby serwery DNS obsługiwały także TCP. |
| Rozmowy głosowe i wideo, gry online | UDP | Spóźniony pakiet jest bezużyteczny. Lepiej go pominąć, niż zatrzymywać wszystko na czas ponownej wysyłki. |
| DHCP | UDP | Klient nie ma jeszcze adresu IP i musi nadawać rozgłoszeniowo (broadcast). TCP nie potrafi: połączenie ma dokładnie dwa końce. |
| Wideo na żywo do wielu odbiorców (multicast) | UDP | Ten sam powód: TCP działa tylko jeden do jednego. |

UDP nie jest „zawodny” w złym sensie. Jest *bez założeń*. **QUIC** (RFC 9000) to najlepszy przykład: działa na UDP i buduje własną niezawodność, kolejność, kontrolę zatorów oraz wbudowane szyfrowanie Transport Layer Security (TLS) 1.3. HTTP/3 (RFC 9114) używa QUIC, dlatego dziś HTTPS korzysta zarówno z portu TCP 443, jak i z portu UDP 443.

> [!CHECK]
> Zespół tworzy grę wieloosobową. Serwer wysyła pozycję każdego gracza 30 razy na sekundę. Który transport pasuje najlepiej i dlaczego?
>
> - [ ] TCP, ponieważ zgubiona aktualizacja pozycji musi zawsze zostać wysłana ponownie
> - [x] UDP, ponieważ ponownie wysłana stara pozycja jest bezużyteczna, gdy istnieje już nowsza, a czekanie na nią zamroziłoby grę
> - [ ] UDP, ponieważ szyfruje dane i zapobiega oszustwom
> - [ ] TCP, ponieważ UDP nie może przenosić więcej niż jednego komunikatu na sekundę
>
> Każda aktualizacja zastępuje poprzednią, więc retransmisja przychodzi za późno, by się przydać, a dostarczanie w kolejności w TCP wstrzymywałoby nowsze aktualizacje na czas oczekiwania. Ani TCP, ani UDP same z siebie niczego nie szyfrują.

### Połączenie TCP: nawiązywanie i zamykanie
Połączenie TCP zaczyna się **trójetapowym handshake'iem** (three-way handshake). Pomyśl o rozmowie telefonicznej: „Słyszysz mnie?” „Tak, słyszę, a Ty mnie słyszysz?” „Tak.” Dopiero wtedy zaczyna się rozmowa.

Handshake używa flag, pojedynczych bitów nagłówka TCP. Flaga **SYN** (synchronize) otwiera połączenie, flaga **ACK** (acknowledgement, potwierdzenie) mówi, że numer potwierdzenia jest ważny, flaga **FIN** (finish) zamyka jeden kierunek, a flaga **RST** (reset) natychmiast przerywa połączenie.

![Handshake TCP między klientem 192.0.2.10:50514 (CLOSED) a serwerem 203.0.113.80:443 (LISTEN). 1: klient wysyła SYN seq=1000 i przechodzi do SYN-SENT; serwer przechodzi do SYN-RECEIVED. 2: serwer wysyła SYN, ACK seq=5000 ack=1001; klient przechodzi do ESTABLISHED. 3: klient wysyła ACK ack=5001; serwer przechodzi do ESTABLISHED. Następnie klient wysyła 100 bajtów danych od seq=1001, na przykład TLS ClientHello, a serwer odpowiada ACK ack=1101](../../../assets/diagrams/tcp-handshake.pl.svg)

*Rysunek 3. Trzy komunikaty otwierają połączenie. Każda strona wybiera własny początkowy numer sekwencyjny, a druga strona potwierdza go, dodając jeden.*

1. **SYN.** Klient wybiera **początkowy numer sekwencyjny (ISN, initial sequence number)**, tu 1000, i wysyła segment z flagą SYN. Ogłasza też opcje, takie jak **Maximum Segment Size (MSS, maksymalny rozmiar segmentu)**, czyli największy fragment danych, jaki może odebrać w jednym segmencie.
2. **SYN, ACK.** Serwer wybiera własny ISN (5000) i potwierdza ISN klienta: `ack=1001` znaczy „dostałem Twój SYN; następny bajt, jakiego od Ciebie oczekuję, to 1001”. SYN liczy się jako jeden bajt przestrzeni numerów sekwencyjnych, chociaż nie niesie danych.
3. **ACK.** Klient potwierdza SYN serwera liczbą `ack=5001`. Obie strony są teraz w stanie **ESTABLISHED** i dane mogą płynąć w obu kierunkach.

Prawdziwe ISN nie wynoszą 1000 i 5000. To liczby 32-bitowe wybierane w sposób nieprzewidywalny (RFC 9293, za RFC 6528), aby atakujący nie mógł ich odgadnąć i wstrzyknąć fałszywych segmentów do połączenia.

Zamykanie to cztery kroki, ponieważ każdy kierunek zamyka się osobno:

![Zamykanie TCP między klientem 192.0.2.10:50514 a serwerem 203.0.113.80:443, obaj w stanie ESTABLISHED. 1: klient wysyła FIN seq=1101 i przechodzi do FIN-WAIT-1. 2: serwer wysyła ACK ack=1102 i przechodzi do CLOSE-WAIT; klient przechodzi do FIN-WAIT-2. Aplikacja serwera kończy pracę i wywołuje close(). 3: serwer wysyła FIN seq=5001 i przechodzi do LAST-ACK; klient przechodzi do TIME-WAIT. 4: klient wysyła ACK ack=5002; serwer przechodzi do CLOSED. Klient czeka w TIME-WAIT 2 × MSL, w Linuksie 60 sekund, po czym przechodzi do CLOSED](../../../assets/diagrams/tcp-teardown.pl.svg)

*Rysunek 4. Każda strona wysyła własny FIN. Strona zamykająca jako pierwsza kończy w TIME-WAIT; druga kończy, gdy tylko jej FIN zostanie potwierdzony.*

- Strona zamykająca jako pierwsza wysyła FIN: „nie mam już nic do wysłania”. Druga strona potwierdza i przechodzi do **CLOSE-WAIT**: może jeszcze wysyłać dane, dopóki jej aplikacja nie wywoła `close()`. Ten stan jednokierunkowy to **półzamknięcie** (half-close).
- Gdy druga strona wyśle własny FIN i zostanie on potwierdzony, ta strona przechodzi do CLOSED.
- Strona, która zamknęła pierwsza, czeka w **TIME-WAIT** (`TIME_WAIT` w `netstat`) przez dwukrotność **Maximum Segment Lifetime (MSL, maksymalny czas życia segmentu)**, zanim zapomni o połączeniu.

**Po co istnieje TIME-WAIT.** Ma dwa zadania. Po pierwsze, jeśli zginie sam ostatni ACK, druga strona wyśle ponownie swój FIN, a ktoś musi jeszcze tam być, żeby potwierdzić go jeszcze raz. Po drugie, chroni przed tym, by opóźnione segmenty starego połączenia zostały przyjęte przez nowe połączenie, które przypadkiem użyje tej samej czwórki. RFC 9293 definiuje MSL jako 2 minuty, co dawałoby TIME-WAIT równy 4 minuty; Linux używa stałych 60 sekund. TIME-WAIT jest normalny i zajmuje bardzo mało pamięci. Mocno obciążony klient lub proxy, który otwiera wiele krótkich połączeń, może pokazywać ich tysiące i nie jest to wyciek. Staje się problemem dopiero wtedy, gdy jeden klient otwiera tyle połączeń do *tego samego* adresu i portu serwera, że wyczerpuje porty efemeryczne. Lekarstwem jest ponowne używanie połączeń (HTTP keep-alive, pule połączeń), a nie wyłączanie TIME-WAIT.

Połączenie może też zakończyć się nagle przez RST: program ulega awarii, zapora resetuje połączenie albo nadchodzi segment dla połączenia, które nie istnieje.

> [!CHECK]
> Po zamknięciu przez klienta połączenia TCP z serwerem WWW `ss` na kliencie pokazuje to połączenie w stanie `TIME-WAIT` przez około minutę. Co to oznacza?
>
> - [ ] Serwer nigdy nie odpowiedział na FIN klienta, więc połączenie utknęło
> - [ ] Aplikacja kliencka zapomniała wywołać `close()`
> - [x] Wszystko w porządku: strona zamykająca jako pierwsza czeka tam, by móc ponownie wysłać zgubiony ostatni ACK i dać wygasnąć starym segmentom
> - [ ] Klient wciąż wysyła dane do serwera
>
> TIME-WAIT to normalny ostatni stan tego, kto wysyła pierwszy FIN. Aplikacja, która zapomina wywołać `close()`, pojawia się natomiast jako CLOSE-WAIT, po swojej stronie.

### Niezawodność: numery sekwencyjne, potwierdzenia i okna
TCP numeruje bajty, a nie segmenty. **Numer sekwencyjny** w każdym segmencie to numer jego pierwszego bajtu danych. **Numer potwierdzenia** to następny bajt, jakiego oczekuje odbiorca, i jest skumulowany: `ack=4001` znaczy „mam wszystko do bajtu 4000”. Na Rysunku 3 klient wysyła 100 bajtów od 1001, więc serwer odpowiada `ack=1101`.

Nadawca przechowuje każdy bajt, dopóki nie zostanie potwierdzony. Jeśli potwierdzenie nie nadejdzie na czas, **licznik czasu retransmisji (RTO, retransmission timeout)** wygasa i nadawca wysyła ponownie. Licznik dostosowuje się do zmierzonego czasu podróży w obie strony (RFC 6298). Jest też szybszy sygnał: jeśli odbiorca dostanie segment poza kolejnością, powtarza swoje ostatnie potwierdzenie. Trzy takie **zduplikowane ACK** z rzędu mówią nadawcy, że brakuje segmentu, więc wysyła go ponownie od razu, nie czekając na licznik. To **szybka retransmisja** (fast retransmit) (RFC 5681).

![Nadawca 192.0.2.10 wysyła seq=1001, 1000 bajtów; odbiorca 203.0.113.80 odpowiada ACK ack=2001 win=64000. Segment seq=2001 ginie w sieci. Segment seq=3001 dociera, a odbiorca powtarza ACK ack=2001, duplikat oznaczający, że wciąż brakuje bajtu 2001. Zduplikowane ACK lub licznik retransmisji sprawiają, że nadawca ponownie wysyła seq=2001, a odbiorca odpowiada ACK ack=4001](../../../assets/diagrams/tcp-retransmission.pl.svg)

*Rysunek 5. Odbiorca może potwierdzić tylko do pierwszej luki. Gdy luka zostanie wypełniona, jedno ACK obejmuje oba segmenty.*

Nowoczesny TCP używa też **selektywnego potwierdzania (SACK, Selective Acknowledgement)** (RFC 2018), dzięki czemu odbiorca może powiedzieć dokładnie, które bloki już ma, a nadawca wysyła ponownie tylko to, czego brakuje.

Dwa kolejne mechanizmy powstrzymują TCP przed wysyłaniem zbyt szybko:
- **Kontrola przepływu** chroni *odbiorcę*. Każdy segment niesie **okno odbioru** (`win`): ile jeszcze bajtów odbiorca może w tej chwili zbuforować. Nadawca nigdy nie ma w locie więcej niepotwierdzonych danych niż ta wartość. Jeśli okno spadnie do 0, nadawca zatrzymuje się i czeka. Skalowanie okna (RFC 7323) pozwala oknu przekroczyć 64 KB na szybkich łączach.
- **Kontrola zatorów** chroni *sieć*. Nadawca utrzymuje własne oszacowanie, okno zatorów, zaczyna od małego (powolny start, slow start), rośnie, dopóki wracają potwierdzenia, i cofa się, gdy widzi straty (RFC 5681). Linux domyślnie używa algorytmu CUBIC (RFC 9438); BBR, opracowany przez Google, to popularna alternatywa.

UDP nie ma nic z tego. Aplikacja na UDP, która potrzebuje niezawodności lub kontroli tempa, jak QUIC, musi to zbudować sama.

> [!CHECK]
> Odbiorca ogłasza `win=0` w swoich potwierdzeniach. Co robi nadawca?
>
> - [ ] Natychmiast wysyła ponownie wszystkie niepotwierdzone dane
> - [ ] Zamyka połączenie przez FIN
> - [x] Przestaje wysyłać nowe dane, dopóki odbiorca nie ogłosi okna większego niż 0
> - [ ] Przełącza połączenie na UDP
>
> Zerowe okno odbioru to kontrola przepływu: aplikacja odbierająca nie czyta dość szybko i jej bufor jest pełny. Nadawca wstrzymuje się i okresowo sonduje, aż okno znów się otworzy.

### Gniazda i ich stany
Na każdym hoście możesz wyświetlić gniazda otwarte przez system operacyjny. W Linuksie służy do tego `ss` (socket statistics); w macOS i Windows `netstat`.

| Stan (tak jak pokazuje `ss`) | Znaczenie | Typowa przyczyna |
|---|---|---|
| `LISTEN` | Gniazdo serwera czekające na połączenia | Usługa działa i przyjmuje połączenia pod tym adresem i portem |
| `SYN-SENT` | Trwa łączenie; jeszcze brak odpowiedzi | Wiele: cel nie odpowiada (szukaj timeoutu) |
| `SYN-RECV` | Nadszedł SYN i wysłano SYN, ACK | Wiele: wolna sieć lub SYN flood |
| `ESTAB` | Nawiązane połączenie | Normalny ruch |
| `CLOSE-WAIT` | Druga strona zamknęła; nasza aplikacja jeszcze nie | Wiele: błąd aplikacji (nigdy nie wywołuje `close()`) |
| `TIME-WAIT` | Zamknęliśmy pierwsi i czekamy 2 × MSL | Normalne; wiele na obciążonych klientach i proxy |
| `UNCONN` | Gniazdo UDP (UDP nie ma połączeń) | Usługa UDP, np. DNS lub NTP |

`netstat` i RFC zapisują stany nieco inaczej: `ESTABLISHED`, `TIME_WAIT`, `CLOSE_WAIT` oraz, w Windows, `LISTENING`. Znaczą to samo.

**Gniazdo nasłuchujące** jest powiązane z adresem, a nie tylko z portem, i ten adres decyduje, kto może się połączyć:
- `127.0.0.1:5432` (lub `[::1]:5432`): tylko programy na tej samej maszynie, przez interfejs pętli zwrotnej (loopback).
- `0.0.0.0:22` (lub `[::]:22`, lub `*:22`): każdy adres IPv4 (lub IPv6) hosta, czyli każdy, kto może dotrzeć do hosta.
- `203.0.113.80:443`: tylko połączenia przychodzące na ten jeden adres.

Serwer, który „działa lokalnie, ale nie z zewnątrz”, bardzo często nasłuchuje wyłącznie na `127.0.0.1`.

Najczęściej potrzebne polecenia:

| Zadanie | Linux | macOS | Windows (PowerShell) |
|---|---|---|---|
| Nasłuchujące gniazda TCP i UDP wraz z programem | `ss -tulpn` | `lsof -nP -iTCP -sTCP:LISTEN` i `lsof -nP -iUDP` | `netstat -ano` lub `Get-NetTCPConnection -State Listen` |
| Wszystkie gniazda TCP z ich stanem | `ss -tan` | `netstat -an -p tcp` | `netstat -an -p tcp` |

W `ss -tulpn` litery oznaczają: `-t` TCP, `-u` UDP, `-l` tylko gniazda nasłuchujące, `-p` pokaż proces, `-n` pokaż liczby zamiast nazw usług. W Linuksie proces gniazd należących do innych użytkowników zobaczysz tylko po uruchomieniu z `sudo`.

Aby policzyć gniazda TCP według stanu, co szybko pokazuje nagromadzenie TIME-WAIT lub CLOSE-WAIT, w Linuksie:

```bash
ss -tan | awk 'NR>1 {print $1}' | sort | uniq -c
```

W Windows (PowerShell) to samo robi `Get-NetTCPConnection | Group-Object State`.

> [!CHECK]
> `ss -tln` na serwerze pokazuje `LISTEN 0 4096 127.0.0.1:8000 0.0.0.0:*`. Twój kolega nie może dotrzeć do portu 8000 ze swojego laptopa. Jaki jest najbardziej prawdopodobny powód?
>
> - [ ] Port jest powyżej 1023, więc połączyć się z nim mogą tylko administratorzy
> - [ ] Usługa jest w stanie TIME-WAIT i za minutę zacznie przyjmować połączenia
> - [x] Usługa nasłuchuje tylko na adresie pętli zwrotnej, więc przyjmuje połączenia z samego serwera i znikąd indziej
> - [ ] `0.0.0.0:*` oznacza, że wszyscy klienci są zablokowani
>
> Adres lokalny `127.0.0.1` ogranicza nasłuch do interfejsu pętli zwrotnej. Kolumna partnera `0.0.0.0:*` oznacza po prostu „dowolny partner” dla gniazda nasłuchującego. Powiązanie z `0.0.0.0` (i otwarcie zapory) uczyniłoby usługę osiągalną z zewnątrz.

### „Connection refused” a „connection timed out”
Gdy połączenie TCP się nie udaje, komunikat o błędzie mówi, *jak daleko dotarł SYN*.

![Po lewej: klient 192.0.2.10 wysyła SYN do 198.51.100.20:8080, gdzie port jest zamknięty. Host odpowiada RST, ACK, a klient zgłasza odrzucenie połączenia w ciągu milisekund. Po prawej: klient 192.0.2.10 wysyła SYN do 198.51.100.30:8080, gdzie zapora po cichu go odrzuca. Klient ponawia SYN jeszcze dwa razy bez odpowiedzi i zgłasza przekroczenie czasu po upływie limitu](../../../assets/diagrams/tcp-refused-vs-timeout.pl.svg)

*Rysunek 6. Odrzucone znaczy, że coś odpowiedziało. Przekroczenie czasu znaczy, że nic nie odpowiedziało.*

- **Connection refused** (`ECONNREFUSED`). SYN dotarł do hosta docelowego, ale żaden program nie nasłuchuje na tym porcie, więc stos TCP hosta odpowiedział RST. Błąd pojawia się niemal natychmiast. Zapora skonfigurowana tak, by *odrzucać* zamiast *porzucać*, daje ten sam efekt, wysyłając RST lub komunikat „port unreachable” protokołu Internet Control Message Protocol (ICMP). Sprawdź serwer: czy usługa działa? Czy nasłuchuje na właściwym porcie i adresie (`ss -tlnp`)?
- **Connection timed out** (`ETIMEDOUT`). Nie wróciła żadna odpowiedź. Klient wysyła SYN kilkakrotnie, za każdym razem czekając dłużej, i poddaje się, gdy minie jego limit. Przyczyny: zapora lub grupa zabezpieczeń w chmurze po cichu porzucająca ruch, wyłączony host, zły adres IP lub problem z routingiem. Sprawdź trasę: zapory, grupy zabezpieczeń, trasy.

Jak długo trwa „timed out”, zależy od klienta. W Linuksie z ustawieniami domyślnymi jądro ponawia SYN z odstępami zaczynającymi się od około 1 sekundy, które potem się podwajają, i poddaje się po nieco ponad 2 minutach (zmierzyliśmy 136 s w Linuksie 7.2 przy `net.ipv4.tcp_syn_retries = 6`). Większość aplikacji ustawia własny, krótszy limit, na przykład `curl --connect-timeout 5`.

Dwa pokrewne błędy pochodzą z warstwy sieci, a nie od celu:
- **No route to host** (`EHOSTUNREACH`): router odesłał ICMP „host unreachable” albo Twój własny host nie potrafił rozwiązać adresu Media Access Control (MAC) następnego skoku w łączu lokalnym.
- **Network is unreachable** (`ENETUNREACH`): Twój własny host w ogóle nie ma trasy do tego celu (sprawdź `ip route`).

UDP nie ma handshake'u, więc nie ma czego odrzucać. Jeśli datagram UDP dotrze do zamkniętego portu, host zwykle odpowiada ICMP „port unreachable”, a program, który użył `connect()` na swoim gnieździe UDP, może zobaczyć błąd „connection refused” przy następnym odbiorze. Częściej klient UDP po prostu nic nie słyszy i musi polegać na własnym limicie czasu.

> [!NOTE]
> W Windows klient, który otrzyma RST, może ponowić połączenie kilka razy, zanim zgłosi błąd, więc „refused” może tam trwać około dwóch sekund zamiast milisekund. Rozróżnienie (szybka odpowiedź a brak odpowiedzi) nadal obowiązuje.

> [!CHECK]
> `curl https://198.51.100.20:8443` kończy się po dokładnie 5 sekundach błędem „Connection timed out” przy `--connect-timeout 5`. Gdzie szukasz najpierw?
>
> - [ ] W konfiguracji serwera WWW, bo nasłuchuje na złym porcie
> - [x] Na trasie: zapora, grupa zabezpieczeń lub problem z routingiem porzuca SYN albo host nie działa
> - [ ] W zakresie portów efemerycznych klienta, bo skończyły mu się porty
> - [ ] W TIME-WAIT na serwerze, bo stare połączenia blokują nowe
>
> Zły port na osiągalnym hoście daje natychmiastowe „connection refused” (RST). Timeout oznacza brak jakiejkolwiek odpowiedzi, co wskazuje na coś, co porzuca pakiety, albo na nieosiągalny host.

## Jak to działa
Złóżmy wszystko w całość. Wpisujesz `https://www.example.com` w przeglądarce na laptopie pod adresem `192.0.2.10`. Strona jest serwowana z `203.0.113.80`.

1. **DNS przez UDP.** Przeglądarka potrzebuje adresu IP. Laptop wysyła zapytanie DNS w jednym datagramie UDP z portu efemerycznego (powiedzmy 41837) na port 53 resolwera i dostaje jeden datagram z powrotem: `www.example.com` to `203.0.113.80`. Bez handshake'u, dwa pakiety.
2. **Wybór portu źródłowego.** Przeglądarka prosi system operacyjny o połączenie TCP z `203.0.113.80:443`. System wybiera wolny port efemeryczny, 50514. Czwórka `192.0.2.10:50514 → 203.0.113.80:443` nazywa teraz to połączenie.
3. **Trójetapowy handshake.** SYN, SYN-ACK, ACK (Rysunek 3). Kosztuje jedną podróż w obie strony, zanim popłyną dane. Gniazdo serwera w stanie LISTEN pozostaje otwarte dla kolejnego klienta; system tworzy nowe gniazdo ESTABLISHED dla tego.
4. **Dane.** Przeglądarka rozpoczyna handshake TLS, a potem wysyła żądanie HTTP. Każdy segment niesie numery sekwencyjne i potwierdzeń; zgubione segmenty są retransmitowane (Rysunek 5); okno odbioru i okno zatorów ograniczają tempo przepływu danych.
5. **Zamykanie.** Gdy przeglądarka skończy (często po utrzymaniu połączenia przez jakiś czas dla kolejnych żądań), jedna strona wysyła FIN, druga odpowiada ACK i własnym FIN (Rysunek 4). Ten, kto wysłał pierwszy FIN, trzyma czwórkę w TIME-WAIT przez 60 sekund w Linuksie.
6. **Jeśli coś zawiedzie** w kroku 3, błąd mówi, gdzie: RST oznacza, że host jest osiągalny, ale nic nie nasłuchuje na 443 (refused); cisza oznacza, że coś na trasie porzuca SYN (timed out).

Jeśli przeglądarka i serwer obsługują HTTP/3, kroki od 2 do 5 odbywają się przez QUIC na porcie UDP 443, a QUIC łączy własny handshake z handshake'iem TLS, aby zaoszczędzić jedną podróż w obie strony.

> [!CHECK]
> W powyższej sekwencji, jakie komunikaty przepływają **zanim** pierwszy bajt żądania HTTP opuści laptop?
>
> - [ ] Tylko samo żądanie HTTP; TCP wysyła dane od razu
> - [ ] Handshake UDP z resolwerem DNS, a potem żądanie HTTP
> - [x] Zapytanie i odpowiedź DNS przez UDP, trójetapowy handshake TCP oraz handshake TLS
> - [ ] Zamknięcie TCP poprzedniego połączenia
>
> DNS nie potrzebuje handshake'u, ale TCP tak (SYN, SYN-ACK, ACK), a HTTPS dokłada na wierzchu handshake TLS. Dlatego ponowne użycie połączeń i połączony handshake HTTP/3 przyspieszają ładowanie stron.

## Przykład praktyczny
Dostajesz zadanie sprawdzenia serwera WWW z Linuksem pod adresem `203.0.113.80`. Wszystkie adresy to adresy dokumentacyjne (RFC 5737).

**Jakie usługi nasłuchują?** Uruchom jako administrator, aby `ss` mógł pokazać każdy proces:

```bash
sudo ss -tulpn
```

```text
Netid State  Recv-Q Send-Q  Local Address:Port  Peer Address:Port Process
udp   UNCONN 0      0           127.0.0.1:323        0.0.0.0:*     users:(("chronyd",pid=702,fd=5))
tcp   LISTEN 0      128           0.0.0.0:22         0.0.0.0:*     users:(("sshd",pid=812,fd=3))
tcp   LISTEN 0      511           0.0.0.0:443        0.0.0.0:*     users:(("nginx",pid=1034,fd=6))
tcp   LISTEN 0      4096        127.0.0.1:5432       0.0.0.0:*     users:(("postgres",pid=990,fd=7))
tcp   LISTEN 0      128              [::]:22            [::]:*     users:(("sshd",pid=812,fd=4))
```

Czytaj linia po linii:
- `udp UNCONN 127.0.0.1:323`: demon NTP `chronyd` ma gniazdo UDP do lokalnych poleceń sterujących. Gniazda UDP pojawiają się jako `UNCONN`, ponieważ UDP nie ma połączeń.
- `tcp LISTEN 0.0.0.0:22` i `[::]:22`: SSH przyjmuje połączenia na każdym adresie IPv4 i IPv6.
- `tcp LISTEN 0.0.0.0:443`: serwer WWW, osiągalny stąd, skąd pozwala zapora.
- `tcp LISTEN 127.0.0.1:5432`: baza danych PostgreSQL przyjmuje tylko połączenia lokalne. To dobrze: aplikacja webowa na tym samym hoście może jej używać, Internet nie.
- Dla gniazda nasłuchującego `Send-Q` pokazuje **backlog**: maksymalną liczbę połączeń, które zakończyły handshake, ale nie zostały jeszcze odebrane przez program (511 dla nginx).

**Jakie połączenia istnieją w tej chwili?**

```bash
ss -tan
```

```text
State      Recv-Q Send-Q     Local Address:Port      Peer Address:Port
LISTEN     0      128              0.0.0.0:22             0.0.0.0:*
LISTEN     0      511              0.0.0.0:443            0.0.0.0:*
LISTEN     0      4096           127.0.0.1:5432           0.0.0.0:*
ESTAB      0      0           203.0.113.80:443       192.0.2.10:50514
ESTAB      0      36          203.0.113.80:22      198.51.100.7:51022
TIME-WAIT  0      0           203.0.113.80:443       192.0.2.10:50388
ESTAB      0      0              127.0.0.1:5432         127.0.0.1:41870
ESTAB      0      0              127.0.0.1:41870        127.0.0.1:5432
LISTEN     0      128                 [::]:22                [::]:*
```

- `192.0.2.10:50514` to przeglądarka połączona z serwerem WWW. Jej port źródłowy jest efemeryczny; po stronie serwera jest to 443.
- Administrator spod `198.51.100.7` jest zalogowany przez SSH. `Send-Q 36` oznacza, że 36 bajtów wysłano, ale jeszcze nie potwierdzono: normalne dla aktywnej sesji.
- `TIME-WAIT … 192.0.2.10:50388` to starsze połączenie z tej samej przeglądarki. Jako pierwszy zamknął je *serwer* (na przykład z powodu limitu bezczynności keep-alive), więc to serwer trzyma TIME-WAIT.
- Dwa wiersze `127.0.0.1` to *jedno* połączenie widziane z obu końców: aplikacja webowa (port 41870) rozmawiająca z bazą danych (5432). Połączenia loopback zawsze pojawiają się dwa razy.

**Jak handshake wygląda w sieci?** Przechwycenie przez `tcpdump` na serwerze (`-n` pokazuje liczby, `-t` ukrywa znaczniki czasu) pokazuje początek połączenia przeglądarki:

```bash
sudo tcpdump -n -t -i eth0 'tcp port 443 and host 192.0.2.10'
```

```text
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [S], seq 2864127401, win 64240, options [mss 1460,sackOK,TS val 3017325814 ecr 0,nop,wscale 7], length 0
IP 203.0.113.80.443 > 192.0.2.10.50514: Flags [S.], seq 1207650562, ack 2864127402, win 65160, options [mss 1460,sackOK,TS val 1554302991 ecr 3017325814,nop,wscale 7], length 0
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [.], ack 1, win 502, options [nop,nop,TS val 3017325839 ecr 1554302991], length 0
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [P.], seq 1:518, ack 1, win 502, options [nop,nop,TS val 3017325840 ecr 1554302991], length 517
IP 203.0.113.80.443 > 192.0.2.10.50514: Flags [.], ack 518, win 507, options [nop,nop,TS val 1554303016 ecr 3017325840], length 0
```

- `[S]` to SYN, `[S.]` to SYN-ACK (`.` oznacza flagę ACK), `[.]` to samo ACK, a `[P.]` to dane z flagą PSH (push). `[F.]` i `[R]` oznaczałyby FIN i RST.
- ISN to losowe liczby 32-bitowe: 2864127401 i 1207650562. SYN-ACK potwierdza 2864127401 + 1.
- Od trzeciej linii `tcpdump` pokazuje *względne* numery sekwencyjne, by oszczędzić miejsce: `ack 1` znaczy „ISN + 1”. Klient wysyła następnie bajty od 1 do 517 (`seq 1:518`, `length 517`, TLS ClientHello), a serwer potwierdza 518.
- `mss 1460` to największy segment, jaki akceptuje każda strona: ramka Ethernet 1500 bajtów minus 20 bajtów nagłówka IP i 20 TCP. `win 502` przy `wscale 7` oznacza okno odbioru 502 × 2⁷ = 64 256 bajtów.

> [!NOTE]
> Rozmiary okien, opcje i dokładny układ kolumn `ss` zależą od wersji systemu operacyjnego i jego ustawień. Struktura (flagi, numery sekwencyjne i potwierdzeń, stany) jest wszędzie taka sama. Własne przechwycenie wykonasz w laboratorium.

## Typowe błędy
- **Traktowanie „refused” i „timed out” jako tego samego problemu.** Refused: idź na serwer i sprawdź usługę. Timed out: sprawdź zapory, grupy zabezpieczeń i routing. Debugowanie aplikacji, gdy zapora porzuca SYN, to stracone godziny.
- **Wiązanie usługi z `127.0.0.1` i dziwienie się, że nikt nie może się połączyć**, albo odwrotnie: wiązanie bazy danych lub interfejsu administracyjnego z `0.0.0.0` „żeby działało” i wystawienie jej do Internetu.
- **Otwieranie tylko portu serwera w zaporze bezstanowej.** Odpowiedzi wracają na efemeryczny port klienta. Zapory stanowe radzą sobie z tym automatycznie; bezstanowe (jak niektóre sieciowe listy kontroli dostępu, ACL, w chmurze) wymagają otwartego zakresu efemerycznego dla ruchu powrotnego, a Linux, Windows i macOS używają różnych zakresów.
- **„Naprawianie” TIME-WAIT zmianami w jądrze.** Tysiące gniazd w TIME-WAIT są normalne na obciążonych hostach. Zamiast tego używaj ponownie połączeń. Dawne ustawienie Linuksa `tcp_tw_recycle` psuło klientów za NAT i zostało usunięte w Linuksie 4.12.
- **Ignorowanie CLOSE-WAIT.** Gniazda CLOSE-WAIT, które się piętrzą i nigdy nie znikają, to błąd aplikacji: program nigdy nie zamyka połączeń, które druga strona już zamknęła. Restart to ukrywa; poprawienie kodu leczy.
- **Zakładanie, że TCP zachowuje granice komunikatów.** TCP to strumień bajtów. Dwa wywołania `send()` po 100 bajtów mogą dotrzeć jako jeden odczyt 200 bajtów albo jako 150 + 50. Aplikacje muszą same wyznaczać granice komunikatów (prefiksy długości, ograniczniki).
- **Zakładanie, że datagramy UDP docierają.** UDP nie ostrzega, gdy datagram zginie. Aplikacja na UDP potrzebuje własnych limitów czasu i ponowień.
- **Zapominanie, że porty TCP i UDP są oddzielne.** Zezwolenie na port TCP 53 w zaporze nie zezwala na DNS przez port UDP 53, i odwrotnie.

## Kwestie bezpieczeństwa
- **SYN flood.** Podczas handshake'u serwer utrzymuje połączenie półotwarte (SYN-RECV) dla każdego SYN, na który odpowiada. Atakujący, który wysyła ogromne liczby SYN, zwykle z podrobionymi adresami źródłowymi, może zapełnić tę kolejkę, tak że prawdziwi klienci nie mogą się połączyć. Standardową obroną są **SYN cookies** (RFC 4987): gdy kolejka jest pełna, serwer koduje szczegóły połączenia we własnym ISN i nie przechowuje stanu, dopóki nie wróci poprawne ACK. Linux włącza je domyślnie (`net.ipv4.tcp_syncookies = 1`). Duże ataki wymagają ponadto ograniczania tempa lub usługi ochronnej po stronie nadrzędnej.
- **Skanowanie portów.** Ponieważ porty zamknięte odpowiadają RST, otwarte SYN-ACK, a filtrowane ciszą, każdy może zmapować, jakie usługi wystawia host. To **skanowanie portów** (port scanning), ta sama logika refused kontra timeout, której właśnie się nauczyłeś. Obrońcy skanują *własne* sieci, by znaleźć usługi, które nie powinny być wystawione. Skanowanie systemów, które nie należą do Ciebie lub których nie masz wyraźnego zezwolenia testować, może być nielegalne i narusza regulaminy większości dostawców.
- **Wystawiaj jak najmniej.** Każdy nasłuchujący port to powierzchnia ataku. Wiąż usługi wewnętrzne (bazy danych, pamięci podręczne, panele administracyjne) z `127.0.0.1` lub adresem prywatnym, postaw zaporę z domyślną odmową przed całą resztą i nigdy nie publikuj SSH (22), RDP (3389) ani baz danych (3306, 5432, 6379…) bezpośrednio w Internecie. Zamiast tego użyj wirtualnej sieci prywatnej (VPN) lub hosta bastionowego. Regularnie przeglądaj wynik `ss -tulpn`.
- **Porzucać czy odrzucać?** Porzucanie spowalnia skanowanie i zdradza mniej; odrzucanie sprawia, że błędy są szybkie i czytelne dla prawowitych użytkowników. Wiele organizacji porzuca na brzegu Internetu, a odrzuca wewnątrz sieci.
- **Odbicie i wzmocnienie UDP.** UDP nie ma handshake'u, więc adres źródłowy łatwo podrobić. Atakujący wysyłają małe zapytania do otwartych serwerów DNS, NTP lub memcached z adresem ofiary jako źródłem, a większe odpowiedzi zalewają ofiarę. Nie uruchamiaj otwartych resolwerów ani usług na UDP, które odpowiadają każdemu, i filtruj podrobione źródła na brzegu sieci (Best Current Practice BCP 38, RFC 2827).
- **TCP i UDP nie szyfrują.** Każdy na trasie może czytać i zmieniać dane. Do wszystkiego, co wrażliwe, używaj TLS (HTTPS, SMTP ze STARTTLS, Internet Message Access Protocol przez TLS, IMAPS), SSH lub QUIC. Nieprzewidywalne ISN (RFC 6528) i kontrole z RFC 5961 utrudniają wstrzykiwanie na ślepo fałszywych segmentów lub RST, ale nie chronią przed atakującym, który widzi ruch.

## Podsumowanie
- Warstwa transportowa dostarcza dane do procesów. Identyfikują je porty (0–65535): dobrze znane/systemowe 0–1023, zarejestrowane/użytkownika 1024–49151, dynamiczne/efemeryczne 49152–65535 (RFC 6335). Linux domyślnie używa 32768–60999 dla portów efemerycznych. Czwórka identyfikuje jedno połączenie.
- UDP (RFC 768) jest bezpołączeniowy, działa w trybie best effort i jest minimalny: 8-bajtowy nagłówek, osobne datagramy, brak potwierdzeń. TCP (RFC 9293) jest połączeniowy, niezawodny i uporządkowany, z kontrolą przepływu i zatorów. QUIC (RFC 9000) buduje na UDP funkcje podobne do TCP oraz szyfrowanie.
- TCP otwiera się przez SYN, SYN-ACK, ACK, a zamyka przez FIN i ACK w każdym kierunku. Strona zamykająca jako pierwsza czeka w TIME-WAIT (2 × MSL; 60 s w Linuksie), co jest normalne.
- Numery sekwencyjne liczą bajty; potwierdzenia wskazują następny oczekiwany bajt. Utracone dane są wysyłane ponownie po timeoucie lub zduplikowanych ACK; okno odbioru (kontrola przepływu) i okno zatorów ograniczają tempo wysyłania.
- `ss -tulpn` / `ss -tan` (Linux) oraz `netstat`, `lsof` lub `Get-NetTCPConnection` (macOS, Windows) pokazują gniazda nasłuchujące i stany. Sprawdzaj adres nasłuchu, nie tylko port.
- „Connection refused” oznacza, że host odpowiedział RST: nic tam nie nasłuchuje. „Connection timed out” oznacza brak jakiejkolwiek odpowiedzi: sprawdź zapory, routing i to, czy host działa.

## Słowniczek
| Termin | Definicja |
|---|---|
| Warstwa transportowa | Warstwa 4 OSI: przenosi dane między procesami na różnych hostach, używając portów. |
| Port | 16-bitowa liczba (0–65535) identyfikująca punkt końcowy procesu dla TCP lub UDP na hoście. |
| Demultipleksacja | Dostarczanie danych przychodzących do właściwego procesu według jego portu docelowego. |
| Multipleksacja | Łączenie danych wielu procesów w jedno połączenie sieciowe lub pod jednym adresem IP, oznaczonych portami. |
| Porty dobrze znane | Porty 0–1023, w RFC 6335 zwane portami systemowymi; używane przez usługi standardowe. |
| Porty zarejestrowane | Porty 1024–49151, w RFC 6335 zwane portami użytkownika; przypisywane usługom przez IANA na życzenie. |
| Port efemeryczny | Tymczasowy port, który system operacyjny nadaje klientowi na jedno połączenie; RFC 6335 rezerwuje dla nich 49152–65535. |
| Gniazdo (socket) | Punkt końcowy komunikacji: adres IP, port i protokół, używane przez program. |
| Czwórka (4-tuple) | Źródłowy adres IP, port źródłowy, docelowy adres IP i port docelowy: razem identyfikują jedno połączenie. |
| Piątka (5-tuple) | Czwórka plus protokół (TCP lub UDP); używana przez zapory i NAT. |
| User Datagram Protocol (UDP) | Bezpołączeniowy protokół transportowy typu best effort z 8-bajtowym nagłówkiem (RFC 768). |
| Datagram | Samodzielny komunikat UDP, który dociera w całości albo wcale. |
| Bezpołączeniowy | Wysyłanie danych bez uprzedniego nawiązywania połączenia ani przechowywania stanu o partnerze. |
| Transmission Control Protocol (TCP) | Połączeniowy protokół transportowy dostarczający niezawodny, uporządkowany strumień bajtów (RFC 9293). |
| Połączeniowy | Wymagający, by oba końce nawiązały połączenie przed wymianą danych. |
| Strumień bajtów | Model usługi TCP: uporządkowany ciąg bajtów bez granic komunikatów. |
| Segment | Jednostka danych wysyłana przez TCP: nagłówek TCP plus fragment strumienia bajtów. |
| QUIC | Protokół transportowy działający na UDP, z wbudowaną niezawodnością, strumieniami, kontrolą zatorów i szyfrowaniem TLS 1.3 (RFC 9000); używany przez HTTP/3. |
| Trójetapowy handshake | Wymiana SYN, SYN-ACK, ACK, która otwiera połączenie TCP. |
| SYN | Flaga TCP otwierająca połączenie i niosąca początkowy numer sekwencyjny. |
| ACK | Flaga TCP oznaczająca numer potwierdzenia jako ważny; ustawiona w prawie każdym segmencie po pierwszym. |
| FIN | Flaga TCP oznaczająca „nie mam już danych do wysłania”; zamyka jeden kierunek połączenia. |
| RST | Flaga TCP natychmiast przerywająca połączenie lub odrzucająca połączenie z zamkniętym portem. |
| Początkowy numer sekwencyjny (ISN) | Nieprzewidywalny 32-bitowy numer sekwencyjny, od którego każda strona zaczyna połączenie. |
| Maximum Segment Size (MSS) | Największa ilość danych, jaką host akceptuje w jednym segmencie TCP, ogłaszana w SYN. |
| ESTABLISHED | Stan TCP otwartego połączenia, które może przenosić dane (`ESTAB` w `ss`). |
| CLOSE-WAIT | Stan TCP po zamknięciu przez partnera, gdy aplikacja lokalna jeszcze tego nie zrobiła (`CLOSE_WAIT` w `netstat`). |
| Półzamknięcie (half-close) | Połączenie TCP, w którym jeden kierunek jest zamknięty, a drugi może jeszcze wysyłać. |
| TIME-WAIT | Stan TCP strony, która zamknęła pierwsza, utrzymywany przez 2 × MSL (`TIME_WAIT` w `netstat`). |
| Maximum Segment Lifetime (MSL) | Zakładany maksymalny czas, przez jaki segment może przetrwać w sieci; 2 minuty w RFC 9293. |
| Numer sekwencyjny | Numer pierwszego bajtu danych w segmencie TCP. |
| Numer potwierdzenia | Następny bajt, jakiego oczekuje odbiorca TCP; potwierdza wszystko, co go poprzedza. |
| Licznik czasu retransmisji (RTO) | Adaptacyjny licznik, po którego upływie TCP ponownie wysyła niepotwierdzone dane (RFC 6298). |
| Zduplikowane ACK | Powtórzone potwierdzenie tego samego bajtu, wysyłane, gdy segment dociera poza kolejnością. |
| Szybka retransmisja | Ponowne wysłanie segmentu po trzech zduplikowanych ACK, bez czekania na RTO (RFC 5681). |
| Selektywne potwierdzanie (SACK) | Opcja TCP pozwalająca odbiorcy zgłosić dokładnie, które bloki otrzymał (RFC 2018). |
| Kontrola przepływu | Ograniczanie nadawcy do tego, co odbiorca może zbuforować, za pomocą okna odbioru. |
| Okno odbioru | Liczba bajtów, jaką odbiorca TCP może jeszcze przyjąć, ogłaszana w każdym segmencie (`win`). |
| Kontrola zatorów | Ograniczanie tempa wysyłania do tego, co sieć może przenieść, za pomocą okna zatorów (RFC 5681). |
| Gniazdo nasłuchujące | Gniazdo serwera w stanie LISTEN, czekające na połączenia pod danym adresem i portem. |
| Connection refused | Błąd, gdy cel odpowiada na SYN przez RST (lub ICMP port unreachable): nic nie nasłuchuje. |
| Connection timed out | Błąd, gdy odpowiedź na SYN nie nadejdzie przed upływem limitu czasu klienta. |
| No route to host | Błąd (`EHOSTUNREACH`), gdy router zgłasza host jako nieosiągalny albo nie można rozwiązać adresu MAC następnego skoku. |
| Network is unreachable | Błąd (`ENETUNREACH`), gdy host lokalny nie ma trasy do celu. |
| Backlog | Kolejka połączeń, które zakończyły handshake, ale nie zostały jeszcze przyjęte przez program. |
| SYN cookies | Obrona przed SYN flood, która koduje stan połączenia w ISN serwera zamiast go przechowywać (RFC 4987). |
| Skanowanie portów | Sondowanie portów hosta w celu stwierdzenia, które są otwarte, zamknięte lub filtrowane. |

## Sprawdź swoją wiedzę
1. Dlaczego klient używa portu efemerycznego zamiast stałego, a serwer używa stałego, dobrze znanego portu?
2. DNS zwykle używa UDP, ale DHCP *musi* używać UDP. Czym różnią się powody?
3. W przechwyconym ruchu SYN ma `seq 2000`, a SYN-ACK ma `seq 7000`. Jakie numery potwierdzeń niosą SYN-ACK i końcowe ACK i dlaczego „plus jeden”?
4. Serwer pokazuje 3000 gniazd w `TIME-WAIT` i 2000 w `CLOSE-WAIT`. Która liczba by Cię niepokoiła i co byś sprawdził?
5. `ss -tln` pokazuje Twoją usługę na `0.0.0.0:8080`, ale klienci z Internetu dostają „connection timed out”. Wymień dwie możliwe przyczyny i sposób sprawdzenia każdej.
6. Dlaczego SYN flood są problemem dla serwerów TCP i dlaczego SYN cookies nie wymagają, by serwer pamiętał cokolwiek o połączeniach półotwartych?

## Źródła
- [RFC 9293](https://www.rfc-editor.org/rfc/rfc9293) — Transmission Control Protocol (TCP).
- [RFC 768](https://www.rfc-editor.org/rfc/rfc768) — User Datagram Protocol.
- [RFC 6335](https://www.rfc-editor.org/rfc/rfc6335) — Procedures for the Management of the Service Name and Transport Protocol Port Number Registry.
- [IANA Service Name and Transport Protocol Port Number Registry](https://www.iana.org/assignments/service-names-port-numbers/).
- [RFC 6298](https://www.rfc-editor.org/rfc/rfc6298) — Computing TCP's Retransmission Timer.
- [RFC 5681](https://www.rfc-editor.org/rfc/rfc5681) — TCP Congestion Control.
- [RFC 2018](https://www.rfc-editor.org/rfc/rfc2018) — TCP Selective Acknowledgment Options.
- [RFC 7323](https://www.rfc-editor.org/rfc/rfc7323) — TCP Extensions for High Performance (window scaling, timestamps).
- [RFC 9438](https://www.rfc-editor.org/rfc/rfc9438) — CUBIC for Fast and Long-Distance Networks.
- [RFC 6528](https://www.rfc-editor.org/rfc/rfc6528) — Defending against Sequence Number Attacks.
- [RFC 5961](https://www.rfc-editor.org/rfc/rfc5961) — Improving TCP's Robustness to Blind In-Window Attacks.
- [RFC 4987](https://www.rfc-editor.org/rfc/rfc4987) — TCP SYN Flooding Attacks and Common Mitigations.
- [RFC 7766](https://www.rfc-editor.org/rfc/rfc7766) — DNS Transport over TCP — Implementation Requirements.
- [RFC 9000](https://www.rfc-editor.org/rfc/rfc9000) — QUIC: A UDP-Based Multiplexed and Secure Transport.
- [RFC 9114](https://www.rfc-editor.org/rfc/rfc9114) — HTTP/3.
- [RFC 2827](https://www.rfc-editor.org/rfc/rfc2827) — Network Ingress Filtering (BCP 38).
- [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737) — IPv4 Address Blocks Reserved for Documentation.
- [Dokumentacja jądra Linuksa: IP sysctl](https://docs.kernel.org/networking/ip-sysctl.html) — `ip_local_port_range`, `tcp_syn_retries`, `tcp_syncookies` i powiązane ustawienia.
