TCP socket প্রোগ্রামিং — client আর server C-তে

১ · Socket API — নেটওয়ার্কও একটি “ফাইল”

পর্ব ২৭-এ দেখেছেন, socket হলো প্রোগ্রাম আর OS-এর transport স্তরের মাঝের দরজা। পর্ব ২৯-এ দেখেছেন, TCP-র handshake, sequence number, retransmission — সবই চালায় kernel. তাহলে প্রোগ্রামারের হাতে কী থাকে? থাকে কয়েকটি system call — kernel-এর কাছে কয়েকটি অনুরোধ: একটি socket চাওয়া, সেটিকে একটি ঠিকানায় বসানো, শোনা শুরু করা, অন্য ঠিকানায় সংযোগ চাওয়া, আর বাইট পাঠানো ও নেওয়া। এই ডাকগুলোর সমষ্টিই socket API. এই পর্বে আমরা সেই API-কে ধাপে ধাপে, সাবধানী C কোডে, ব্যবহার করব।

একটু ইতিহাস — Berkeley থেকে POSIX

আজকের socket API-র জন্ম ক্যালিফোর্নিয়া বিশ্ববিদ্যালয়, Berkeley-র Unix সংস্করণ BSD-তে। DARPA-র অর্থায়নে সেখানে TCP/IP Unix-এর ভেতরে বসানো হয়, আর ১৯৮৩ সালে প্রকাশিত 4.2BSD-তে socket API প্রথম ব্যাপকভাবে সবার হাতে আসে বলে ধরা হয়। নকশার মূল চিন্তা ছিল Unix-এর পুরোনো দর্শন — “সবকিছুই ফাইল”: socket-ও একটি file descriptor, তাই ফাইলের মতোই read(), write(), close() চলে। পরে এই API প্রায় হুবহু Linux, macOS, অন্যান্য Unix আর (কিছু পরিবর্তনসহ) Windows-এর Winsock-এ গেছে। POSIX মানদণ্ড এটিকে আনুষ্ঠানিক রূপ দিয়েছে, আর IPv6-এর জন্য নতুন অংশগুলো (getaddrinfo, sockaddr_in6) এসেছে IETF-এর RFC 3493-জাতীয় নথি থেকে।

এই পর্বের সব কোড POSIX/Linux-এর জন্য; ধারণাগুলো সব OS-এ একই, শুধু ওপরের পার্থক্যগুলো মনে রাখবেন। Socket-এর OS-দিক — file descriptor table, system call কীভাবে kernel-এ ঢোকে — জানতে চাইলে অপারেটিং সিস্টেম কোর্সের System call আর file descriptor পর্ব দুটি দেখে নিতে পারেন। C-র দিক থেকে pointer আর struct-এ হাত পাকা না থাকলে C কোর্সের পয়েন্টার আর struct পর্ব কাজে দেবে।

২ · Server আর client-এর call-এর ক্রম — তারে কী ঘটে

প্রথমে পুরো ছবিটা একটি সারণিতে দেখে নিই। বাম দিকে প্রোগ্রামের ডাক, ডান দিকে সেই মুহূর্তে TCP তারে কী পাঠায়। লক্ষ করুন, অনেক ডাক তারে কিছুই পাঠায় না — সেগুলো শুধু kernel-এর ভেতরের হিসাব বদলায়।

এবার একই কাজ সময়ের ক্রমে, পাশাপাশি। Server 127.0.0.1:47301-এ শুনছে, client “salam” লিখে উত্তর পড়ে বন্ধ করছে। “পরে” চাপুন:

এই ছবির দুটি জিনিস মনে রাখবেন। এক, accept() handshake করে না — handshake kernel আগেই সেরে রাখে, accept() শুধু তৈরি সংযোগ তুলে নেয়। দুই, একটি listening socket থেকে অসংখ্য connected socket জন্মায়, প্রতিটি আলাদা চার-মানের জোড়া (উৎস IP, উৎস port, গন্তব্য IP, গন্তব্য port) দিয়ে চেনা — পর্ব ২৭-এর demultiplexing ঠিক এভাবেই কাজ করে। Client চাইলে connect()-এর আগে নিজেও bind() করতে পারে, কিন্তু সাধারণত দরকার হয় না; kernel নিজেই একটি ephemeral port দেয়।

৩ · ঠিকানার struct, byte order আর cast

Socket API প্রথম থেকেই অনেক ধরনের নেটওয়ার্কের জন্য নকশা করা — IPv4, পরে IPv6, একই যন্ত্রের Unix domain socket ইত্যাদি। প্রতিটির ঠিকানার আকার আলাদা। তাই bind(), connect(), accept() একটি সাধারণ ধরন নেয়: struct sockaddr * আর তার দৈর্ঘ্য। আসল ঠিকানা থাকে নির্দিষ্ট struct-এ, যার প্রথম ঘর সবসময় “পরিবার” (family) — kernel সেটা দেখে বোঝে বাকিটা কীভাবে পড়তে হবে।

struct sockaddr {            /* "সাধারণ" ধরন — ১৬ বাইট, শুধু pointer-এর জন্য */
    sa_family_t sa_family;   /* AF_INET, AF_INET6, AF_UNIX ... */
    char        sa_data[14];
};
struct sockaddr_in {         /* IPv4 — ১৬ বাইট */
    sa_family_t    sin_family;   /* AF_INET */
    in_port_t      sin_port;     /* port, network byte order */
    struct in_addr sin_addr;     /* ৪ বাইটের IPv4 ঠিকানা, network byte order */
    /* + padding */
};
struct sockaddr_in6 {        /* IPv6 — ২৮ বাইট */
    sa_family_t     sin6_family;   /* AF_INET6 */
    in_port_t       sin6_port;
    uint32_t        sin6_flowinfo;
    struct in6_addr sin6_addr;     /* ১৬ বাইট */
    uint32_t        sin6_scope_id; /* fe80:: ঠিকানার interface */
};
struct sockaddr_storage;     /* যেকোনো পরিবারের ঠিকানা ধরার মতো বড় (Linux-এ ১২৮ বাইট) */

(মাপগুলো Linux x86-64-এর; অন্য OS-এ ঘরের নাম ও ক্রম সামান্য আলাদা হতে পারে, যেমন BSD-তে শুরুতে একটি দৈর্ঘ্যের বাইট থাকে।) struct sockaddr আসলে একটি “সাধারণ খাম”: C-তে তখনো void * প্রচলিত ছিল না বলে API-কে একটি সাধারণ pointer-ধরন দিতে হয়েছিল। তাই প্রতিবার নির্দিষ্ট struct-এর ঠিকানা cast করতে হয় — (struct sockaddr *)&addr — আর পাশে সঠিক দৈর্ঘ্য sizeof addr দিতে হয়। ভুল দৈর্ঘ্য দিলে kernel হয় EINVAL দেবে, নয়তো আধখানা ঠিকানা পড়বে। accept() বা recvfrom()-এ কার কাছ থেকে এল তা জানতে চাইলে কোন পরিবার আসবে আগে জানা থাকে না; তখন sockaddr_storage নিন, কারণ এটি সব পরিবারের ঠিকানা ধরার মতো বড় আর ঠিকভাবে সারিবদ্ধ।

Byte order — htons কেন

পর্ব ১৬-এ দেখেছেন, IP আর TCP header-এ বহু-বাইটের সংখ্যা থাকে big-endian ক্রমে — বড় বাইট আগে; একে বলে network byte order. কিন্তু x86 আর বেশিরভাগ ARM যন্ত্র মেমরিতে সংখ্যা রাখে little-endian ক্রমে। sin_port আর sin_addr-এ kernel হুবহু নেটওয়ার্কের ক্রম আশা করে, তাই লেখার আগে রূপান্তর লাগে:

Big-endian যন্ত্রে এই ফাংশনগুলো কিছুই করে না, তবু সবসময় ডাকতে হয় — তাহলে কোড সব যন্ত্রে চলে। সবচেয়ে চেনা বাগ: addr.sin_port = 8080; লিখে htons ভুলে যাওয়া। 8080 = 0x1F90, little-endian মেমরিতে বাইট দুটি 90 1F; kernel এটাকে নেটওয়ার্ক ক্রমে পড়ে 0x901F = 36895. প্রোগ্রাম কোনো error ছাড়াই port 36895-এ শুনতে থাকে, আর client 8080-এ গিয়ে Connection refused পায়। একই কারণে length-prefix framing-এর দৈর্ঘ্যও (অংশ ৬) পাঠানোর আগে htonl আর পড়ার পরে ntohl.

লেখা ঠিকানা থেকে বাইনারি — inet_pton আর inet_ntop

“192.168.1.10” বা “::1” — মানুষের পড়ার মতো লেখা ঠিকানাকে struct-এর বাইনারি রূপে নিতে inet_pton() (presentation to network), আর উল্টো দিকে inet_ntop(). দুটোই IPv4 আর IPv6 দুটোতেই চলে:

struct sockaddr_in a = {0};
a.sin_family = AF_INET;
a.sin_port   = htons(47301);
if (inet_pton(AF_INET, "127.0.0.1", &a.sin_addr) != 1) {   /* 1 = ঠিক, 0 = ভুল লেখা, -1 = ভুল family */
    fprintf(stderr, "bad address\n");  exit(1);
}
char text[INET_ADDRSTRLEN];                                  /* IPv4-এর জন্য ১৬, IPv6-এ INET6_ADDRSTRLEN = ৪৬ */
inet_ntop(AF_INET, &a.sin_addr, text, sizeof text);         /* "127.0.0.1" */

পুরোনো কোডে প্রায়ই inet_addr(), inet_aton() বা inet_ntoa() দেখবেন। এগুলো শুধু IPv4 বোঝে, আর inet_addr() ভুল লেখা আর বৈধ ঠিকানা “255.255.255.255”-কে একই মান (−১) দিয়ে ফেরায় — তাই নতুন কোডে inet_pton/inet_ntop. আর নাম থেকে ঠিকানা (DNS) খোঁজার কাজ এদের নয়, সেটা পরের অংশের getaddrinfo()-এর।

৪ · getaddrinfo — IPv4 আর IPv6, দুটোর জন্য এক কোড

হাতে sockaddr_in বানানো কোড শুধু IPv4-এ চলে। কাল যদি সার্ভার শুধু IPv6-এ থাকে (পর্ব ২১), সব কোড আবার লিখতে হবে। এর সমাধান getaddrinfo(): একটি host নাম (বা লেখা ঠিকানা) আর একটি service (port নম্বর বা নাম, যেমন “https”) দিলে এটি তৈরি-করা sockaddr-সহ struct addrinfo-এর একটি linked list ফেরত দেয় — প্রতিটি সারিতে family, socktype, protocol আর ঠিকানা, ঠিক যা socket(), bind() আর connect()-এ লাগে। আপনার কোড family জানেই না; তালিকা ধরে একে একে চেষ্টা করে। নামটি কোথায় খোঁজা হবে — /etc/hosts, DNS (পর্ব ৩৫) বা অন্য কোথাও — তা ঠিক করে OS-এর resolver সেটিং।

ফলাফল ব্যবহার শেষে freeaddrinfo() দিয়ে মেমরি ফেরত দিতে হয়। আর ভুল হলে এটি errno-তে নয়, নিজের একটি কোড ফেরায় (যেমন EAI_NONAME), যার লেখা রূপ দেয় gai_strerror(). AI_PASSIVE-এর সাথে NULL host দিলে server সব interface-এ শোনে — সেটা কখন বিপজ্জনক, অংশ ৮-এ দেখব। “localhost”-এর জন্য তালিকা কেমন হয় আর client কীভাবে চেষ্টা করে, দেখুন:

এবার এই ধাঁচটিই চালিয়ে দেখা যাক। একটি প্রোগ্রামে fork() দিয়ে দুটি process: parent হলো server, child হলো client. দুটোই একই open_tcp() ফাংশন ব্যবহার করে — server "127.0.0.1" দিয়ে bind+listen করে (hints-এ AI_PASSIVE থাকলেও host দেওয়ায় সেটি নিষ্ক্রিয়; ইচ্ছা করেই সব interface-এ খুলিনি), client "localhost" resolve করে তালিকা ধরে connect করে। Client তিনটি লাইন পাঠায়, server প্রতিটি ফেরত দেয় (echo). লাইন পড়ার কাজটি fdopen() আর fgets()-এর হাতে দিয়েছি — stdio-র buffer নিজেই অংশে অংশে আসা বাইট জুড়ে একটি পূর্ণ লাইন বানায়, যা অংশ ৫-এর সমস্যার একটি সমাধান।

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/wait.h>
static int open_tcp(const char *host, const char *port, int server) {   /* try every result */
    struct addrinfo *res, *p, hints = { .ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM };
    hints.ai_flags = server ? AI_PASSIVE : 0;  int e, fd = -1, one = 1;   /* IPv4 or IPv6, TCP */
    if ((e = getaddrinfo(host, port, &hints, &res)) != 0) { puts(gai_strerror(e)); return -1; }
    for (p = res; p != NULL && fd < 0; p = p->ai_next) {
        char ip[64]; getnameinfo(p->ai_addr, p->ai_addrlen, ip, sizeof ip, NULL, 0, NI_NUMERICHOST);
        if ((fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) continue;
        if (server) setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
        int ok = server ? bind(fd, p->ai_addr, p->ai_addrlen) == 0 && listen(fd, 8) == 0
                        : connect(fd, p->ai_addr, p->ai_addrlen) == 0;
        printf("%s: try %-9s -> %s\n", server ? "server" : "client", ip, ok ? "OK" : strerror(errno));
        if (!ok) { close(fd); fd = -1; }                /* failed: try the next address */
    }
    freeaddrinfo(res); return fd;
}
int main(void) {
    setvbuf(stdout, NULL, _IONBF, 0);  int ls = open_tcp("127.0.0.1", "47301", 1), n = 0;
    char line[64]; const char *msg[] = { "salam\n", "kemon achen?\n", "bye\n" };
    if (ls >= 0 && fork() == 0) {                       /* child process = client */
        FILE *in = fdopen(open_tcp("localhost", "47301", 0), "r");   /* NULL if it failed */
        for (int i = 0; in && i < 3 && write(fileno(in), msg[i], strlen(msg[i])) > 0
                        && fgets(line, sizeof line, in); i++)
            printf("client: sent %zu bytes, echo back: %s", strlen(msg[i]), line);
        _exit(0);
    }
    FILE *in = fdopen(accept(ls, NULL, NULL), "r");     /* serve ONE client, then stop */
    while (in && fgets(line, sizeof line, in) && write(fileno(in), line, strlen(line)) > 0) n++;
    wait(NULL); printf("server: echoed %d lines, then read() returned 0 (EOF) -> close\n", n);
}

server: try 127.0.0.1 -> OK
client: try ::1       -> Connection refused
client: try 127.0.0.1 -> OK
client: sent 6 bytes, echo back: salam
client: sent 13 bytes, echo back: kemon achen?
client: sent 4 bytes, echo back: bye
server: echoed 3 lines, then read() returned 0 (EOF) -> close

৫ · Partial read আর write — চিরচেনা বাগ

পর্ব ২৯-এ পড়েছেন, TCP একটি byte stream — বার্তার কোনো সীমানা রাখে না। প্রোগ্রামারের ভাষায় এর মানে খুব কঠিন একটি সত্য: read(fd, buf, 10000) মানে “সর্বোচ্চ ১০,০০০ বাইট দাও”, “ঠিক ১০,০০০ বাইট দাও” নয়। Receive buffer-এ যা আছে — ১ বাইট থেকে চাওয়া পরিমাণ পর্যন্ত যেকোনো সংখ্যা — read() তাই দিয়েই ফেরে। কিছুই না থাকলে অপেক্ষা করে, আর অন্য পক্ষ বন্ধ করে দিলে ফেরত দেয় ০ — এটাই EOF.

এই বাগ ধরা কঠিন, কারণ loopback-এ বা একই LAN-এ ছোট বার্তা প্রায় সবসময় একবারেই চলে আসে। কোড পরীক্ষায় পাস করে, তারপর দূরের সার্ভারে, ধীর মোবাইল নেটওয়ার্কে বা বড় বার্তায় হঠাৎ আধখানা ডেটা নিয়ে ভাঙে। তাই নিচের পরীক্ষায় ইচ্ছা করে receive buffer ছোট (SO_RCVBUF = ২০৪৮) করা হয়েছে, যাতে loopback-এও সমস্যাটা চোখে পড়ে। প্রেরক একটিমাত্র write()-এ ১০,০০০ বাইট পাঠায়; প্রাপক প্রথমে “ভুল” কোডের মতো একবার পড়ে, তারপর একটি সঠিক readn() loop দিয়ে বাকিটা জোড়ে। আগে ধাপগুলো দেখে নিন:

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define N 10000
static ssize_t readn(int fd, char *buf, size_t n) {    /* keep reading until n bytes or EOF */
    size_t got = 0;
    while (got < n) {
        ssize_t r = read(fd, buf + got, n - got);
        if (r < 0 && errno == EINTR) continue;          /* interrupted by a signal: retry */
        if (r <= 0) break;                               /* error, or EOF (peer closed) */
        printf("  readn: read() returned %4zd, so far %4zu\n", r, got += (size_t)r);
    }
    return (ssize_t)got;
}
int main(void) {
    struct sockaddr_in a = { .sin_family = AF_INET, .sin_port = htons(47302) };
    a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    int ls = socket(AF_INET, SOCK_STREAM, 0), small = 2048, one = 1;  static char msg[N], buf[N];
    setsockopt(ls, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
    setsockopt(ls, SOL_SOCKET, SO_RCVBUF, &small, sizeof small);  /* copied to accepted socket */
    if (bind(ls, (struct sockaddr *)&a, sizeof a) < 0 || listen(ls, 1) < 0) return 1;
    if (fork() == 0) {                                   /* child = sender */
        int c = socket(AF_INET, SOCK_STREAM, 0);
        if (connect(c, (struct sockaddr *)&a, sizeof a) < 0) _exit(1);
        _exit(write(c, msg, N) == N ? 0 : 2);            /* ONE write() of 10,000 bytes */
    }
    int s = accept(ls, NULL, NULL), st;  usleep(100000); /* let some data arrive first */
    ssize_t n = read(s, buf, N);                         /* naive: "one read = one message" */
    printf("naive: read(fd, buf, 10000) returned %zd\n", n);
    ssize_t rest = n < 0 ? 0 : readn(s, buf + n, N - (size_t)n);
    wait(&st); printf("total %zd of %d bytes, sender exit code %d\n", n + rest, N, WEXITSTATUS(st));
}

naive: read(fd, buf, 10000) returned 2048
  readn: read() returned 2048, so far 2048
  readn: read() returned 2048, so far 4096
  readn: read() returned 2048, so far 6144
  readn: read() returned 1808, so far 7952
total 10000 of 10000 bytes, sender exit code 0

লেখার দিক — writen

write()-ও চাওয়ার চেয়ে কম বাইট লিখে ফিরতে পারে: non-blocking socket-এ send buffer ভরে গেলে, signal এসে অপেক্ষা ভাঙলে, বা timeout হলে। ওপরের পরীক্ষায় blocking socket-এ পুরোটা লেখা হয়েছে ঠিকই, কিন্তু সাবধানী কোড সেটা ধরে নেয় না। সঠিক ধাঁচ readn-এর জমজ:

ssize_t writen(int fd, const void *p, size_t n) {   /* সব n বাইট লিখবে, নয়তো -1 */
    const char *b = p;  size_t left = n;
    while (left > 0) {
        ssize_t w = write(fd, b, left);
        if (w < 0) { if (errno == EINTR) continue; return -1; }
        b += w;  left -= (size_t)w;
    }
    return (ssize_t)n;
}

Python-এর sendall() বা Go-র Write ভেতরে ঠিক এই loop চালায়; C-তে আপনাকে নিজে লিখতে হয়। EINTR নিয়ে একটি কথা: Linux-এ signal handler SA_RESTART দিয়ে বসালে অনেক system call নিজেই আবার শুরু হয়, তবু সব call নয় আর সব OS-এ নয় — তাই loop-এ EINTR সামলানো সস্তা বীমা (বিস্তারিত C কোর্সের signal আর low-level I/O পর্বে)।

৬ · বার্তার সীমানা — delimiter আর length prefix

readn জানে কত বাইট পড়তে হবে। কিন্তু সেটা জানবে কীভাবে? Byte stream-এর ওপর বার্তা চিনতে application-কে নিজের একটি নিয়ম বানাতে হয় — একে বলে message framing, পর্ব ৩৪-এ protocol নকশার অংশ হিসেবে দেখেছেন। প্রচলিত দুটি উপায়:

এবার length-prefix framing চালিয়ে দেখি। প্রেরক তিনটি বার্তা পাঠায়, কিন্তু বাইটগুলো লেখে দুই কিস্তিতে: প্রথম কিস্তি শেষ হয় দ্বিতীয় বার্তার ৪-বাইট header-এর ঠিক মাঝখানে, তারপর ১০০ মিলিসেকেন্ড বিরতি। শেষে একটি “মিথ্যা” header — দাবি করে ১০ লাখ বাইট আসছে। প্রাপকের নিয়ম: header-এর দৈর্ঘ্য MAXMSG (৬৪)-এর বেশি হলে বিশ্বাস না করে প্রত্যাখ্যান। এখানে socketpair() ব্যবহার করেছি — একই যন্ত্রের দুটি জোড়া socket, framing-এর নিয়ম TCP-তেও হুবহু একই।

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define MAXMSG 64                         /* never trust a length that came from the network */
static int readn(int fd, void *p, size_t n) {          /* 1 = got all n bytes, 0 = EOF/error */
    for (ssize_t r; n > 0; n -= (size_t)r, p = (char *)p + r) {
        if ((r = read(fd, p, n)) <= 0) return 0;
        if ((size_t)r < n) printf("  (short read: got %zd of %zu bytes)\n", r, n);
    }
    return 1;
}
static size_t put(char *out, const char *s, uint32_t len) {   /* [4-byte length][text] */
    uint32_t h = htonl(len);  memcpy(out, &h, 4);  memcpy(out + 4, s, strlen(s));  /* big-endian */
    return 4 + strlen(s);
}
int main(void) {
    int sv[2]; char buf[MAXMSG + 1], out[128]; uint32_t h;
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) < 0) { perror("socketpair"); return 1; }
    size_t a = put(out, "salam", 5), b = a + put(out + a, "kemon achen?", 12);
    b += put(out + b, "bye", 3);  b += put(out + b, "", 1000000);    /* a lying header */
    if (fork() == 0) {                                 /* child = sender */
        if (write(sv[1], out, a + 2) < 0) _exit(1);    /* frame 1 + first 2 bytes of header 2 */
        usleep(100000);  _exit(write(sv[1], out + a + 2, b - a - 2) < 0);   /* pause, the rest */
    }
    close(sv[1]);
    while (readn(sv[0], &h, 4)) {
        if ((h = ntohl(h)) > MAXMSG) { printf("frame says %u bytes > %d: reject\n", h, MAXMSG); break; }
        if (!readn(sv[0], buf, h)) break;
        buf[h] = '\0'; printf("frame %2u bytes: \"%s\"\n", h, buf);          /* we add the '\0' */
    }
    close(sv[0]); wait(NULL);
}

frame  5 bytes: "salam"
  (short read: got 2 of 4 bytes)
frame 12 bytes: "kemon achen?"
frame  3 bytes: "bye"
frame says 1000000 bytes > 64: reject

৭ · ভুল সামলানো — errno, SIGPIPE, close আর timeout

Socket-এর প্রায় প্রতিটি call ব্যর্থ হতে পারে, আর ব্যর্থ হলে সাধারণত −১ ফেরায়, কারণের সংখ্যাটি বসায় thread-নিজস্ব চলক errno-তে। perror("connect") সেটিকে লেখায় রূপ দিয়ে stderr-এ ছাপে, strerror(errno) লেখাটি ফেরত দেয়। একটি নিয়ম মনে রাখুন: errno দেখতে হবে ব্যর্থতার ঠিক পরেই — মাঝে অন্য কোনো library call (এমনকি printf) errno বদলে দিতে পারে। আর সফল call errno-কে শূন্য করে না, তাই আগে ফেরত মান দেখে তবেই errno. C-তে ভুল সামলানোর সাধারণ কৌশল জানতে C কোর্সের এরর হ্যান্ডলিং পর্ব দেখুন।

SIGPIPE — বন্ধ সংযোগে লিখলে প্রোগ্রাম মরে যেতে পারে

অন্য পক্ষ সংযোগ বন্ধ করে চলে গেছে, আর আপনি তখনো লিখছেন। প্রথম লেখা প্রায়ই “সফল” হয় — বাইটগুলো শুধু নিজের kernel-এর buffer-এ গেছে। অন্য পক্ষের kernel সেই ডেটা পেয়ে দেখে socket নেই, উত্তরে RST দেয়। এরপরের লেখায় Unix ঐতিহ্য অনুযায়ী kernel process-কে SIGPIPE signal পাঠায়, যার ডিফল্ট কাজ — process শেষ করে দেওয়া, কোনো error বার্তা ছাড়াই। Shell-এর pipe-এ (yes | head) এই আচরণ সুবিধাজনক, কিন্তু server-এ একজন client হঠাৎ চলে গেলে পুরো server নিঃশব্দে মরে যাওয়া ভয়ংকর। প্রতিকার:

• প্রতিটি send()-এ MSG_NOSIGNAL: signal নয়, শুধু EPIPE ফেরত। Linux-এ আছে আর POSIX-এর নতুন সংস্করণে মানদণ্ডভুক্ত; macOS-এ ঐতিহ্যগতভাবে এর বদলে socket option SO_NOSIGPIPE.
• পুরো process-এ উপেক্ষা: শুরুতেই signal(SIGPIPE, SIG_IGN); — তারপর সব লেখা শুধু EPIPE দেবে। অনেক server এটাই করে।

Signal-এর OS-দিক অপারেটিং সিস্টেম কোর্সের Signal পর্বে আছে।

চারটি ভুল, নিজের চোখে

নিচের প্রোগ্রাম loopback-এ ইচ্ছা করে চারটি ভুল ঘটায় আর প্রতিটির errno-র নাম ছাপে (strerrorname_np(), glibc ২.৩২ থেকে আছে, GNU-নির্দিষ্ট): (১) কেউ শুনছে না এমন port-এ connect; (২) চালু listener-এর port-এ আবার bind, SO_REUSEADDR ছাড়া ও সহ; (৩) listener বন্ধ, কিন্তু আগের একটি সংযোগ TIME-WAIT-এ পড়ে আছে — তখন আবার bind; (৪) অন্য পক্ষ বন্ধ করার পর MSG_NOSIGNAL দিয়ে দুবার send().

#define _GNU_SOURCE                       /* for strerrorname_np() (glibc 2.32+) */
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
static struct sockaddr_in A;              /* the address used by the next call */
#define SA (struct sockaddr *)&A
static int tcp_at(int port, int reuse) {  /* new TCP socket for 127.0.0.1:port */
    A = (struct sockaddr_in){ .sin_family = AF_INET, .sin_port = htons(port) };
    A.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof reuse);  return fd;
}
static void show(const char *what, int rc) {
    printf("%-46s -> %s\n", what, rc == 0 ? "OK" : strerrorname_np(errno)); }
int main(void) {
    show("1. connect to 127.0.0.1:47399 (nobody listens)", connect(tcp_at(47399, 0), SA, sizeof A));
    int ls = tcp_at(47304, 1);
    show("2. bind+listen 47304", bind(ls, SA, sizeof A) || listen(ls, 8));
    show("   bind 47304 again, no SO_REUSEADDR", bind(tcp_at(47304, 0), SA, sizeof A));
    show("   bind 47304 again, SO_REUSEADDR", bind(tcp_at(47304, 1), SA, sizeof A));
    int c = tcp_at(47304, 0); connect(c, SA, sizeof A);
    close(accept(ls, NULL, NULL)); close(c); close(ls);   /* server side closed first */
    usleep(50000);                                         /* -> TIME-WAIT on port 47304 */
    show("3. listener gone, TIME-WAIT left; no REUSEADDR", bind(tcp_at(47304, 0), SA, sizeof A));
    show("   same, with SO_REUSEADDR", bind(tcp_at(47304, 1), SA, sizeof A));
    ls = tcp_at(47305, 1); bind(ls, SA, sizeof A); listen(ls, 8);
    c = tcp_at(47305, 0); connect(c, SA, sizeof A);
    close(accept(ls, NULL, NULL)); usleep(50000);          /* the peer closes */
    show("4. send #1 after peer close (MSG_NOSIGNAL)", send(c, "x", 1, MSG_NOSIGNAL) < 0);
    usleep(50000);                                         /* the peer's RST arrives */
    show("   send #2 after the RST (MSG_NOSIGNAL)", send(c, "x", 1, MSG_NOSIGNAL) < 0);
}

1. connect to 127.0.0.1:47399 (nobody listens) -> ECONNREFUSED
2. bind+listen 47304                           -> OK
   bind 47304 again, no SO_REUSEADDR           -> EADDRINUSE
   bind 47304 again, SO_REUSEADDR              -> EADDRINUSE
3. listener gone, TIME-WAIT left; no REUSEADDR -> EADDRINUSE
   same, with SO_REUSEADDR                     -> OK
4. send #1 after peer close (MSG_NOSIGNAL)     -> OK
   send #2 after the RST (MSG_NOSIGNAL)        -> EPIPE

close বনাম shutdown

close(fd) descriptor ছেড়ে দেয়; এটাই শেষ descriptor হলে kernel FIN পাঠায় (receive buffer-এ না-পড়া ডেটা থাকলে Linux FIN-এর বদলে RST পাঠায়)। কিন্তু fork()-এর পর parent আর child দুজনের কাছেই একই socket-এর descriptor থাকে — একজন close() করলে সংযোগ বন্ধ হয় না, শুধু তার কপি যায়। shutdown(fd, SHUT_WR) descriptor-এর সংখ্যা না দেখেই লেখার দিকে FIN পাঠায়, আর পড়ার দিক খোলা রাখে — পর্ব ২৯-এর half-close. “আমার অনুরোধ শেষ, উত্তর দিন” বোঝাতে এটাই সঠিক যন্ত্র; তারপরও descriptor মুক্ত করতে শেষে close() লাগে।

Timeout — চিরকাল অপেক্ষা নয়

Blocking read() অন্য পক্ষ চুপ থাকলে অনন্তকাল অপেক্ষা করতে পারে — নীরব, অর্ধেক-খোলা সংযোগে (পর্ব ২৯) এটা সত্যিই ঘটে। দুটি সহজ উপায়:

struct timeval tv = { .tv_sec = 5, .tv_usec = 0 };            /* ৫ সেকেন্ড */
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);      /* read: -1, errno EAGAIN/EWOULDBLOCK */
setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv);      /* write-এর জন্য */

SO_RCVTIMEO পার হলে read() −১ ফেরত দেয়, errno EAGAIN বা EWOULDBLOCK. connect()-এর timeout আলাদা বিষয়: কোনো উত্তর না এলে Linux ডিফল্টে কয়েকবার SYN আবার পাঠায় (tcp_syn_retries = ৬ হলে মোট প্রায় দুই মিনিট)। নিজের মাপের connect timeout-এর বহনযোগ্য উপায় হলো socket-কে non-blocking করে connect() (ফেরত দেয় EINPROGRESS), তারপর poll() দিয়ে নির্দিষ্ট সময় লেখার-প্রস্তুতির অপেক্ষা, শেষে getsockopt(SO_ERROR) দিয়ে ফল দেখা। poll() আর non-blocking socket-এর পুরো গল্প পর্ব ৪৪-এ।

৮ · একজন-একজন করে সেবা, নিরাপদ server আর টুল

Iterative server — সহজ, কিন্তু একজন ধীর হলে সবাই আটকে

এই পর্বের server-এর কাঠামো এমন: for (;;) { c = accept(ls); serve(c); close(c); }. একজন client-কে পুরো সেবা দিয়ে তবেই পরের accept(). লেখা সহজ, বোঝা সহজ, কোনো race condition নেই। কিন্তু একজন client যদি ধীর হয় — ধীর মোবাইল নেটওয়ার্কে আছে, বা ইচ্ছা করে প্রতি মিনিটে এক বাইট পাঠায় — তাহলে serve() তার read()-এ আটকে থাকে, আর বাকি সবাই accept queue-তে লাইনে দাঁড়িয়ে। Queue ভরে গেলে নতুনরা সংযোগই পায় না।

তবু iterative server-এর জায়গা আছে: খুব ছোট, দ্রুত অনুরোধের সেবা, শেখা আর পরীক্ষা, বা যেখানে ক্রম বজায় রাখা জরুরি। আর এটি concurrent server-এর ভিত্তি — serve() ফাংশন বদলায় না, বদলায় শুধু কে কখন সেটা ডাকে। পর্ব ৪৫-এ এই সব একসাথে করে একটি ছোট HTTP server বানানো হবে।

নিরাপদ server-এর চেকলিস্ট

টুল দিয়ে দেখা — ss, nc, telnet

নিজের server কোন ঠিকানায় শুনছে, তা দেখার সবচেয়ে দ্রুত উপায় ss (পর্ব ০৬)। -t TCP, -l শুধু LISTEN, -n নামের বদলে সংখ্যা, -p কোন process (অন্য ব্যবহারকারীর process দেখতে root লাগে)। একটি সাধারণ Linux যন্ত্রের উদাহরণ (এখানে চালানো নয়):

$ ss -tlnp                                   # উদাহরণ আউটপুট
State  Recv-Q Send-Q Local Address:Port  Peer Address:Port Process
LISTEN 0      8          127.0.0.1:47301      0.0.0.0:*     users:(("echo_srv",pid=2817,fd=3))
LISTEN 0      4096         0.0.0.0:8080       0.0.0.0:*     users:(("devserver",pid=2901,fd=5))
LISTEN 0      244            [::1]:5432          [::]:*     users:(("postgres",pid=1190,fd=6))

প্রথম সারি আমাদের echo server — শুধু loopback, backlog ৮ (Send-Q ঘরে)। দ্বিতীয় সারি সাবধান হওয়ার মতো: 0.0.0.0:8080 মানে LAN-এর যে কেউ এই ডেভেলপমেন্ট server-এ পৌঁছাতে পারে। তৃতীয়টি শুধু IPv6 loopback-এ। হাতে সংযোগ করে বাইট পাঠাতে netcat সবচেয়ে সুবিধার — শুধু নিজের যন্ত্রে বা নিজের অনুমতিপ্রাপ্ত পরীক্ষাগারে:

# উদাহরণ — নিজের যন্ত্রে, দুটি terminal-এ
$ nc -l 127.0.0.1 47301          # terminal ১: একটি অস্থায়ী server (OpenBSD nc-এর ধরন)
$ nc 127.0.0.1 47301             # terminal ২: client; লিখে Enter চাপলে অন্য পাশে দেখা যাবে
$ telnet 127.0.0.1 47301         # পুরোনো বিকল্প; বের হতে Ctrl+] তারপর quit

nc-এর কয়েকটি আলাদা রূপ আছে (OpenBSD netcat, GNU netcat, Nmap-এর ncat); শোনার option-এর লেখা (-l -p port বনাম -l port) তাদের মধ্যে আলাদা — নিজের যন্ত্রের man nc দেখে নিন।

অন্য ভাষায় একই কাজ

প্রায় সব ভাষার নেটওয়ার্ক library ভেতরে এই Berkeley API-ই ডাকে; শুধু কিছু ঝামেলা নিজে সামলে দেয়। এই সারণি তুলনার জন্য, এখানে চালানোর জন্য নয়:

খেয়াল করুন: কোনো ভাষাই “একটি read = একটি বার্তা” দেয় না। Python-এর recv(1024)-ও আংশিক ফেরত দিতে পারে; framing সবখানে application-এর দায়িত্ব। C কোর্সের নেটওয়ার্ক প্রোগ্রামিং — TCP সকেট পর্বে C-র দিক থেকে আরেকটি সহজ পরিচয় আছে।

৯ · AI-এর যুগে socket কোড — চলছে মানেই ঠিক নয়

“C-তে একটি TCP echo server লিখে দাও” — AI কয়েক সেকেন্ডে চলনসই কোড দেবে, আর loopback-এ সেটা চলবেও। সমস্যা হলো, socket কোডের বেশিরভাগ বাগ loopback-এ লুকিয়ে থাকে: ছোট বার্তা একবারে আসে, কেউ হঠাৎ চলে যায় না, IPv6 নিয়ে কেউ ভাবে না। AI-এর লেখা কোডে বারবার দেখা যায় এমন ভুল:

AI-এর socket কোড চালানোর আগে — চেকলিস্ট

• প্রতিটি read/recv loop-এ আছে, ০ (EOF) আর −১ আলাদা করে সামলানো, আর বার্তার সীমানা একটি স্পষ্ট framing নিয়মে ঠিক হয়
• নেটওয়ার্ক থেকে আসা প্রতিটি দৈর্ঘ্য সীমার সাথে মেলানো হয়েছে, আর buffer-এ '\0' বসানোর জায়গা রাখা আছে
• getaddrinfo-এর সব ফলাফল চেষ্টা হয়, ব্যর্থ socket বন্ধ হয়, শেষে freeaddrinfo
• Server কোন ঠিকানায় শুনছে ss -tlnp দিয়ে নিজে দেখেছি; দরকার ছাড়া 0.0.0.0 নয়
• Client-কে মাঝপথে মেরে, বড় বার্তা পাঠিয়ে, আর ভুল দৈর্ঘ্য পাঠিয়ে পরীক্ষা করেছি — নিজের যন্ত্রে বা VM-এ, দরকারে নিজের loopback-এ tcpdump দিয়ে আসল segment দেখে