প্রজেক্ট — C-তে একটি ছোট HTTP সার্ভার

/* mini_httpd.c -- a small, careful static-file HTTP/1.1 server (a learning project, not for production)
 * build: gcc -Wall -Wextra -O2 -o mini_httpd mini_httpd.c
 * run:   ./mini_httpd 8080 ./www      then open http://127.0.0.1:8080/  */
#define _GNU_SOURCE                       /* memmem, strcasestr */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <arpa/inet.h>

#define MAX_HEAD 8192                     /* request line + all headers */
#define IDLE_SEC 5                        /* keep-alive: close after this much silence */
#define HEAD_SEC 10                       /* a whole request head must arrive within this (Slowloris) */
#define MAX_REQS 100                      /* requests served on one connection */

struct req { char method[16], target[2048], version[16], inm[128]; int hosts, close, body; };
static char root[PATH_MAX];               /* document root, already passed through realpath() */
static size_t rootlen;

static int writen(int s, const void *p, size_t n) {            /* write() may send less: loop (lesson 41) */
    for (const char *c = p; n > 0; ) {
        ssize_t k = write(s, c, n);
        if (k < 0 && errno == EINTR) continue;
        if (k <= 0) return -1;
        c += k; n -= (size_t)k;
    }
    return 0;
}

/* 1 = head complete (*end points at "\r\n\r\n"), 0 = closed or idle, -1 = too big, -2 = too slow */
static int read_head(int s, char *b, size_t *n, char **end) {
    time_t start = time(NULL);
    while (!(*end = memmem(b, *n, "\r\n\r\n", 4))) {
        if (*n >= MAX_HEAD) return -1;
        if (time(NULL) - start > HEAD_SEC) return -2;
        ssize_t k = read(s, b + *n, MAX_HEAD - *n);
        if (k < 0 && errno == EINTR) continue;
        if (k < 0 && *n > 0) return -2;                        /* went silent half-way through a request */
        if (k <= 0) return 0;                                  /* peer closed, or idle timeout */
        *n += (size_t)k;
    }
    return 1;
}

static int content_length(const char *v, unsigned long long *out) {   /* digits only, and no overflow */
    unsigned long long x = 0;
    if (*v == '\0') return -1;
    for (; *v >= '0' && *v <= '9'; v++) {
        if (x > (ULLONG_MAX - (unsigned)(*v - '0')) / 10) return -1;
        x = x * 10 + (unsigned)(*v - '0');
    }
    if (*v) return -1;
    *out = x;
    return 0;
}

static int parse(char *b, size_t len, struct req *r) {         /* 0 = fine, else an error status */
    char extra[2], *p, *nl, *colon, *v, *e;
    unsigned long long cl;
    if (strlen(b) != len) return 400;                          /* a NUL byte hidden inside the head */
    for (p = b; *p; p++)                                       /* other controls, a bare CR or a bare LF */
        if ((*p == '\r' && p[1] != '\n') || (*p == '\n' && (p == b || p[-1] != '\r'))
            || ((unsigned char)*p < 0x20 && *p != '\r' && *p != '\n' && *p != '\t') || *p == 0x7f) return 400;
    if ((nl = strstr(b, "\r\n"))) *nl = '\0';
    if ((v = strchr(b, ' ')) && strcspn(v + 1, " \t") >= sizeof r->target) return 414;   /* target too long */
    if (sscanf(b, "%15s %2047s %15s %1s", r->method, r->target, r->version, extra) != 3) return 400;
    if (strcmp(r->version, "HTTP/1.1") && strcmp(r->version, "HTTP/1.0"))
        return strncmp(r->version, "HTTP/", 5) ? 400 : 505;
    if (r->target[0] != '/') return 400;
    r->close = strcmp(r->version, "HTTP/1.0") == 0;            /* 1.0 closes unless it asks for keep-alive */
    for (p = nl ? nl + 2 : b + len; *p; p = nl ? nl + 2 : p + strlen(p)) {
        if ((nl = strstr(p, "\r\n"))) *nl = '\0';
        colon = strchr(p, ':');
        if (*p == ' ' || *p == '\t' || !colon || colon == p || colon[-1] == ' ' || colon[-1] == '\t')
            return 400;                                        /* folded line, or "Name : v": both invalid */
        *colon = '\0';
        v = colon + 1 + strspn(colon + 1, " \t");
        for (e = v + strlen(v); e > v && (e[-1] == ' ' || e[-1] == '\t'); ) *--e = '\0';
        if (!strcasecmp(p, "Host")) r->hosts++;
        else if (!strcasecmp(p, "Connection")) r->close = strcasestr(v, "close") ? 1 : strcasestr(v, "keep-alive") ? 0 : r->close;
        else if (!strcasecmp(p, "If-None-Match")) snprintf(r->inm, sizeof r->inm, "%s", v);
        else if (!strcasecmp(p, "Transfer-Encoding")) r->body = 1;
        else if (!strcasecmp(p, "Content-Length")) { if (content_length(v, &cl)) return 400; if (cl > 0) r->body = 1; }
    }
    if (r->hosts > 1 || (r->hosts == 0 && !strcmp(r->version, "HTTP/1.1"))) return 400;   /* exactly one Host */
    return 0;
}

static int hex(int c) { const char *d = "0123456789abcdef0123456789ABCDEF", *p = c ? strchr(d, c) : NULL; return p ? (int)(p - d) % 16 : -1; }

static int safe_path(const char *t, char *out, size_t cap) {   /* decode %XX once, then check */
    size_t n = 0;
    for (; *t && *t != '?'; t++) {
        int c = (unsigned char)*t, h, l;
        if (c == '%') {
            if ((h = hex(t[1])) < 0 || (l = hex(t[2])) < 0) return 400;
            c = h * 16 + l; t += 2;
        }
        if (c < 0x20 || c == 0x7f || c == '\\') return 400;    /* NUL, CR, LF, other controls, backslash */
        if (n + 1 >= cap) return 414;
        out[n++] = (char)c;
    }
    out[n] = '\0';
    for (const char *p = out; (p = strstr(p, "/..")); p++)
        if (p[3] == '/' || p[3] == '\0') return 403;          /* a ".." path segment */
    return out[0] == '/' ? 0 : 400;
}

static const char *reason(int c) {
    switch (c) {
    case 200: return "OK";                 case 304: return "Not Modified";
    case 400: return "Bad Request";        case 403: return "Forbidden";
    case 404: return "Not Found";          case 405: return "Method Not Allowed";
    case 408: return "Request Timeout";    case 413: return "Content Too Large";
    case 414: return "URI Too Long";       case 431: return "Request Header Fields Too Large";
    case 501: return "Not Implemented";    case 505: return "HTTP Version Not Supported";
    default:  return "Internal Server Error";
    }
}

static const char *mime(const char *path) {
    static const char *table[][2] = {
        {".html", "text/html; charset=utf-8"}, {".css", "text/css; charset=utf-8"},
        {".js", "text/javascript; charset=utf-8"}, {".txt", "text/plain; charset=utf-8"},
        {".png", "image/png"}, {".jpg", "image/jpeg"}, {".svg", "image/svg+xml"}, {".pdf", "application/pdf"} };
    const char *dot = strrchr(path, '.'), *slash = strrchr(path, '/');
    for (size_t i = 0; dot && dot > slash && i < sizeof table / sizeof table[0]; i++)
        if (!strcasecmp(dot, table[i][0])) return table[i][1];
    return "application/octet-stream";
}

static void http_date(char *out, size_t cap, time_t t) {       /* IMF-fixdate, always GMT */
    struct tm tm;
    strftime(out, cap, "%a, %d %b %Y %H:%M:%S GMT", gmtime_r(&t, &tm));
}

/* send headers (+ body text); returns bytes of body sent, or -1 */
static long send_simple(int s, int code, const struct req *r, int head_only) {
    char h[512], date[64], body[128];
    int bl = snprintf(body, sizeof body, "%d %s\n", code, reason(code));
    http_date(date, sizeof date, time(NULL));
    int hl = snprintf(h, sizeof h, "HTTP/1.1 %d %s\r\nDate: %s\r\nContent-Type: text/plain; charset=utf-8\r\n"
                      "Content-Length: %d\r\n%s%s\r\n", code, reason(code), date, bl,
                      code == 405 ? "Allow: GET, HEAD\r\n" : "", r->close ? "Connection: close\r\n" : "");
    if (writen(s, h, (size_t)hl) < 0 || (!head_only && writen(s, body, (size_t)bl) < 0)) return -1;
    return head_only ? 0 : bl;
}

/* GET/HEAD of a file. *code = 200/304 (answered) or 404/414 (caller answers). Returns body bytes, -1 = write error */
static long serve_file(int s, const char *path, const struct req *r, int head_only, int *code) {
    char full[PATH_MAX], real[PATH_MAX], h[768], date[64], lm[64], et[64], buf[16384];
    struct stat st;
    int fd, len = snprintf(full, sizeof full, "%s%s%s", root, path, path[strlen(path) - 1] == '/' ? "index.html" : "");
    *code = 404;
    if (len < 0 || (size_t)len >= sizeof full) { *code = 414; return 0; }
    if (!realpath(full, real)) return 0;                       /* realpath also follows symlinks ... */
    if (strncmp(real, root, rootlen) || (real[rootlen] != '/' && real[rootlen] != '\0')) return 0;  /* ... must stay inside */
    if ((fd = open(real, O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK)) < 0) return 0;   /* a FIFO must not hang us */
    if (fstat(fd, &st) < 0 || !S_ISREG(st.st_mode)) { close(fd); return 0; }
    snprintf(et, sizeof et, "\"%llx-%llx\"", (unsigned long long)st.st_size, (unsigned long long)st.st_mtime);
    http_date(date, sizeof date, time(NULL));
    http_date(lm, sizeof lm, st.st_mtime);
    int not_mod = r->inm[0] && (strstr(r->inm, et) || !strcmp(r->inm, "*"));
    *code = not_mod ? 304 : 200;
    int hl = not_mod
        ? snprintf(h, sizeof h, "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nETag: %s\r\n%s\r\n", date, et,
                   r->close ? "Connection: close\r\n" : "")
        : snprintf(h, sizeof h, "HTTP/1.1 200 OK\r\nDate: %s\r\nContent-Type: %s\r\nContent-Length: %lld\r\n"
                   "Last-Modified: %s\r\nETag: %s\r\n%s\r\n", date, mime(real), (long long)st.st_size, lm, et,
                   r->close ? "Connection: close\r\n" : "");
    long sent = 0;
    if (writen(s, h, (size_t)hl) < 0) sent = -1;
    while (sent >= 0 && sent < st.st_size && !not_mod && !head_only) {   /* stream exactly st_size bytes */
        size_t want = (size_t)(st.st_size - sent) < sizeof buf ? (size_t)(st.st_size - sent) : sizeof buf;
        ssize_t k = read(fd, buf, want);
        if (k <= 0) { sent = -1; break; }                      /* file shrank: Content-Length would lie, so close */
        if (writen(s, buf, (size_t)k) < 0) sent = -1; else sent += k;
    }
    close(fd);
    return sent;
}

static void log_clf(const char *ip, const struct req *r, int code, long bytes) {   /* Common Log Format */
    char ts[64], bs[24] = "-", line[2400]; time_t now = time(NULL); struct tm tm;
    strftime(ts, sizeof ts, "%d/%b/%Y:%H:%M:%S %z", localtime_r(&now, &tm));
    if (bytes > 0) snprintf(bs, sizeof bs, "%ld", bytes);
    int n = snprintf(line, sizeof line, "%s - - [%s] \"%s %s %s\" %d %s\n", ip, ts, r->method[0] ? r->method : "-",
                     r->target[0] ? r->target : "-", r->version[0] ? r->version : "-", code, bs);
    if (n > 0) writen(STDOUT_FILENO, line, (size_t)n < sizeof line ? (size_t)n : sizeof line - 1);   /* one write() per line */
}

static void handle_conn(int s, const char *ip) {
    static char b[MAX_HEAD + 1];
    size_t n = 0;
    struct timeval tv = {IDLE_SEC, 0};
    setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);    /* idle and Slowloris limit */
    setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv);    /* a client that never reads */
    for (int served = 1; served <= MAX_REQS; served++) {
        struct req r = {0};
        char *end, path[2048];
        int rc = read_head(s, b, &n, &end), code = 0, head = 0;
        long sent = 0;
        if (rc == 0) break;                                    /* closed or idle: nothing to answer */
        size_t used = rc == 1 ? (size_t)(end - b) + 4 : n;
        if (rc == 1) { *end = '\0'; code = parse(b, (size_t)(end - b), &r); }
        else code = rc == -1 ? 431 : 408;
        if (served == MAX_REQS) r.close = 1;
        if (!code && r.body) code = 413;                       /* a static server accepts no request bodies */
        if (!code) {
            head = !strcmp(r.method, "HEAD");
            snprintf(path, sizeof path, " %s ", r.method);      /* known method, but not allowed here? */
            if (strcmp(r.method, "GET") && !head)
                code = strstr(" POST PUT DELETE OPTIONS PATCH CONNECT TRACE ", path) ? 405 : 501;
            else if (!(code = safe_path(r.target, path, sizeof path)))
                sent = serve_file(s, path, &r, head, &code);
        }
        if (code >= 400) {
            if (code != 403 && code != 404 && code != 405) r.close = 1;   /* the byte stream may be out of sync */
            sent = send_simple(s, code, &r, head);
        }
        log_clf(ip, &r, code, sent);
        if (sent < 0 || r.close) break;
        memmove(b, b + used, n - used);                        /* keep pipelined bytes for the next request */
        n -= used;
    }
    struct timeval one = {1, 0};                               /* lingering close (as in M1): FIN first, then */
    shutdown(s, SHUT_WR);                                      /* drain for at most ~2 s, so that unread bytes */
    setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &one, sizeof one);  /* do not turn our last answer into an RST */
    for (time_t t0 = time(NULL); time(NULL) - t0 < 2 && read(s, b, MAX_HEAD) > 0; ) {}
    close(s);
}

int main(int argc, char **argv) {
    char *endp;
    long port = argc == 3 ? strtol(argv[1], &endp, 10) : 0;
    if (argc != 3 || *endp || port < 1 || port > 65535) { fprintf(stderr, "usage: %s PORT DOCROOT\n", argv[0]); return 2; }
    if (!realpath(argv[2], root)) { perror(argv[2]); return 1; }
    rootlen = strlen(root);
    signal(SIGPIPE, SIG_IGN);                                  /* a vanished client must not kill us (lesson 41) */
    signal(SIGCHLD, SIG_IGN);                                  /* children are reaped automatically: no zombies */
    struct sockaddr_in a = {.sin_family = AF_INET, .sin_port = htons((unsigned short)port), .sin_addr = {htonl(INADDR_LOOPBACK)}};
    int ls = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(ls, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int));
    if (ls < 0 || bind(ls, (struct sockaddr *)&a, sizeof a) < 0 || listen(ls, 128) < 0) { perror("listen"); return 1; }
    printf("serving %s at http://127.0.0.1:%ld/\n", root, port);
    fflush(stdout);
    for (;;) {                                                 /* fork per connection (lesson 43) */
        struct sockaddr_in peer; socklen_t pl = sizeof peer; char ip[INET_ADDRSTRLEN];
        int s = accept(ls, (struct sockaddr *)&peer, &pl);
        if (s < 0) { if (errno != EINTR) perror("accept"); continue; }
        inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof ip);
        pid_t pid = fork();
        if (pid == 0) { close(ls); handle_conn(s, ip); _exit(0); }
        if (pid < 0) perror("fork");
        close(s);
    }
}