Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## 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
<figure class="diagram" style="--dg-w: 980px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 980 480" width="980" height="480" role="img" aria-labelledby="tcp-lab-architecture-pl-title tcp-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="tcp-lab-architecture-pl-title">Architektura laboratorium: gniazda TCP i UDP na własnym komputerze</title>
<desc id="tcp-lab-architecture-pl-desc">Wszystko działa na Twoim komputerze przez interfejs pętli zwrotnej, 127.0.0.1. Klienci tcp_client.py, udp_client.py, nc i probe.py używają efemerycznych portów źródłowych. Łączą się z serwerem echo TCP na 127.0.0.1 port 9000, serwerem echo UDP na 127.0.0.1 port 9000 oraz portem 9001, na którym 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 idzie na adres dokumentacyjny 192.0.2.1 port 80, który nigdy nie odpowiada, więc połączenie kończy się przekroczeniem czasu.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="979" height="479" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="700" height="400" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Twój komputer · interfejs pętli zwrotnej (lo) · 127.0.0.1</text></g>
<rect class="dg-card" x="44" y="64" width="200" height="330" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 80) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="102" y="101" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Klienci</text>
<text x="62" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">tcp_client.py</text>
<text x="62" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">udp_client.py</text>
<text x="62" y="172" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nc</text>
<text x="62" y="192" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">probe.py</text>
<text x="62" y="230" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="500">źródło: port efemeryczny</text>
<g class="dg-l4"><rect class="dg-tint" x="62" y="244" width="132" height="26" rx="13" fill="#f9ece7" stroke="#e4aa92" stroke-width="1.2"/><text x="128" y="261.5" font-size="12" class="dg-ink" fill="#c2410c" font-weight="700" text-anchor="middle">127.0.0.1:50980</text></g>
<rect class="dg-card" x="440" y="64" width="260" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(456 80) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g></g>
<g class="dg-l4"><text x="498" y="101" font-size="15" class="dg-ink" fill="#c2410c" font-weight="700">Serwer echo TCP</text></g>
<text x="458" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9000/tcp</text>
<g class="dg-l4"><path class="dg-stroke" d="M248 110H434" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M427 104l8 6-8 6" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="323.34" y="98" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="342" y="114.5" font-size="11.5" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle">TCP</text></g>
<rect class="dg-card" x="440" y="176" width="260" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(456 192) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g></g>
<g class="dg-l1"><text x="498" y="213" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Serwer echo UDP</text></g>
<text x="458" y="244" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9000/udp</text>
<g class="dg-l1"><path class="dg-stroke" d="M248 222H434" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M427 216l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="323.34" y="210" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="342" y="226.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">UDP</text></g>
<rect class="dg-card" x="440" y="288" width="260" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(456 304) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g></g>
<g class="dg-warn"><text x="498" y="325" font-size="15" class="dg-ink" fill="#b91c1c" font-weight="700">Nic nie nasłuchuje</text></g>
<text x="458" y="356" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9001</text>
<text x="458" y="376" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">TCP: RST · UDP: ICMP unreachable</text>
<g class="dg-warn"><path class="dg-stroke" d="M248 334H434" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M427 328l8 6-8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><rect class="dg-bg-plain" x="304.02" y="322" width="75.96" height="24" rx="12" fill="#ffffff"/><text x="342" y="338.5" font-size="11.5" class="dg-ink" fill="#b91c1c" font-weight="600" text-anchor="middle">TCP / UDP</text></g>
<rect class="dg-card" x="750" y="64" width="210" height="170" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(766 80) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g>
<text x="808" y="101" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Obserwuj za pomocą</text>
<text x="768" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">ss -tan</text>
<text x="768" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">ss -uln</text>
<text x="768" y="172" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">tcpdump -i lo</text>
<text x="768" y="192" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">(opcjonalnie, wymaga sudo)</text>
<rect class="dg-card" x="750" y="270" width="210" height="140" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(766 286) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="808" y="307" font-size="14" class="dg-text" fill="#17171c" font-weight="700">192.0.2.1:80</text>
<text x="768" y="338" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Adres dokumentacyjny</text>
<text x="768" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">brak odpowiedzi → timeout</text>
<g class="dg-warn"><path class="dg-stroke" d="M144 394V450H855V416" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M849 423l6-8 6 8" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><rect class="dg-bg-plain" x="394.4" y="438" width="211.2" height="24" rx="12" fill="#ffffff"/><text x="500" y="454.5" font-size="11.5" class="dg-ink" fill="#b91c1c" font-weight="600" text-anchor="middle">SYN, brak odpowiedzi → timeout</text></g>
</svg></figure>
*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.