Esercizio - Server HTTP che risponde in chunked con trailer (sul modello della prova pratica)

<dimensione in esadecimale> CRLF
<dati> CRLF

0 CRLF
[righe di trailer, ciascuna "Nome: valore" CRLF]
CRLF

/* chunk_server.c - server HTTP/1.1 che risponde con Transfer-Encoding: chunked (lunghezza non nota in anticipo).
 *   GET /stream : cinque righe generate una alla volta, con un trailer finale X-Totale-Byte
 *   GET /lorem  : un testo spezzato in chunk da 16 byte (comodo per vedere la struttura)
 *   altro       : 404 con Content-Length
 *
 * Compilare:  gcc -Wall -Wextra -o chunk_server chunk_server.c
 * Avviare:    ./chunk_server 8080
 * Provare:    curl -i http://127.0.0.1:8080/lorem          (curl decodifica i chunk)
 *             curl --raw -i http://127.0.0.1:8080/lorem    (--raw mostra i chunk cosi' come viaggiano)
 *             curl -N http://127.0.0.1:8080/stream         (-N: stampa man mano che arriva)
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

static int write_all(int fd, const char *buf, size_t n)
{
    while (n > 0) {
        ssize_t w = write(fd, buf, n);
        if (w < 0) {
            if (errno == EINTR)
                continue;
            return -1;
        }
        buf += w;
        n -= (size_t)w;
    }
    return 0;
}

/* Un chunk:  <lunghezza in esadecimale> CRLF <dati> CRLF.  Un chunk di lunghezza 0 NON va mandato qui:
 * e' il last-chunk e chiude il corpo (lo fa end_chunks). */
static int send_chunk(int fd, const char *data, size_t len)
{
    if (len == 0)
        return 0;
    char hdr[32];
    int n = snprintf(hdr, sizeof hdr, "%zx\r\n", len);
    if (write_all(fd, hdr, (size_t)n) < 0 || write_all(fd, data, len) < 0 || write_all(fd, "\r\n", 2) < 0)
        return -1;
    return 0;
}

/* last-chunk "0", poi i trailer (righe "Nome: valore"), poi la riga vuota finale. */
static int end_chunks(int fd, const char *trailers)
{
    if (write_all(fd, "0\r\n", 3) < 0)
        return -1;
    if (trailers != NULL && write_all(fd, trailers, strlen(trailers)) < 0)
        return -1;
    return write_all(fd, "\r\n", 2);
}

/* Legge la richiesta fino alla riga vuota, un byte per volta; copia la prima riga in first. */
static int read_request(int fd, char *first, size_t size)
{
    char line[1024];
    size_t n = 0;
    int nline = 0;
    char c;
    for (;;) {
        if (read(fd, &c, 1) <= 0)
            return -1;
        if (c != '\n') {
            if (n + 1 < sizeof line)
                line[n++] = c;
            continue;
        }
        if (n > 0 && line[n - 1] == '\r')
            n--;
        line[n] = '\0';
        if (nline++ == 0)
            snprintf(first, size, "%s", line);
        else if (n == 0)
            return 0;                               /* riga vuota: richiesta completa */
        n = 0;
    }
}

static void handle(int fd)
{
    char first[1024], method[16], target[512];
    if (read_request(fd, first, sizeof first) < 0 || sscanf(first, "%15s %511s", method, target) != 2) {
        close(fd);
        return;
    }
    if (strcmp(method, "GET") == 0 && strcmp(target, "/stream") == 0) {
        const char *head =
            "HTTP/1.1 200 OK\r\n"
            "Content-Type: text/plain\r\n"
            "Transfer-Encoding: chunked\r\n"
            "Trailer: X-Totale-Byte\r\n"             /* annuncia che alla fine arrivera' questo trailer */
            "Connection: close\r\n"
            "\r\n";
        write_all(fd, head, strlen(head));
        size_t total = 0;
        for (int i = 1; i <= 5; i++) {
            char msg[64];
            int len = snprintf(msg, sizeof msg, "riga %d di 5\n", i);
            if (send_chunk(fd, msg, (size_t)len) < 0)
                break;
            total += (size_t)len;
            usleep(300000);                         /* il client riceve ogni riga subito, senza aspettare la fine */
        }
        char trailer[64];
        snprintf(trailer, sizeof trailer, "X-Totale-Byte: %zu\r\n", total);
        end_chunks(fd, trailer);
    } else if (strcmp(method, "GET") == 0 && strcmp(target, "/lorem") == 0) {
        const char *text = "Il chunked permette di mandare un corpo senza conoscerne la lunghezza.\n";
        const char *head =
            "HTTP/1.1 200 OK\r\n"
            "Content-Type: text/plain; charset=utf-8\r\n"
            "Transfer-Encoding: chunked\r\n"
            "Connection: close\r\n"
            "\r\n";
        write_all(fd, head, strlen(head));
        size_t len = strlen(text);
        for (size_t off = 0; off < len; off += 16)  /* l'ultimo chunk puo' essere piu' corto */
            send_chunk(fd, text + off, len - off < 16 ? len - off : 16);
        end_chunks(fd, NULL);
    } else {
        const char *resp =
            "HTTP/1.1 404 Not Found\r\n"
            "Content-Type: text/plain\r\n"
            "Content-Length: 10\r\n"                 /* qui la lunghezza e' nota: niente chunked */
            "Connection: close\r\n"
            "\r\n"
            "Not Found\n";
        write_all(fd, resp, strlen(resp));
    }
    close(fd);
}

int main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "uso: %s porta\n", argv[0]);
        return 1;
    }
    signal(SIGPIPE, SIG_IGN);
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd < 0) {
        perror("socket");
        return 1;
    }
    int yes = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons((unsigned short)atoi(argv[1]));
    if (bind(lfd, (struct sockaddr *)&addr, sizeof addr) < 0 || listen(lfd, 8) < 0) {
        perror("bind/listen");
        return 1;
    }
    for (;;) {
        int cfd = accept(lfd, NULL, NULL);          /* NULL: non ci serve l'indirizzo del client */
        if (cfd < 0) {
            if (errno == EINTR)
                continue;
            perror("accept");
            break;
        }
        handle(cfd);
    }
    return 0;
}

$ gcc -Wall -Wextra -o chunk_server chunk_server.c
$ ./chunk_server 8080 &
$ curl -i http://127.0.0.1:8080/lorem          # curl decodifica i chunk
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Transfer-Encoding: chunked
Connection: close

Il chunked permette di mandare un corpo senza conoscerne la lunghezza.

$ curl --raw -i http://127.0.0.1:8080/lorem | cat -A
HTTP/1.1 200 OK^M$
Content-Type: text/plain; charset=utf-8^M$
Transfer-Encoding: chunked^M$
Connection: close^M$
^M$
10^M$
Il chunked perme^M$
10^M$
tte di mandare u^M$
10^M$
n corpo senza co^M$
10^M$
noscerne la lung^M$
7^M$
hezza.$
^M$
0^M$
^M$

$ curl -N --raw -i http://127.0.0.1:8080/stream
HTTP/1.1 200 OK^M$
Content-Type: text/plain^M$
Transfer-Encoding: chunked^M$
Trailer: X-Totale-Byte^M$
Connection: close^M$
^M$
c^M$
riga 1 di 5$
^M$
c^M$
riga 2 di 5$
^M$
...
c^M$
riga 5 di 5$
^M$
0^M$
X-Totale-Byte: 60^M$
^M$