Sockets in Python: TCP Client

By the end of this lesson you can:

• Create a TCP socket and connect to a host:port.
• Send and receive bytes, encoding/decoding text correctly.
• Handle partial reads — TCP is a stream, not messages.
• Use timeouts and context managers so connections never hang or leak.

When you called requests.get("https://...") in Level 7, underneath it: a socket connected to the server's IP on port 443, TLS-encrypted the channel, sent the literal HTTP bytes, and read the reply byte by byte. requests hid all of that. Today we lift the lid.

Create → connect → send → recv → close

import socket

# 1. create: AF_INET = IPv4, SOCK_STREAM = TCP
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(5)                       # never hang forever

# 2. connect to host:port
s.connect(("127.0.0.1", 9000))

# 3. send bytes (encode text first!)
s.sendall(b"hello\n")                 # sendall ensures it all goes

# 4. receive bytes (decode after)
data = s.recv(1024)                   # read up to 1024 bytes
print("got:", data.decode())

# 5. close
s.close()

Use a context manager so it always closes, even on error:

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.settimeout(5)
    s.connect(("127.0.0.1", 9000))
    s.sendall(b"hello\n")
    print(s.recv(1024).decode())
# socket auto-closed here

Bytes, not strings

text = "héllo"
raw = text.encode("utf-8")     # str → bytes  (b'h\xc3\xa9llo')
back = raw.decode("utf-8")     # bytes → str
s.sendall(text.encode())       # always encode before sending

The network only moves bytes. Forgetting to .encode() raises TypeError; using the wrong codec mangles non-ASCII. Default to UTF-8 everywhere.

TCP is a stream — loop your reads

def recv_all(sock) -> bytes:
    """Read until the peer closes the connection."""
    chunks = []
    while True:
        chunk = sock.recv(4096)
        if not chunk:              # b"" means the peer closed
            break
        chunks.append(chunk)
    return b"".join(chunks)

def recv_line(sock) -> str:
    """Read until a newline delimiter."""
    buf = b""
    while not buf.endswith(b"\n"):
        chunk = sock.recv(1)
        if not chunk:
            break
        buf += chunk
    return buf.decode().rstrip("\n")

Timeouts & errors

try:
    with socket.create_connection(("127.0.0.1", 9000), timeout=5) as s:
        s.sendall(b"ping\n")
        print(s.recv(1024).decode())
except socket.timeout:
    print("connection timed out")
except ConnectionRefusedError:
    print("nothing is listening there")

socket.create_connection is a tidy shortcut that creates + connects in one call. Always set a timeout and handle ConnectionRefusedError (no server) and socket.timeout (no answer) — security tools especially must never hang.

Goal: connect to a service and read the "banner" it sends on connect (many services announce their software/version). We'll also speak raw HTTP to a local server — proving requests is just bytes over a socket. Localhost only.

import socket

def grab_banner(host: str, port: int, timeout: float = 3.0) -> str:
    """Read whatever a service sends on connect. LOCALHOST/own hosts only."""
    try:
        with socket.create_connection((host, port), timeout=timeout) as s:
            s.settimeout(timeout)
            return s.recv(1024).decode(errors="replace").strip()
    except (socket.timeout, ConnectionRefusedError, OSError) as e:
        return f"(no banner: {e})"

def http_get_raw(host: str, port: int, path: str = "/") -> str:
    """Speak HTTP by hand — what requests.get does under the hood."""
    request = (f"GET {path} HTTP/1.1\r\n"
               f"Host: {host}\r\n"
               f"User-Agent: socket-demo/1.0\r\n"
               f"Connection: close\r\n\r\n")        # blank line ends headers
    with socket.create_connection((host, port), timeout=5) as s:
        s.sendall(request.encode())
        # read until the server closes (Connection: close)
        chunks = []
        while True:
            chunk = s.recv(4096)
            if not chunk:
                break
            chunks.append(chunk)
    return b"".join(chunks).decode(errors="replace")

# against your own running dev server:
raw = http_get_raw("127.0.0.1", 3000, "/")
print(raw.split("\r\n\r\n")[0])     # just the status line + headers

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
...
# You just performed an HTTP request with nothing but a socket and bytes.

Read the code

The http_get_raw function demystifies the whole web stack: an HTTP request is just text bytes (method, path, headers, a blank line) sent over a TCP socket, and the response is bytes you read until the server closes. requests wraps exactly this, plus TLS, redirects, and parsing. grab_banner shows the security angle — services often reveal their version on connect, which is recon (and a reason to suppress banners defensively). We stay on 127.0.0.1 per the ethics rules.

A TCP client follows one lifecycle: create → connect → send → recv → close (use a context manager or create_connection so it always closes). Everything is bytes — encode before sending, decode after — and TCP is a stream, so one recv may be partial: loop until close, until a delimiter, or until a known length (length-prefixing is the clean solution). Always set a timeout and handle ConnectionRefusedError/socket.timeout. Speaking raw HTTP over a socket shows that requests is just this plus TLS and parsing. Next: the server side.