Socket programming — TCP server - client, UDP server - client in Python
4.3.28· Coding › Computer Networks
WHY socket programming exist karti hai?
WHAT problem solve karti hai? Do processes jo memory share nahi karti (alag machines, ya ek machine par sirf alag programs) unhe data exchange karna hota hai. OS network card ka owner hota hai. Sockets wo API hai jo OS tumhe deta hai bytes ko network tak pahunchane aur network se receive karne ke liye.
WHY do flavours (TCP / UDP)? Reliability ki cost latency hai. Kabhi kabhi tumhe zaroor har byte order mein chahiye hota hai (web pages, files) → TCP. Kabhi speed zyada important hoti hai beech-beech mein kho jaane waale packet se zyada (video calls, DNS, gaming) → UDP.
HOW calls fit together hote hain ("from scratch" mental derivation)
Call list ko memorize mat karo — isse derive karo ki har side ko kya karna hai.
Ek TCP server ko: (1) socket create karna hai, (2) ek address claim karna hai taaki clients usse dhundh sakein → bind, (3) kehna hai "main incoming calls queue karne ke liye taiyaar hoon" → listen, (4) actually call pick up karna hai → accept (yeh ek naya socket return karta hai sirf us ek client ke liye), (5) read/write karna hai, (6) hang up karna hai → close.
Ek TCP client ko: (1) socket create karna hai, (2) dial karna hai → connect, (3) read/write karna hai, (4) close karna hai.
Worked Example 1 — TCP echo server + client
# ---- tcp_server.py ----
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # IPv4 + TCP
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # reuse port quickly after restart
s.bind(('127.0.0.1', 9000)) # claim address
s.listen(5) # queue up to 5 pending connections
print("listening...")
conn, addr = s.accept() # BLOCKS until a client dials; conn = per-client socket
print("connected by", addr)
data = conn.recv(1024) # read up to 1024 bytes
conn.sendall(b"echo: " + data)# send back
conn.close()
s.close()# ---- tcp_client.py ----
import socket
c = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
c.connect(('127.0.0.1', 9000)) # dial the server
c.sendall(b"hello") # send bytes (NOT str!)
print(c.recv(1024).decode()) # -> echo: hello
c.close()| Step | Why this step? |
|---|---|
setsockopt(... SO_REUSEADDR ...) |
Iske bina, server ko jaldi restart karo → "Address already in use" kyunki OS port ko TIME_WAIT mein rakhta hai. |
bind(('127.0.0.1', 9000)) |
Server ko ek known address own karna hota hai taaki client usse target kar sake. Client usually bind nahi karta — OS ek ephemeral port choose karta hai. |
listen(5) |
Socket ko "passive" banata hai. 5 backlog hai = max half-/fully-formed connections jo accept ka wait kar rahi hain. |
conn, addr = accept() |
Ek doosra socket return karta hai jo is client ke liye dedicated hai. Original s doosron ko accept karne ke liye free rehta hai. |
conn.recv(1024) |
1024 ek max hai — TCP ek stream hai, toh ek recv kam return kar sakta hai ya kai sends ko merge kar sakta hai. |
sendall vs send |
send data ka part transmit kar sakta hai; sendall loop karta hai jab tak saare bytes send nahi ho jaate. |
Worked Example 2 — UDP echo server + client
# ---- udp_server.py ----
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # IPv4 + UDP
s.bind(('127.0.0.1', 9001))
print("udp up...")
data, addr = s.recvfrom(1024) # get one datagram + sender's address
s.sendto(b"echo: " + data, addr)# reply to that exact address
s.close()# ---- udp_client.py ----
import socket
c = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
c.sendto(b"hi udp", ('127.0.0.1', 9001)) # no connect; address goes with the packet
print(c.recvfrom(1024)[0].decode()) # -> echo: hi udp
c.close()| Step | Why this step? |
|---|---|
SOCK_DGRAM |
UDP select karta hai: har sendto ek self-contained packet (datagram) hota hai. |
recvfrom returns (data, addr) |
Hume jaanna padta hai kisne bheja, kyunki koi fixed connection nahi hai — reply karne ke liye zaruri hai. |
koi accept/connect nahi |
Connectionless: address har call mein hota hai, kisi setup handshake mein nahi. |
Ek send = ek recv |
Datagrams message boundaries preserve karte hain (TCP ke byte stream ke unlike). |
Common mistakes (Steel-man + fix)
Recall Feynman: ek 12-saal ke bacche ko explain karo
Do computers baat karna chahte hain. Ek socket waise hai jaise ek walkie-talkie jo tum apne program mein banate ho. TCP waise hai jaise kisi dost ko call karna: tum dial karte ho, woh pick up karta hai, aur ab jo bhi tum kaho woh order mein aata hai aur kuch lost nahi hota — lekin call set up karne mein thoda waqt lagta hai. UDP waise hai jaise ek shor waale playground mein koi message chilla ke bolna: super fast, koi setup nahi, lekin kuch words kho sakte hain ya ulti-seedhi order mein aa sakte hain. Server woh baccha hai jo ek fixed jagah (ek known port par) wait karta hai taaki doosre jaante hain use kahan dhundhna hai; client woh hai jo chalta aata hai aur baat shuru karta hai.
Flashcards
TCP ke liye konsa socket type constant use hota hai?
SOCK_STREAMUDP ke liye konsa socket type constant use hota hai?
SOCK_DGRAMAF_INET kya specify karta hai?
TCP server calls ka order?
TCP client calls ka order?
accept() ek naya socket kyun return karta hai?
UDP mein send/recv ki jagah kaun se calls use hote hain?
sendto(data, addr) aur recvfrom(bufsize) → (data, addr).UDP mein listen/accept/connect kyun nahi hota?
listen(n) ka argument kya matlab rakhta hai?
accept se pehle queue mein wait kar sakti hain.TCP mein recv ka b'' return karna kya signal karta hai?
TCP vs UDP mein 3 sends ka kya fark hai?
send vs sendall mein kya fark hai?
send sirf data ka part transmit kar sakta hai; sendall loop karta hai jab tak sab kuch send nahi ho jaata.SO_REUSEADDR kyun use karte hain?
Socket data kis type ka hona chahiye?
.encode()/.decode() use karo).Kaun si side usually bind skip karti hai?
Connections
- TCP three-way handshake —
connect/acceptke under the hood kya trigger hota hai. - UDP vs TCP tradeoffs — reliability vs latency.
- Ports and IP addressing — kaise (IP, port) ek endpoint identify karta hai.
- TIME_WAIT and SO_REUSEADDR — close ke baad ports kyun linge karte hain.
- Message framing / length-prefix protocol — TCP stream boundaries fix karna.
- select / asyncio for concurrent servers — ek saath kai clients handle karna.
- DNS — ek real-world UDP protocol.