Sockets API ও kernel stack — syscall থেকে wire

লক্ষ্য: আজকের সব তত্ত্ব — state mapping, sockaddr_in, byte order, EOF semantics, SIGPIPE — একটা ~৯০ লাইনের সৎ, production- ধাঁচের echo প্রোগ্রামে একসাথে।

// echo.c — gcc -Wall -O2 -o echo echo.c
// চালান: ./echo server   (এক terminal)
//        ./echo client   (অন্য terminal) — টাইপ করুন, echo ফেরত পাবেন

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>

#define PORT     9090
#define BACKLOG  16
#define BUF_SIZE 1024

/* send()-এর guarantee: পুরো buf না পাঠানো পর্যন্ত লুপ —
   stream-এ partial send normal ব্যাপার, error না */
static int send_all(int fd, const char *buf, size_t len) {
    size_t done = 0;
    while (done < len) {
        ssize_t n = send(fd, buf + done, len - done, 0);
        if (n < 0) {
            if (errno == EINTR) continue;   /* signal — আবার চেষ্টা */
            return -1;                      /* সত্যিকারের ব্যর্থতা */
        }
        done += (size_t)n;
    }
    return 0;
}

static int run_client(void) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in sa = {0};            /* আগে শূন্য — নিয়ম */
    sa.sin_family = AF_INET;
    sa.sin_port   = htons(PORT);            /* ভুললে ভুল port! */
    inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr);

    if (connect(fd, (struct sockaddr *)&sa, sizeof sa) < 0) {
        perror("connect");
        return 1;
    }

    char line[BUF_SIZE], rbuf[BUF_SIZE];
    while (fgets(line, sizeof line, stdin)) {
        size_t need = strlen(line);
        if (send_all(fd, line, need) < 0) break;

        /* ঠিক যত byte পাঠালাম ততটাই ফেরত — recv জোটানো stream,
           তাই কতবার কল হবে কেউ বলে দেয় না: লুপই একমাত্র পথ */
        size_t got = 0;
        while (got < need) {
            ssize_t n = recv(fd, rbuf + got, sizeof rbuf - got, 0);
            if (n == 0) { fprintf(stderr, "peer closed\n"); return 1; }
            if (n < 0)  { perror("recv"); return 1; }
            got += (size_t)n;
        }
        fwrite(rbuf, 1, got, stdout);
        fflush(stdout);
    }
    close(fd);                              /* FIN পাঠায় — graceful */
    return 0;
}

static void run_server(void) {
    signal(SIGPIPE, SIG_IGN);  /* মৃত peer-এ write = signal, crash নয় */

    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    int yes = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);

    struct sockaddr_in sa = {0};
    sa.sin_family      = AF_INET;
    sa.sin_port        = htons(PORT);
    sa.sin_addr.s_addr = htonl(INADDR_ANY); /* সব interface-এ শোনা */

    if (bind(lfd, (struct sockaddr *)&sa, sizeof sa) < 0) {
        perror("bind");                     /* Address already in use? */
        exit(1);
    }
    if (listen(lfd, BACKLOG) < 0) { perror("listen"); exit(1); }
    printf("listening on %d\n", PORT);

    for (;;) {
        int cfd = accept(lfd, NULL, NULL);  /* নতুন fd প্রতি connection-এ */
        if (cfd < 0) continue;

        char buf[BUF_SIZE];
        ssize_t n;
        while ((n = recv(cfd, buf, sizeof buf, 0)) > 0) {
            if (send_all(cfd, buf, (size_t)n) < 0) break;
        }
        close(cfd);                         /* recv==0 (EOF) হলেই এখানে */
    }
}

int main(int argc, char **argv) {
    if (argc > 1 && strcmp(argv[1], "client") == 0) return run_client();
    run_server();
    return 0;
}

একই প্রোগ্রাম Python-এ — API-র আকৃতি হুবহু এক, শুধু boilerplate আর manual loops-এর ভার লাইব্রেরি নিয়ে নিল:

# echo.py — python3 echo.py server / python3 echo.py client
import socket, sys

def server():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind(("127.0.0.1", 9090))
    s.listen(16)
    while True:
        conn, _ = s.accept()
        with conn:                          # with = try/finally close
            for chunk in iter(lambda: conn.recv(1024), b""):
                conn.sendall(chunk)         # partial-send লুপ ভেতরেই

def client():
    with socket.create_connection(("127.0.0.1", 9090)) as s:
        for line in sys.stdin:
            s.sendall(line.encode())
            reply, need = b"", line.encode()
            while len(reply) < len(need):   # recv-জোটানো — একই নিয়ম
                part = s.recv(1024)
                if not part: return         # EOF
                reply += part
            print(reply.decode(), end="", flush=True)

if len(sys.argv) > 1 and sys.argv[1] == "client":
    client()
else:
    server()

strace diff — দুই সংস্করণ পাশাপাশি:

strace -c -o c.trace   ./echo client < input.txt
strace -c -o py.trace  python3 echo.py client < input.txt
diff <(grep -E 'socket|connect|recv|send' c.trace) \
     <(grep -E 'socket|connect|recv|send' py.trace) | head -20

Python trace-এর শুরুতে শত শত অতিরিক্ত syscall — interpreter boot, shared library আর module openat/mmap/read। কিন্তু network-সংক্রান্ত অংশে খুঁজে দেখুন: socket, connect, recvfrom, sendto — হুবহু এক, একই ক্রমে। Python আসলে ভেতরে C sockets API-ই ডাকে; abstraction লেয়ারটা আপনার সময় বাঁচায়, wire-এর খরচ বাড়ায় না। Steady-state-এ প্রতি message দুজনেরই খরচ একই ২টা syscall — hood অংশের হিসাব মিলে গেল।

নিজে বাড়ান:

1. SO_REUSEADDR লাইনটা বাদ দিয়ে build করে experiment ধাপ ৩-এর fail-টা এই binary দিয়েই reproduce করুন
2. Server-কে concurrent বানান — প্রতি accept-এ fork() বা pthread, তারপর দুই simultaneous client পরীক্ষা করুন
3. shutdown(cfd, SHUT_WR) যোগ করে half-close আচরণ দেখুন — client পাঠানো বন্ধ করেও কেন উত্তর পেতে পারে, strace-এ প্রমাণ করুন