---
title: "Laboratorium: gniazda TCP i UDP na własnym komputerze"
domain: networking
level: beginner
duration: "60 min"
cost: "bezpłatne"
environment: "Twój własny komputer (Linux, macOS lub Windows) z Pythonem 3; wszystko działa na interfejsie pętli zwrotnej"
lang: pl
source_hash: 64c2dda423c2
---

# Laboratorium: gniazda TCP i UDP na własnym komputerze

## Cel
Piszesz w Pythonie mały serwer echa Transmission Control Protocol (TCP) i serwer echa User Datagram Protocol (UDP), rozmawiasz z nimi za pomocą własnych klientów i `nc` oraz obserwujesz, jak gniazda zmieniają stan, za pomocą `ss` (lub `netstat`). Następnie wywołujesz dwie klasyczne awarie, „connection refused” i „connection timed out”, i sprawdzasz, dlaczego jedna trwa milisekundy, a druga tak długo, jak jej pozwolisz. Wszystko działa na Twoim własnym komputerze, pod adresem `127.0.0.1`.

## Cele
- Wyjaśnić, jak port nasłuchujący i efemeryczny port klienta razem identyfikują połączenie.
- Porównać TCP i UDP, uruchamiając oba na tym samym numerze portu i obserwując, jak różnie się zachowują.
- Zaobserwować przejście połączenia TCP z ESTABLISHED do TIME-WAIT oraz (opcjonalnie) przechwycić handshake i zamykanie za pomocą `tcpdump`.
- Rozpoznawać gniazda nasłuchujące i stany połączeń (LISTEN, ESTAB, TIME-WAIT, UNCONN) za pomocą `ss` lub `netstat`.
- Odtworzyć i wyjaśnić „connection refused” w odróżnieniu od „connection timed out”.

## Wymagania wstępne
- Komputer z Linuksem (z `ss` z iproute2), macOS lub Windows 10/11.
- Python 3.10 lub nowszy, tylko biblioteka standardowa. To laboratorium przetestowano z Pythonem 3.14.7 i 3.11.8. Sprawdź swoją wersję poleceniem `python3 --version` (w Windows: `py --version`).
- `nc` (netcat), opcjonalnie, ale zalecane. Linux: pakiet `netcat-openbsd` (Debian, Ubuntu) lub `nmap-ncat` (Fedora, RHEL). macOS: wbudowany. Windows: niewbudowany; użyj zamiast tego klientów Pythona i `Test-NetConnection`. Poniższe wyniki pochodzą z OpenBSD netcat 1.226.
- Trzy okna terminala: po jednym dla każdego serwera i jedno na Twoje polecenia.
- Opcjonalnie, tylko do Kroku 10: `tcpdump` i uprawnienia administratora (`sudo`) w Linuksie lub macOS.
- [Lekcja: Warstwa transportowa: TCP, UDP i porty](lesson.pl.md) z tego modułu.

> [!WARNING]
> Wszystkie polecenia z tego laboratorium wykonuj **wyłącznie na własnym komputerze**: `127.0.0.1` oraz adres dokumentacyjny `192.0.2.1` (RFC 5737), który nigdy nie jest przypisany do prawdziwego hosta. Nie kieruj `nc -z`, `probe.py` ani żadnego innego testu połączenia na systemy, które nie należą do Ciebie lub których nie masz wyraźnego zezwolenia testować: sondowanie cudzych portów to skanowanie portów, które może być nielegalne i narusza regulaminy większości dostawców. Serwery z tego laboratorium nasłuchują tylko na `127.0.0.1`, więc nic w Twojej sieci nie może się z nimi połączyć.

## Architektura
![Architektura laboratorium. Wszystko działa na Twoim komputerze przez interfejs pętli zwrotnej lo, 127.0.0.1. Klienci tcp_client.py, udp_client.py, nc i probe.py używają efemerycznego portu źródłowego, np. 127.0.0.1:50980. Łączą się przez TCP z serwerem echa TCP pod 127.0.0.1:9000/tcp, przez UDP z serwerem echa UDP pod 127.0.0.1:9000/udp oraz z 127.0.0.1:9001, gdzie nic nie nasłuchuje i który na TCP odpowiada RST, a na UDP komunikatem ICMP port unreachable. Obserwujesz za pomocą ss -tan, ss -uln i opcjonalnie, z sudo, tcpdump -i lo. Jedna sonda wysyła SYN na adres dokumentacyjny 192.0.2.1:80, który nigdy nie odpowiada, więc kończy się przekroczeniem czasu](../../../assets/diagrams/tcp-lab-architecture.pl.svg)

*Rysunek 1. Dwa serwery dzielą numer portu 9000, jeden dla TCP, drugi dla UDP. Port 9001 nie ma serwera, a `192.0.2.1` nigdy nie odpowiada.*

## Kroki

### Krok 1 — Utwórz folder roboczy
Napiszesz pięć małych skryptów. Trzymaj je w jednym folderze, by sprzątanie było jednym poleceniem.

Linux i macOS:

```bash
mkdir -p ~/tcp-lab && cd ~/tcp-lab
```

Windows (PowerShell):

```powershell
New-Item -ItemType Directory -Force "$HOME\tcp-lab"; Set-Location "$HOME\tcp-lab"
```

Używaj tego folderu we wszystkich trzech terminalach. W Windows wpisuj `py` wszędzie tam, gdzie to laboratorium mówi `python3`.

### Krok 2 — Sprawdź, zanim cokolwiek ruszysz
Zanim uruchomisz własne serwery, zobacz, na czym Twój komputer już nasłuchuje i jakiego zakresu używa dla portów efemerycznych.

**Linux:**

```bash
ss -tuln
cat /proc/sys/net/ipv4/ip_local_port_range
```

Oczekiwany wynik (skrócony; Twoja lista będzie inna):

```text
Netid State  Recv-Q Send-Q   Local Address:Port  Peer Address:Port
udp   UNCONN 0      0        127.0.0.53%lo:53         0.0.0.0:*
udp   UNCONN 0      0            127.0.0.1:323        0.0.0.0:*
udp   UNCONN 0      0              0.0.0.0:5353       0.0.0.0:*
tcp   LISTEN 0      4096     127.0.0.53%lo:53         0.0.0.0:*
tcp   LISTEN 0      4096         127.0.0.1:631        0.0.0.0:*
32768	60999
```

Na typowym pulpicie zobaczysz lokalny resolwer Domain Name System (DNS) na porcie 53 (tu `systemd-resolved`, pod `127.0.0.53`), usługę czasu na UDP 323, multicast DNS na UDP 5353 i usługę druku na TCP 631. Większość nasłuchuje tylko na adresach pętli zwrotnej. Ostatnia linia to zakres portów efemerycznych: Linux domyślnie używa 32768–60999, a nie zakresu 49152–65535 z RFC 6335.

**macOS:**

```bash
netstat -an -p tcp | grep LISTEN
sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last
```

**Windows (PowerShell):**

```powershell
Get-NetTCPConnection -State Listen | Sort-Object LocalPort | Select-Object LocalAddress, LocalPort, OwningProcess
netsh int ipv4 show dynamicport tcp
```

W macOS i Windows domyślny zakres dynamiczny to 49152–65535.

> [!NOTE]
> Poleceń dla macOS i Windows nie uruchamiano na potrzeby tego przewodnika, więc ich wynik nie jest pokazany; kolumny są oczywiste. Port 9000 musi być wolny na potrzeby tego laboratorium. Jeśli coś już na nim nasłuchuje, zmień `PORT` w każdym skrypcie na inny wolny port powyżej 1024, na przykład 9500.

### Krok 3 — Napisz i uruchom serwer echa TCP
Serwer potrzebuje stałego, znanego portu, aby klienci mogli go znaleźć. Ten nasłuchuje na `127.0.0.1:9000` i odsyła każdy odebrany bajt. Zapisz go jako `tcp_server.py`:

```python
"""TCP echo server: accepts connections on 127.0.0.1:9000 and sends back every byte it receives."""
import socket
import sys

HOST, PORT = "127.0.0.1", 9000

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as srv:
    if sys.platform != "win32":
        # Allow a restart while old connections are still in TIME-WAIT.
        # (On Windows this option means something else, so it is skipped there.)
        srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    srv.bind((HOST, PORT))
    srv.listen()
    print(f"TCP echo server listening on {HOST}:{PORT}", flush=True)
    try:
        while True:
            conn, peer = srv.accept()  # blocks until a handshake completes
            with conn:
                print(f"connection from {peer[0]}:{peer[1]}", flush=True)
                while data := conn.recv(1024):  # b"" means the client sent FIN
                    conn.sendall(data)
                print(f"{peer[0]}:{peer[1]} closed the connection", flush=True)
    except KeyboardInterrupt:
        print("server stopped")
```

- `SOCK_STREAM` prosi o TCP. `bind()` rezerwuje adres i port; `listen()` zamienia gniazdo w gniazdo nasłuchujące.
- `accept()` zwraca dopiero wtedy, gdy klient zakończył trójetapowy handshake. Handshake wykonał system operacyjny; Twój program tylko odbiera wynik.
- `recv()` zwraca pusty wynik, gdy klient wysłał FIN. W ten sposób program TCP dowiaduje się, że druga strona zamknęła połączenie.

W **terminalu 1** uruchom go i zostaw działający:

```bash
python3 tcp_server.py
```

Oczekiwany wynik:

```text
TCP echo server listening on 127.0.0.1:9000
```

### Krok 4 — Znajdź gniazdo nasłuchujące
W **terminalu 3** (Twoim terminalu poleceń) zapytaj system operacyjny, kto nasłuchuje na porcie 9000. Filtr `'sport = :9000'` (port źródłowy, który dla gniazda nasłuchującego jest portem lokalnym) skraca wynik.

**Linux:**

```bash
ss -tlnp 'sport = :9000'
```

Oczekiwany wynik (Twój identyfikator procesu będzie inny):

```text
State  Recv-Q Send-Q Local Address:Port Peer Address:PortProcess
LISTEN 0      128        127.0.0.1:9000      0.0.0.0:*    users:(("python3",pid=4242,fd=3))
```

- `LISTEN` na `127.0.0.1:9000`: połączyć się mogą tylko programy na tym komputerze.
- `Peer Address:Port` to `0.0.0.0:*`, ponieważ gniazdo nasłuchujące nie ma jeszcze partnera.
- `Send-Q 128` to backlog: ile zakończonych handshake'ów może czekać na `accept()`.
- `users:(("python3",pid=…))` to proces będący właścicielem. Widzisz go bez `sudo`, bo gniazdo jest Twoje.

**macOS:** `lsof -nP -iTCP:9000 -sTCP:LISTEN`. **Windows (PowerShell):** `Get-NetTCPConnection -LocalPort 9000`.

### Krok 5 — Połącz się i obserwuj połączenie
Teraz potrzebujesz klienta. Łączy się, wypisuje swój adres i port oraz adres i port serwera, wysyła wiadomość i odczytuje echo. Opcjonalny argument utrzymuje połączenie otwarte przez kilka sekund, żebyś mógł je obejrzeć. Zapisz go jako `tcp_client.py`:

```python
"""TCP client: connects to the echo server, sends one message, prints the reply."""
import socket
import sys
import time

HOST, PORT = "127.0.0.1", 9000
HOLD = int(sys.argv[1]) if len(sys.argv) > 1 else 0  # seconds to keep the connection open

with socket.create_connection((HOST, PORT), timeout=5) as sock:
    local, remote = sock.getsockname(), sock.getpeername()
    print(f"connected: {local[0]}:{local[1]} -> {remote[0]}:{remote[1]}")
    sock.sendall(b"hello over TCP")
    print("reply:", sock.recv(1024).decode())
    time.sleep(HOLD)
print("closed")
```

Zauważ, że klient nigdy nie wybiera własnego portu: `create_connection()` pozwala systemowi operacyjnemu wybrać port efemeryczny.

W terminalu 3 uruchom klienta w tle z 15-sekundowym oczekiwaniem, a zaraz potem wyświetl gniazda TCP na porcie 9000. W Linuksie:

```bash
python3 tcp_client.py 15 &
ss -tan '( sport = :9000 or dport = :9000 )'
```

Oczekiwany wynik (Twój port efemeryczny będzie inny; linie klienta mogą pojawić się przed tabelą lub po niej):

```text
connected: 127.0.0.1:36784 -> 127.0.0.1:9000
reply: hello over TCP
State  Recv-Q Send-Q Local Address:Port  Peer Address:Port
LISTEN 0      128        127.0.0.1:9000       0.0.0.0:*
ESTAB  0      0          127.0.0.1:36784    127.0.0.1:9000
ESTAB  0      0          127.0.0.1:9000     127.0.0.1:36784
```

Przeczytaj trzy linie:
- Gniazdo `LISTEN` wciąż tam jest: nadal czeka na *następnego* klienta.
- Połączenie pojawia się **dwa razy**, raz z każdego końca, ponieważ oba końce są na Twoim komputerze. Strona klienta to `127.0.0.1:36784 → 127.0.0.1:9000`; strona serwera jest jej lustrzanym odbiciem.
- `36784` mieści się w zakresie efemerycznym z Kroku 2. Uruchom klienta jeszcze raz, a dostaniesz inny port.

W terminalu 1 serwer zapisał połączenie:

```text
connection from 127.0.0.1:36784
```

W macOS uruchom klienta tak samo i użyj `netstat -an -p tcp | grep 9000`. W Windows uruchom `py tcp_client.py 15` w dodatkowym terminalu i w ciągu 15 sekund wykonaj w terminalu 3 `Get-NetTCPConnection -LocalPort 9000; Get-NetTCPConnection -RemotePort 9000`.

### Krok 6 — Zobacz TIME-WAIT
Poczekaj, aż klient wypisze `closed` (15 sekund), i spójrz ponownie:

```bash
ss -tan '( sport = :9000 or dport = :9000 )'
ss -tano state time-wait '( sport = :9000 or dport = :9000 )'
```

Oczekiwany wynik:

```text
State     Recv-Q Send-Q Local Address:Port  Peer Address:Port
LISTEN    0      128        127.0.0.1:9000       0.0.0.0:*
TIME-WAIT 0      0          127.0.0.1:36784    127.0.0.1:9000
Recv-Q Send-Q Local Address:Port  Peer Address:Port
0      0          127.0.0.1:36784    127.0.0.1:9000 timer:(timewait,58sec,0)
```

- Dla starego połączenia została tylko jedna linia i jest na porcie **klienta**. Klient zamknął pierwszy (jego blok `with` się skończył), więc to klient jest stroną czekającą w TIME-WAIT. Strona serwera przeszła od razu do CLOSED po potwierdzeniu własnego FIN.
- `-o` pokazuje liczniki czasu: `timewait,58sec` odlicza od 60 sekund, czyli stałego czasu TIME-WAIT w Linuksie. Uruchom polecenie jeszcze raz po minucie: linii już nie ma.

Serwer zapisał zamknięcie w terminalu 1:

```text
127.0.0.1:36784 closed the connection
```

W macOS i Windows `netstat -an -p tcp | grep 9000` (macOS) lub `netstat -an -p tcp | findstr 9000` (Windows) pokazuje to samo połączenie jako `TIME_WAIT`. Ich liczniki czasu różnią się od linuksowych.

### Krok 7 — Porozmawiaj z serwerem przez netcat
Twój klient nie jest wyjątkowy: z serwerem może rozmawiać każdy program TCP. Netcat (`nc`) łączy się, a potem kopiuje Twoją klawiaturę do gniazda, a gniazdo na Twój ekran.

```bash
nc 127.0.0.1 9000
```

Wpisz `hello from nc` i naciśnij Enter. Serwer odsyła to echem:

```text
hello from nc
hello from nc
```

Pierwsza linia to to, co wpisałeś, druga to echo. Naciśnij **Ctrl+C**, aby wyjść. Terminal 1 zapisuje połączenie i zamknięcie, każde z nowym portem efemerycznym.

> [!NOTE]
> Istnieje kilka implementacji netcata z nieco różnymi opcjami i komunikatami: OpenBSD netcat (Debian, Ubuntu i baza `nc` w macOS), `ncat` z Nmapa (Fedora, RHEL) oraz stary „tradycyjny” netcat. Podstawowe `nc <host> <port>` działa we wszystkich. W Windows pomiń polecenia `nc` i użyj klientów Pythona.

### Krok 8 — Dodaj serwer UDP na tym samym numerze portu
TCP i UDP mają oddzielne przestrzenie portów, więc serwer UDP też może używać portu 9000. Zapisz to jako `udp_server.py`:

```python
"""UDP echo server: receives datagrams on 127.0.0.1:9000 and sends each one back."""
import socket

HOST, PORT = "127.0.0.1", 9000

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as srv:
    srv.bind((HOST, PORT))
    print(f"UDP echo server listening on {HOST}:{PORT}", flush=True)
    try:
        while True:
            data, peer = srv.recvfrom(2048)  # no accept(): every datagram stands alone
            print(f"datagram from {peer[0]}:{peer[1]}: {data.decode(errors='replace')}", flush=True)
            srv.sendto(data, peer)
    except KeyboardInterrupt:
        print("server stopped")
```

Porównaj go z serwerem TCP: `SOCK_DGRAM` zamiast `SOCK_STREAM`, brak `listen()`, brak `accept()` i brak obiektu połączenia. Każdy datagram przychodzi z adresem nadawcy, a odpowiedź wraca pod ten adres.

W **terminalu 2** uruchom go:

```bash
python3 udp_server.py
```

```text
UDP echo server listening on 127.0.0.1:9000
```

W terminalu 3 wyświetl razem gniazda TCP i UDP na porcie 9000:

```bash
ss -tuln 'sport = :9000'
```

Oczekiwany wynik:

```text
Netid State  Recv-Q Send-Q Local Address:Port Peer Address:Port
udp   UNCONN 0      0          127.0.0.1:9000      0.0.0.0:*
tcp   LISTEN 0      128        127.0.0.1:9000      0.0.0.0:*
```

Dwa gniazda, ten sam adres, ten sam numer portu, różne protokoły. To UDP jest w stanie `UNCONN` (niepołączone), a nie `LISTEN`: UDP nie ma połączeń, na które mógłby czekać.

Teraz klient. Zapisz go jako `udp_client.py`:

```python
"""UDP client: sends one datagram to 127.0.0.1 and waits up to 2 seconds for an answer."""
import socket
import sys

HOST = "127.0.0.1"
PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 9000

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
    sock.settimeout(2)
    sock.connect((HOST, PORT))  # for UDP, connect() only sets the default destination: nothing is sent
    local = sock.getsockname()
    print(f"sending from {local[0]}:{local[1]} to {HOST}:{PORT}")
    sock.send(b"hello over UDP")
    try:
        print("reply:", sock.recv(2048).decode())
    except TimeoutError:
        print("no reply within 2 s (lost, filtered, or nobody listening)")
    except ConnectionError:
        print("error: port unreachable (an ICMP message said nobody is listening)")
```

Uruchom go:

```bash
python3 udp_client.py
```

Oczekiwany wynik:

```text
sending from 127.0.0.1:40760 to 127.0.0.1:9000
reply: hello over UDP
```

Terminal 2 pokazuje `datagram from 127.0.0.1:40760: hello over UDP`. Potem wypróbuj netcat w trybie UDP (`-u`), wpisz linię, odczytaj echo i naciśnij Ctrl+C:

```bash
nc -u 127.0.0.1 9000
```

Po kliencie UDP uruchom ponownie `ss -tan '( sport = :9000 or dport = :9000 )'` i `ss -uan 'sport = :9000'`: dla UDP nie ma ESTAB ani TIME-WAIT. Nic nie zostało nawiązane, więc nic nie trzeba zamykać.

### Krok 9 — Connection refused a connection timed out
To umiejętność diagnostyczna z lekcji. Sprawisz, że połączenie zawiedzie na trzy sposoby, i zmierzysz czas każdego. Zapisz to jako `probe.py`:

```python
"""Try a TCP connection and report how it ended and how long it took."""
import socket
import sys
import time

host, port = sys.argv[1], int(sys.argv[2])
timeout = float(sys.argv[3]) if len(sys.argv) > 3 else 3

start = time.monotonic()
try:
    with socket.create_connection((host, port), timeout=timeout):
        result = "open: handshake completed"
except ConnectionRefusedError:
    result = "refused: the host answered with RST"
except TimeoutError:
    result = "timed out: no answer at all"
except OSError as exc:
    result = f"error: {exc.strerror}"
print(f"{host}:{port} -> {result} after {time.monotonic() - start:.2f} s")
```

Sondaż otwartego portu, zamkniętego portu na własnym komputerze oraz adresu dokumentacyjnego `192.0.2.1`, który nigdy nie jest nikomu przypisany:

```bash
python3 probe.py 127.0.0.1 9000
python3 probe.py 127.0.0.1 9001
python3 probe.py 192.0.2.1 80 3
```

Oczekiwany wynik:

```text
127.0.0.1:9000 -> open: handshake completed after 0.01 s
127.0.0.1:9001 -> refused: the host answered with RST after 0.01 s
192.0.2.1:80 -> timed out: no answer at all after 3.01 s
```

- **Port 9000:** handshake kończy się powodzeniem. Terminal 1 zapisuje połączenie.
- **Port 9001:** Twój komputer odebrał SYN, nie znalazł gniazda nasłuchującego i od razu odpowiedział RST: *connection refused*.
- **`192.0.2.1`:** SYN opuszcza Twój komputer i nikt nigdy nie odpowiada, więc klient czeka cały podany limit czasu (3 s): *timed out*. Bez limitu czasu Linux ponawia SYN przez nieco ponad dwie minuty, zanim się podda.

`<timeout>`, opcjonalny trzeci argument, to liczba sekund oczekiwania. Spróbuj `python3 probe.py 192.0.2.1 80 10`, a wynik przyjdzie po 10 sekundach: opóźnienie ustala *klient*, a nie sieć.

Te same testy z netcatem (`-v` gadatliwy, `-z` połącz bez wysyłania danych, `-w 3` limit czasu):

```bash
nc -vz 127.0.0.1 9000
nc -vz 127.0.0.1 9001
nc -vz -w 3 192.0.2.1 80
```

```text
Connection to 127.0.0.1 9000 port [tcp/*] succeeded!
nc: connect to 127.0.0.1 port 9001 (tcp) failed: Connection refused
nc: connect to 192.0.2.1 port 80 (tcp) timed out: Operation in progress
```

Tekst w nawiasach kwadratowych może pokazywać nazwę usługi z listy usług Twojego systemu zamiast `*`. W Windows (PowerShell) równoważnym sprawdzeniem jest `Test-NetConnection -ComputerName 127.0.0.1 -Port 9001`, które zgłasza `TcpTestSucceeded : False` dla obu rodzajów awarii; użyj `probe.py`, aby zobaczyć różnicę.

Na koniec UDP do zamkniętego portu:

```bash
python3 udp_client.py 9001
```

```text
sending from 127.0.0.1:56778 to 127.0.0.1:9001
error: port unreachable (an ICMP message said nobody is listening)
```

Twój komputer odpowiedział na datagram komunikatem „port unreachable” protokołu Internet Control Message Protocol (ICMP), a ponieważ klient użył `connect()`, system operacyjny zgłosił to jako błąd. W prawdziwej sieci ten komunikat ICMP jest często filtrowany, a klient po prostu wypisałby `no reply within 2 s`: w UDP „zamknięty” i „zgubiony” mogą wyglądać identycznie.

> [!NOTE]
> Czasy i komunikaty różnią się w zależności od systemu operacyjnego. W Windows odrzucone połączenie może trwać około dwóch sekund, bo klient ponawia próbę kilka razy po RST, a błąd UDP może być zgłaszany jako *reset* połączenia; skrypt przechwytuje oba. Twoja sieć może też szybko odpowiedzieć dla `192.0.2.1` komunikatem „No route to host” lub „Network is unreachable” (skrypt wypisze `error: …`), jeśli nie ma trasy do tego zakresu. To trzeci rodzaj awarii, pochodzący z warstwy sieci, a nie od celu.

### Krok 10 (opcjonalnie) — Przechwyć handshake za pomocą tcpdump
Ten krok wymaga uprawnień administratora. Pomiń go, jeśli ich nie masz; poniższy wynik pokazuje, co byś zobaczył.

W terminalu 3 uruchom przechwytywanie na interfejsie pętli zwrotnej (`lo` w Linuksie, `lo0` w macOS). `-n` pokazuje liczby zamiast nazw:

```bash
sudo tcpdump -i lo -n 'tcp port 9000 or tcp port 9001 or icmp'
```

W dodatkowym terminalu uruchom raz klienta i raz sondaż zamkniętego portu:

```bash
python3 tcp_client.py
python3 probe.py 127.0.0.1 9001
python3 udp_client.py 9001
```

Zatrzymaj przechwytywanie za pomocą Ctrl+C. Oczekiwany wynik (znaczniki czasu i opcje TCP skrócone; Twoje porty, numery sekwencyjne i okna będą inne):

```text
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [S], seq 646296056, win 65495, options [mss 65495,…], length 0
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [S.], seq 1082532584, ack 646296057, win 65483, options [mss 65495,…], length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [.], ack 1, win 64, length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [P.], seq 1:15, ack 1, win 64, length 14
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [.], ack 15, win 64, length 0
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [P.], seq 1:15, ack 15, win 64, length 14
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [.], ack 15, win 64, length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [F.], seq 15, ack 15, win 64, length 0
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [F.], seq 15, ack 16, win 64, length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [.], ack 16, win 64, length 0
IP 127.0.0.1.34924 > 127.0.0.1.9001: Flags [S], seq 1486054817, win 65495, options [mss 65495,…], length 0
IP 127.0.0.1.9001 > 127.0.0.1.34924: Flags [R.], seq 0, ack 1486054818, win 0, length 0
IP 127.0.0.1 > 127.0.0.1: ICMP 127.0.0.1 udp port 9001 unreachable, length 50
```

Dopasuj to do lekcji:
- Linie 1–3: trójetapowy handshake, `[S]`, `[S.]`, `[.]`. Początkowe numery sekwencyjne (ISN) są losowe; SYN-ACK potwierdza ISN klienta + 1. Od linii 3 `tcpdump` wypisuje numery sekwencyjne względem ISN.
- Linie 4–7: `hello over TCP` to 14 bajtów (`seq 1:15`, `length 14`), potwierdzone `ack 15`, potem odesłane jako echo i potwierdzone w ten sam sposób.
- Linie 8–10: zamykanie. FIN klienta, potem FIN serwera połączony z ACK na FIN klienta (`ack 16`: FIN liczy się jako jeden bajt), potem końcowe ACK klienta. Łączenie dwóch kroków w jednym segmencie jest częste, więc często widać trzy segmenty zamykania zamiast czterech.
- Linie 11–12: SYN do zamkniętego portu 9001, na który odpowiada `[R.]` (RST, ACK). To jest „connection refused” w sieci.
- Linia 13: komunikat ICMP port unreachable dla datagramu UDP do 9001.
- Maksymalny rozmiar segmentu (MSS) 65495 i duże okna są typowe dla pętli zwrotnej, której maksymalna jednostka transmisji (MTU) wynosi 65536. W Ethernecie zobaczyłbyś `mss 1460`.

> [!NOTE]
> To przechwycenie zarejestrowano za pomocą `tcpdump` w Linuksie. SYN do `192.0.2.1` pojawiłby się jako ta sama linia `[S]` powtórzona kilka razy z rosnącymi odstępami i bez odpowiedzi, tak właśnie wygląda timeout w sieci. Aby to zobaczyć, przechwytuj na głównym interfejsie (na przykład `eth0`, `en0` lub nazwie zgłoszonej przez `ip route show default`) zamiast na pętli zwrotnej.

## Weryfikacja
Laboratorium jest ukończone, jeśli na każdy punkt możesz odpowiedzieć „tak”:

| Sprawdzenie | Jak potwierdzić |
|---|---|
| Serwer TCP nasłuchuje na `127.0.0.1:9000` | `ss -tlnp 'sport = :9000'` pokazuje `LISTEN` i Twój proces `python3` |
| Widziałeś jedno połączenie z obu końców | Krok 5 pokazuje dwie lustrzane linie `ESTAB` z portem efemerycznym z Twojego zakresu z Kroku 2 |
| Widziałeś TIME-WAIT po stronie, która zamknęła pierwsza | Krok 6 pokazuje `TIME-WAIT` tylko na efemerycznym porcie klienta, z licznikiem co najwyżej 60 s w Linuksie |
| TCP i UDP dzielą numer portu 9000 | `ss -tuln 'sport = :9000'` pokazuje linię `tcp LISTEN` i linię `udp UNCONN` |
| Umiesz odróżnić refused od timed out | `probe.py` zgłasza `refused` w około 0,01 s dla portu 9001 i `timed out` po wybranym limicie czasu dla `192.0.2.1` |

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `OSError: [Errno 98] Address already in use` (Linux), `[Errno 48]` (macOS) lub `[WinError 10048]` (Windows) przy uruchamianiu serwera | Inna kopia serwera wciąż działa albo coś innego używa portu 9000 | Znajdź to poleceniem `ss -tulnp 'sport = :9000'` (Linux), `lsof -nP -i :9000` (macOS) lub `Get-NetTCPConnection -LocalPort 9000` (Windows); zatrzymaj albo zmień `PORT` we wszystkich skryptach |
| `ConnectionRefusedError: [Errno 111] Connection refused` z `tcp_client.py` | Serwer TCP nie działa albo nasłuchuje na innym porcie | Sprawdź terminal 1; uruchom ponownie `python3 tcp_server.py` |
| `udp_client.py` wypisuje `no reply within 2 s`, chociaż serwer UDP powinien działać | Serwer UDP nie działa albo lokalna zapora odrzuca UDP przez pętlę zwrotną | Sprawdź terminal 2 i `ss -uln 'sport = :9000'` |
| `nc: command not found` | Netcat nie jest zainstalowany | Zainstaluj `netcat-openbsd` lub `nmap-ncat` albo pomiń polecenia `nc`; klienci Pythona robią to samo |
| `probe.py 192.0.2.1 80` od razu wypisuje `error: No route to host` lub `Network is unreachable` | Twój system lub sieć nie ma trasy do `192.0.2.0/24` albo router odpowiada ICMP | W porządku: to awaria warstwy sieci, a nie timeout. Porównaj z listą błędów z lekcji |
| Linie `ESTAB` nie pojawiają się w Kroku 5 | Minęło więcej niż 15 s, zanim uruchomiono `ss`, albo klient zawiódł | Uruchom oba polecenia razem, jak pokazano, albo wydłuż oczekiwanie: `python3 tcp_client.py 30 &` |
| `tcpdump: lo: No such device exists` | W macOS interfejs pętli zwrotnej to `lo0` | Użyj `sudo tcpdump -i lo0 -n …` |

## Wyzwanie (opcjonalne)
1. Zmień `tcp_server.py` tak, aby to **serwer** zamykał połączenie zaraz po wysłaniu echa (wyjdź z pętli po pierwszym `sendall()`). Która strona pokazuje teraz TIME-WAIT? Potem usuń linię `SO_REUSEADDR`, uruchom klienta, zatrzymaj serwer i uruchom go ponownie w ciągu minuty. Co się dzieje i dlaczego prawie każdy prawdziwy serwer ustawia `SO_REUSEADDR`?
2. Spraw, by serwer nasłuchiwał na `0.0.0.0` zamiast na `127.0.0.1`, i sprawdź różnicę za pomocą `ss -tln`. Czy jest teraz osiągalny z innego urządzenia w Twojej sieci? Czy zapora Twojego hosta na to pozwala? Gdy skończysz, przywróć poprzednie ustawienie.
3. Otwórz dziesięć połączeń naraz (na przykład `for i in $(seq 10); do python3 tcp_client.py 20 & done`) i policz je za pomocą `ss -tan '( dport = :9000 )' | wc -l`. Która część czwórki różni się między nimi?
4. Wyślij 5000-bajtową wiadomość za pomocą `tcp_client.py` i odczytaj ją jednym `recv(1024)`. Co dociera? Co to mówi o TCP jako strumieniu bajtów i jak zaprojektowałbyś format wiadomości na jego bazie?

## Sprzątanie
Zatrzymaj oba serwery: naciśnij **Ctrl+C** w terminalu 1 i terminalu 2. Każdy wypisze `server stopped`. Zamknij sesje `nc` za pomocą Ctrl+C i zatrzymaj `tcpdump`, jeśli jeszcze działa.

Sprawdź, czy na porcie 9000 nic nie zostało (Linux):

```bash
ss -tuln 'sport = :9000'
```

```text
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
```

Sama linia nagłówka oznacza, że oba serwery zniknęły. Jeśli któryś serwer wciąż działa (na przykład zamknąłeś jego terminal), zatrzymaj go poleceniem `pkill -f tcp_server.py; pkill -f udp_server.py` w Linuksie lub macOS albo `Get-Process python*` i `Stop-Process -Id <pid>` w Windows. `<pid>` to identyfikator procesu pokazany przez `ss -tulnp` lub `Get-NetTCPConnection` (kolumna `OwningProcess`).

Usuń folder i pięć skryptów.

Linux i macOS:

```bash
cd ~ && rm -r ~/tcp-lab
```

Windows (PowerShell):

```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\tcp-lab"
```

Wpisy TIME-WAIT znikają same w ciągu mniej więcej minuty. Żadne ustawienia systemu nie zostały zmienione, więc nie ma nic więcej do cofnięcia.

## Co już umiesz
- Serwer wiąże stały port i nasłuchuje; każdy klient dostaje od systemu operacyjnego port efemeryczny, a czwórka nazywa połączenie. Na jednej maszynie widzisz każde połączenie dwa razy, raz z każdego końca.
- TCP i UDP mają oddzielne przestrzenie portów. TCP pokazuje LISTEN, ESTAB i TIME-WAIT; UDP tylko UNCONN, bo nie ma połączeń.
- Strona, która zamyka pierwsza, trzyma TIME-WAIT (60 s w Linuksie). To normalne i znika samo.
- „Connection refused” to odpowiedź (RST) i przychodzi w milisekundach. „Connection timed out” to cisza, a czas jej trwania zależy od limitu czasu klienta.
- `ss` (lub `netstat`, `lsof`, `Get-NetTCPConnection`) oraz, z uprawnieniami administratora, `tcpdump` pokazują dokładnie, co robi warstwa transportowa.
