Lecture 20: 网络编程 II 与 Web 服务器 (Network Programming II and Web Servers)

/* tiny_srv.c — 简化版 Tiny Web 服务器：gcc -g -Wall -Wextra -std=gnu11 tiny_srv.c -o tiny_srv
 * 运行: cd docroot && ./tiny_srv 18213      (以 docroot 为工作目录)
 * 验证: curl -v http://127.0.0.1:18213/index.html                              */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <netdb.h>
#define MAXLINE 8192
#define MAXBUF  (MAXLINE * 2)
#define LISTENQ 1024
typedef struct sockaddr SA;

/* ---------- RIO: 缓冲读一行(rio_readlineb) + 无缓冲写满(rio_writen) ---------- */
typedef struct { int rio_fd; ssize_t rio_cnt; char *rio_bufptr; char rio_buf[MAXLINE]; } rio_t;

ssize_t rio_readn(int fd, void *usrbuf, size_t n) {          /* 读满 n 字节，仅 EOF 才短读 */
    size_t nleft = n; ssize_t nread; char *bufp = usrbuf;
    while (nleft > 0) {
        if ((nread = read(fd, bufp, nleft)) < 0) {
            if (errno == EINTR) nread = 0; else return -1;
        } else if (nread == 0) break;                        /* EOF */
        nleft -= nread; bufp += nread;
    }
    return (ssize_t)(n - nleft);
}
static ssize_t rio_writen(int fd, const void *usrbuf, size_t n) { /* 绝不短写 */
    size_t nleft = n; ssize_t nwritten; const char *bufp = usrbuf;
    while (nleft > 0) {
        if ((nwritten = write(fd, bufp, nleft)) <= 0) {
            if (errno == EINTR) nwritten = 0; else return -1;
        }
        nleft -= nwritten; bufp += nwritten;
    }
    return (ssize_t)n;
}
static void rio_readinitb(rio_t *rp, int fd)
{ rp->rio_fd = fd; rp->rio_cnt = 0; rp->rio_bufptr = rp->rio_buf; }

static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n) {  /* 内部缓冲读 */
    int cnt;
    while (rp->rio_cnt <= 0) {                                /* 缓冲空则填满 */
        rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, sizeof(rp->rio_buf));
        if (rp->rio_cnt < 0) { if (errno != EINTR) return -1; }
        else if (rp->rio_cnt == 0) return 0;                  /* EOF */
        else rp->rio_bufptr = rp->rio_buf;
    }
    cnt = (rp->rio_cnt < (ssize_t)n) ? (int)rp->rio_cnt : (int)n;
    memcpy(usrbuf, rp->rio_bufptr, cnt);
    rp->rio_bufptr += cnt; rp->rio_cnt -= cnt;
    return cnt;
}
static ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) {
    ssize_t n, rc; char c, *bufp = usrbuf;
    for (n = 1; n < (ssize_t)maxlen; n++) {
        if ((rc = rio_read(rp, &c, 1)) == 1) { *bufp++ = c; if (c == '\n') break; }
        else if (rc == 0) { if (n == 1) return 0; else break; }
        else return -1;
    }
    *bufp = '\0';
    return n;
}
static void unix_error(const char *m){ fprintf(stderr,"%s: %s\n",m,strerror(errno)); exit(1); }

static int Open_listenfd(const char *port) {                  /* getaddrinfo 版: 协议无关+线程安全 */
    struct addrinfo hints, *listp, *p; int listenfd, optval = 1;
    memset(&hints, 0, sizeof(hints));
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG | AI_NUMERICSERV;
    if (getaddrinfo(NULL, port, &hints, &listp) != 0) unix_error("getaddrinfo");
    for (p = listp; p; p = p->ai_next) {
        if ((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) continue;
        setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int));
        if (bind(listenfd, p->ai_addr, p->ai_addrlen) == 0) break;
        close(listenfd);
    }
    freeaddrinfo(listp);
    if (!p) return -1;
    if (listen(listenfd, LISTENQ) < 0) { close(listenfd); return -1; }
    return listenfd;
}

/* ------------------------------- Tiny 主体 -------------------------------- */
static void serve_static(int fd, const char *filename, int filesize) {
    int srcfd; char *srcp, filetype[MAXLINE], buf[MAXBUF];
    if      (strstr(filename, ".html")) strcpy(filetype, "text/html");
    else if (strstr(filename, ".gif"))  strcpy(filetype, "image/gif");
    else if (strstr(filename, ".png"))  strcpy(filetype, "image/png");
    else if (strstr(filename, ".jpg"))  strcpy(filetype, "image/jpeg");
    else                                 strcpy(filetype, "text/plain");

    sprintf(buf, "HTTP/1.0 200 OK\r\n");                rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Server: Tiny-Lite Web Server\r\n");    rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-length: %d\r\n", filesize);    rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-type: %s\r\n\r\n", filetype);  rio_writen(fd, buf, strlen(buf));

    srcfd = open(filename, O_RDONLY, 0);
    if (srcfd < 0) return;
    srcp = mmap(0, filesize, PROT_READ, MAP_PRIVATE, srcfd, 0);  /* 文件页按需装入 */
    close(srcfd);                                                /* 映射后即可关闭 fd */
    if (srcp != MAP_FAILED) { rio_writen(fd, srcp, filesize); munmap(srcp, filesize); }
}

static void clienterror(int fd, const char *cause, const char *errnum,
                        const char *shortmsg, const char *longmsg) {
    char buf[MAXLINE], body[MAXLINE];
    sprintf(body, "<html><title>Tiny Error</title>");
    sprintf(body + strlen(body), "<body bgcolor=\"ffffff\">\r\n");
    sprintf(body + strlen(body), "%s: %s\r\n", errnum, shortmsg);
    sprintf(body + strlen(body), "<p>%s: %s\r\n", longmsg, cause);
    sprintf(body + strlen(body), "<hr><em>The Tiny Web server</em>\r\n");
    sprintf(buf, "HTTP/1.0 %s %s\r\n", errnum, shortmsg);   rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-type: text/html\r\n");            rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-length: %d\r\n\r\n",(int)strlen(body)); rio_writen(fd, buf, strlen(buf));
    rio_writen(fd, body, strlen(body));
}

static void doit(int fd) {
    int is_static; struct stat sbuf;
    char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE];
    char filename[MAXLINE]; rio_t rio;

    rio_readinitb(&rio, fd);
    if (!rio_readlineb(&rio, buf, MAXLINE)) return;            /* 客户端未发请求就关闭 */
    printf("[server] request line: %s", buf);
    sscanf(buf, "%s %s %s", method, uri, version);             /* 解析请求行 */
    if (strcasecmp(method, "GET")) {                           /* 非 GET -> 501 */
        clienterror(fd, method, "501", "Not Implemented", "Tiny does not implement this method");
        return;
    }
    while (strcmp(buf, "\r\n")) {                              /* 读头直到空行 */
        if (!rio_readlineb(&rio, buf, MAXLINE)) break;
        printf("[server] header: %s", buf);
    }
    is_static = (strstr(uri, "cgi-bin") == NULL);              /* cgi-bin -> 动态 */
    strcpy(filename, "."); strcat(filename, uri);              /* URI 映射到 "./"+uri */
    if (uri[strlen(uri) - 1] == '/') strcat(filename, "index.html");  /* 目录默认页 */
    if (!is_static) {
        clienterror(fd, filename, "501", "Not Implemented", "CGI not shown in this demo");
        return;
    }
    if (stat(filename, &sbuf) < 0) {                           /* 不存在 -> 404 */
        clienterror(fd, filename, "404", "Not found", "Tiny couldn't find this file");
        return;
    }
    if (!(S_ISREG(sbuf.st_mode)) || !(S_IRUSR & sbuf.st_mode)) { /* 非常规文件/不可读 -> 403 */
        clienterror(fd, filename, "403", "Forbidden", "Tiny couldn't read the file");
        return;
    }
    serve_static(fd, filename, (int)sbuf.st_size);
}

int main(int argc, char **argv) {
    int listenfd, connfd; char hostname[MAXLINE], port[MAXLINE];
    socklen_t clientlen; struct sockaddr_storage clientaddr;
    if (argc != 2) { fprintf(stderr, "usage: %s <port>\n", argv[0]); exit(1); }
    listenfd = Open_listenfd(argv[1]);
    if (listenfd < 0) unix_error("Open_listenfd");
    printf("[server] listening on port %s\n", argv[1]); fflush(stdout);
    while (1) {                                                /* 迭代式: 一次一个连接 */
        clientlen = sizeof(clientaddr);
        connfd = accept(listenfd, (SA *)&clientaddr, &clientlen);
        if (connfd < 0) continue;
        getnameinfo((SA *)&clientaddr, clientlen, hostname, MAXLINE, port, MAXLINE, 0);
        printf("[server] accepted connection from (%s, %s)\n", hostname, port); fflush(stdout);
        doit(connfd);
        close(connfd);
    }
    return 0;
}

/* miniproxy.c — 最小可用代理: gcc -g -Wall -Wextra -std=gnu11 miniproxy.c -o miniproxy
 * 运行: ./miniproxy 18214
 * 验证: curl -x http://127.0.0.1:18214 http://127.0.0.1:18213/index.html */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#define MAXLINE 8192
#define LISTENQ 1024
typedef struct sockaddr SA;

/* 逐字节读到 '\r\n'：头部长度不可预知，这样最稳 */
static ssize_t read_until_crlf(int fd, char *buf, size_t max) {
    size_t i = 0; char c; ssize_t n;
    while (i + 1 < max) {
        if ((n = read(fd, &c, 1)) <= 0) return n == 0 ? (ssize_t)i : -1;
        buf[i++] = c;
        if (i >= 2 && buf[i-2] == '\r' && buf[i-1] == '\n') break;
    }
    buf[i] = '\0';
    return (ssize_t)i;
}
static ssize_t writen(int fd, const char *buf, size_t n) {
    size_t left = n; ssize_t w;
    while (left > 0) {
        if ((w = write(fd, buf, left)) <= 0) {
            if (errno == EINTR) continue;
            return -1;                       /* 常见: EPIPE —— 客户端提前断开 */
        }
        left -= (size_t)w; buf += w;
    }
    return (ssize_t)n;
}
static ssize_t readn(int fd, char *buf, size_t n) {   /* 严格读满 n 字节 */
    size_t left = n; ssize_t r;
    while (left > 0) {
        if ((r = read(fd, buf, left)) <= 0) {
            if (r < 0 && errno == EINTR) continue;
            return r < 0 ? -1 : (ssize_t)(n - left);
        }
        left -= (size_t)r; buf += r;
    }
    return (ssize_t)n;
}
static void clienterror(int fd, const char *num, const char *msg, const char *longmsg) {
    char buf[MAXLINE], body[MAXLINE];
    snprintf(body, sizeof(body),
             "<html><title>Proxy Error</title>\r\n%s: %s\r\n<p>%s\r\n", num, msg, longmsg);
    snprintf(buf, sizeof(buf), "HTTP/1.0 %s %s\r\n", num, msg);   writen(fd, buf, strlen(buf));
    snprintf(buf, sizeof(buf), "Content-type: text/html\r\n");    writen(fd, buf, strlen(buf));
    snprintf(buf, sizeof(buf), "Content-length: %d\r\n\r\n", (int)strlen(body));
    writen(fd, buf, strlen(buf));
    writen(fd, body, strlen(body));
}
static int open_clientfd(const char *host, const char *port) {
    struct addrinfo hints, *listp, *p; int fd;
    memset(&hints, 0, sizeof(hints));
    hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_NUMERICSERV;
    if (getaddrinfo(host, port, &hints, &listp) != 0) return -1;
    for (p = listp; p; p = p->ai_next) {
        if ((fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) continue;
        if (connect(fd, p->ai_addr, p->ai_addrlen) == 0) break;
        close(fd);
    }
    freeaddrinfo(listp);
    return p ? fd : -1;
}
/* 从 "http://host[:port]/path" 拆出 host / port / path（含查询串） */
static int parse_url(const char *url, char *host, char *port, char *path) {
    const char *p = url, *slash, *colon; size_t hl, pl;
    if (strncasecmp(p, "http://", 7) != 0) return -1;
    p += 7; slash = strchr(p, '/');
    if (!slash) return -1;
    colon = memchr(p, ':', (size_t)(slash - p));
    if (colon) {
        hl = (size_t)(colon - p); pl = (size_t)(slash - colon - 1);
        if (hl == 0 || hl >= MAXLINE || pl == 0 || pl >= 16) return -1;
        memcpy(host, p, hl); host[hl] = '\0';
        memcpy(port, colon + 1, pl); port[pl] = '\0';
    } else {
        hl = (size_t)(slash - p);
        if (hl == 0 || hl >= MAXLINE) return -1;
        memcpy(host, p, hl); host[hl] = '\0';
        strcpy(port, "80");                              /* 缺省端口 80 */
    }
    snprintf(path, MAXLINE, "%s", slash);                /* 保留 ?query */
    return 0;
}
static void handle(int connfd) {
    char buf[MAXLINE], method[MAXLINE], url[MAXLINE], version[MAXLINE];
    char host[MAXLINE], port[16], path[MAXLINE], server_buf[MAXLINE * 4];
    int serverfd, bad_line = 0; ssize_t n;
    long content_length = -1; int saw_cl = 0;

    n = read_until_crlf(connfd, buf, MAXLINE);           /* 1. 请求行 */
    if (n <= 0) return;
    if (sscanf(buf, "%s %s %s", method, url, version) != 3) bad_line = 1;

    /* 2. 无论如何先把客户端请求头读干净(直到空行)!
     *    若带着未读数据 close(), 内核发送 RST 而非 FIN, 客户端读不到错误响应。 */
    while ((n = read_until_crlf(connfd, buf, MAXLINE)) > 0) {
        if (strcmp(buf, "\r\n") == 0) break;
        if (strncasecmp(buf, "Content-Length:", 15) == 0) {
            content_length = strtol(buf + 15, NULL, 10); saw_cl = 1;
        }
    }
    if (saw_cl && content_length > 0) {                  /* 有 body 一并读掉 */
        char sink[MAXLINE]; long left = content_length;
        while (left > 0) {
            size_t chunk = left < MAXLINE ? (size_t)left : MAXLINE;
            if (readn(connfd, sink, chunk) <= 0) break;
            left -= (long)chunk;
        }
    }
    if (bad_line) { clienterror(connfd,"400","Bad Request","Malformed request line"); return; }
    if (strcasecmp(method, "GET")) {
        clienterror(connfd, "501", "Not Implemented", "Proxy only implements GET"); return; }
    if (strcasecmp(version,"HTTP/1.0") && strcasecmp(version,"HTTP/1.1")) {
        clienterror(connfd,"505","HTTP Version Not Supported","Only HTTP/1.0 and 1.1"); return; }
    if (url[0] == '/') {   /* 相对路径 = 源服务器请求, Proxy Lab 要求 400 */
        clienterror(connfd,"400","Bad Request","Origin-server requests not supported"); return; }
    if (parse_url(url, host, port, path) < 0) {
        clienterror(connfd,"400","Bad Request","Proxy expects absolute URL"); return; }

    /* 3. 连接源服务器（必须在读完请求头之后） */
    if ((serverfd = open_clientfd(host, port)) < 0) {
        clienterror(connfd,"502","Bad Gateway","Could not connect to origin server"); return; }
    /* 4. 转发: 降级为 HTTP/1.0, 补 Host/Connection/Proxy-Connection */
    snprintf(server_buf, sizeof(server_buf),
             "GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent: miniproxy/1.0\r\n"
             "Connection: close\r\nProxy-Connection: close\r\n\r\n", path, host);
    if (writen(serverfd, server_buf, strlen(server_buf)) < 0) { close(serverfd); return; }

    /* 5. 转发响应头, 同时记下 Content-Length */
    content_length = -1; saw_cl = 0;
    while ((n = read_until_crlf(serverfd, buf, MAXLINE)) > 0) {
        if (writen(connfd, buf, (size_t)n) < 0) { close(serverfd); return; }
        if (strncasecmp(buf, "Content-Length:", 15) == 0) {
            content_length = strtol(buf + 15, NULL, 10); saw_cl = 1;
        }
        if (strcmp(buf, "\r\n") == 0) break;
    }
    /* 6. 转发响应体: 有长度就"恰好"读这么多, 否则读到 EOF */
    if (saw_cl && content_length >= 0) {
        char body[MAXLINE]; long left = content_length;
        while (left > 0) {
            size_t chunk = left < MAXLINE ? (size_t)left : MAXLINE;
            ssize_t got = readn(serverfd, body, chunk);
            if (got <= 0) break;
            if (writen(connfd, body, (size_t)got) < 0) break;
            left -= got;
        }
        printf("[proxy] relayed %ld bytes of body (Content-Length exact)\n", content_length - left);
    } else {
        while ((n = read(serverfd, buf, MAXLINE)) > 0)
            if (writen(connfd, buf, (size_t)n) < 0) break;
    }
    close(serverfd);
}
int main(int argc, char **argv) {
    int listenfd, connfd, optval = 1;
    struct addrinfo hints, *listp, *p;
    struct sockaddr_storage clientaddr; socklen_t clientlen;
    if (argc != 2) { fprintf(stderr, "usage: %s <port>\n", argv[0]); exit(1); }
    signal(SIGPIPE, SIG_IGN);                            /* 写已关闭 socket 不要杀死进程 */
    memset(&hints, 0, sizeof(hints));
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG | AI_NUMERICSERV;
    if (getaddrinfo(NULL, argv[1], &hints, &listp) != 0) { perror("getaddrinfo"); exit(1); }
    for (p = listp; p; p = p->ai_next) {
        if ((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) continue;
        setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int));
        if (bind(listenfd, p->ai_addr, p->ai_addrlen) == 0) break;
        close(listenfd);
    }
    freeaddrinfo(listp);
    if (!p || listen(listenfd, LISTENQ) < 0) { perror("listen"); exit(1); }
    printf("[proxy] listening on port %s\n", argv[1]); fflush(stdout);
    while (1) {                                          /* 迭代式: 一次一个客户端 */
        clientlen = sizeof(clientaddr);
        if ((connfd = accept(listenfd, (SA *)&clientaddr, &clientlen)) < 0) continue;
        handle(connfd);
        close(connfd);
    }
    return 0;
}

void serve_dynamic(int fd, char *filename, char *cgiargs) {
    char buf[MAXLINE], *emptylist[] = { NULL };
    sprintf(buf, "HTTP/1.0 200 OK\r\n");        Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Server: Tiny Web Server\r\n"); Rio_writen(fd, buf, strlen(buf));
    if (Fork() == 0) {                           /* 子进程 */
        setenv("QUERY_STRING", cgiargs, 1);      /* 第 3 参数 1 = 覆盖已有值 */
        Dup2(fd, STDOUT_FILENO);                 /* stdout 重定向到客户端连接 */
        Execve(filename, emptylist, environ);    /* 执行 CGI 程序 */
    }
    Wait(NULL);                                  /* 父进程回收子进程，避免僵尸 */
}