TinyHTTPd 源码分析

        void accept_request(int client)
        {
            char buf[1024];
            int numchars;
            char method[255];           //保存请求行中的请求方法 GET or POST
            char url[255];   //请求行的 url 字段
            char path[512];  //请求行中文件在服务器上的路径
            size_t i, j;
            struct stat st;
            int cgi = 0;      /* becomes true if server decides this is a CGI
                               * program */
            char *query_string = NULL; //get 请求？之后的查询参数

            numchars = get_line(client, buf, sizeof(buf));//获取请求行
            i = 0; j = 0;
            /* 处理请求行 */
            /* 请求方法 */
            while (!ISspace(buf[j]) && (i < sizeof(method) - 1))
            {
                method[i] = buf[j];//根据 http 请求报文格式，这里得到的是请求方法
                i++; j++;
            }
            method[i] = '\0';
            /* 省略 */
            /* URL 字段 */
            while (!ISspace(buf[j]) && (i < sizeof(url) - 1) && (j < sizeof(buf)))
            {
                url[i] = buf[j];//获取的是 URL（互联网标准资源的地址）
                i++; j++;
            }
            url[i] = '\0';

            if (strcasecmp(method, "GET") == 0)
            {
                query_string = url;//请求信息
                while ((*query_string != '?') && (*query_string != '\0'))//截取'?'前的字符
                    query_string++;//问号前面是路径，后面是参数
                if (*query_string == '?')//有'?'，表明动态请求
                {
                    cgi = 1;
                    *query_string = '\0';
                    query_string++;
                }
            }
            /* 根据 url 拼接 url 在服务器上的路径 */
            sprintf(path, "htdocs%s", url);
            if (path[strlen(path) - 1] == '/')//如果 url 是目录(/)，则加上 index.html
                strcat(path, "index.html");//

            /* 查找 path 指向的文件 */
            if (stat(path, &st) == -1) {//执行失败，文件未找到
                /*丢弃所有 headers 的信息*/
                while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */
                    numchars = get_line(client, buf, sizeof(buf));//从客户端读取数据进 buf
                not_found(client);//回应客户端找不到
            }
            else
            {
                /*如果 path 是个目录，则默认使用该目录下 index.html 文件*/
                if ((st.st_mode & S_IFMT) == S_IFDIR)
                    strcat(path, "/index.html");
                /* 如果 path 是可执行文件，设置 cgi 标识 */
                if ((st.st_mode & S_IXUSR) ||
                    (st.st_mode & S_IXGRP) ||
                    (st.st_mode & S_IXOTH)    )
                    cgi = 1;
                if (!cgi)//静态页面请求
                    serve_file(client, path);//直接返回文件信息给客户端，静态页面返回
                else//动态页面请求
                    execute_cgi(client, path, method, query_string);//执行 cgi 脚本
            }

            close(client);//关闭客户端套接字
        }

        int get_line(int sock, char *buf, int size)
        {
            int i = 0;
            char c = '\0';
            int n;

            /* http 请求报文每行都是\r\n 结尾 */
            while ((i < size - 1) && (c != '\n'))
            {
                n = recv(sock, &c, 1, 0);

                if (n > 0)
                {
                    if (c == '\r')//如果是回车符，继续读取
                    {
                        /* MSG_PEEK 探测下一个字符是不是\n */
                        n = recv(sock, &c, 1, MSG_PEEK);

                        if ((n > 0) && (c == '\n'))//如果是回车换行符说明读完一行
                            recv(sock, &c, 1, 0);
                        else
                            c = '\n';//换行替换回车，当作一行返回
                    }
                    buf[i] = c;
                    i++;
                }
                else
                    c = '\n';
            }
            buf[i] = '\0'; //返回一行

            return(i);//返回读到的字符个数(包括'\0')
        }

void execute_cgi(int client, const char *path, const char *method, const char *query_string)
{
    char buf[1024];
    int cgi_output[2];
    int cgi_input[2];
    pid_t pid;
    int status;
    int i;
    char c;
    int numchars = 1;
    int content_length = -1;

    buf[0] = 'A'; buf[1] = '\0';
    if (strcasecmp(method, "GET") == 0)//GET 方法：一般用于获取/查询资源信息
        while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers 读取并丢弃 HTTP 请求 */
            numchars = get_line(client, buf, sizeof(buf));
    else    /* POST 一般用于更新资源信息*/
    {
        numchars = get_line(client, buf, sizeof(buf));

        //获取 HTTP 消息实体的传输长度
        while ((numchars > 0) && strcmp("\n", buf))//不为空且不为换行符
        {
            buf[15] = '\0';
            if (strcasecmp(buf, "Content-Length:") == 0)//是否为 Content-Length 字段
                content_length = atoi(&(buf[16]));//Content-Length 用于描述 HTTP 消息实体的传输长度
            numchars = get_line(client, buf, sizeof(buf));
        }
        if (content_length == -1) {
            bad_request(client);//请求的页面数据为空，没有数据，就是我们打开网页经常出现空白页面
            return;
        }
    }

    sprintf(buf, "HTTP/1.0 200 OK\r\n");//
    send(client, buf, strlen(buf), 0);

    if (pipe(cgi_output) < 0) {
        cannot_execute(client);//管道建立失败，打印出错信息
        return;
    }
    if (pipe(cgi_input) < 0) {
        cannot_execute(client);
        return;
    }

    if ((pid = fork()) < 0) {
        cannot_execute(client);
        return;
    }
    //实现进程间的管道通信机制
    /*子进程继承了父进程的 pipe，然后通过关闭子进程 output 管道的输出端，input 管道的写入端；
      关闭父进程 output 管道的写入端，input 管道的输出端*/
    //子进程，
    if (pid == 0)  /* child: CGI script */
    {
        char meth_env[255];
        char query_env[255];
        char length_env[255];

        //复制文件句柄，重定向进程的标准输入输出
        //dup2 的第一个参数描述符关闭
        dup2(cgi_output[1], 1);//标准输出重定向到 output 管道的写入端
        dup2(cgi_input[0], 0);//标准输入重定向到 input 管道的读取端
        close(cgi_output[0]);//关闭 output 管道的写入端
        close(cgi_input[1]);//关闭输出端
        sprintf(meth_env, "REQUEST_METHOD=%s", method);
        putenv(meth_env);
        if (strcasecmp(method, "GET") == 0) {//GET
            /*设置 query_string 的环境变量*/
            sprintf(query_env, "QUERY_STRING=%s", query_string);
            putenv(query_env);
        }
        else {   /* POST */
            /*设置 content_length 的环境变量*/
            sprintf(length_env, "CONTENT_LENGTH=%d", content_length);
            putenv(length_env);
        }
        execl(path, path, NULL);//exec 函数簇，执行 CGI 脚本，获取 cgi 的标准输出作为相应内容发送给客户端
        //通过 dup2 重定向，标准输出内容进入管道 output 的输入端

        exit(0);//子进程退出
    }
    else {    /* parent */
        close(cgi_output[1]);//关闭管道的一端，这样可以建立父子进程间的管道通信
        close(cgi_input[0]);
        /*通过关闭对应管道的通道，然后重定向子进程的管道某端，这样就在父子进程之间构建一条单双工通道
          如果不重定向，将是一条典型的全双工管道通信机制
        */
        if (strcasecmp(method, "POST") == 0)//POST 方式，将指定好的传输长度字符发送
            /*接收 POST 过来的数据*/
            for (i = 0; i < content_length; i++) {
                recv(client, &c, 1, 0);//从客户端接收单个字符
                write(cgi_input[1], &c, 1);//写入 input，然后重定向到了标准输入
                //数据传送过程：input[1](父进程) ——> input[0](子进程)[执行 cgi 函数] ——> STDIN ——> STDOUT
                // ——> output[1](子进程) ——> output[0](父进程)[将结果发送给客户端]

            }
        while (read(cgi_output[0], &c, 1) > 0)//读取 output 的管道输出到客户端，output 输出端为 cgi 脚本执行后的内容
            send(client, &c, 1, 0);//即将 cgi 执行结果发送给客户端，即 send 到浏览器，如果不是 POST 则只有这一处理

        close(cgi_output[0]);//关闭剩下的管道端，子进程在执行 dup2 之后，就已经关闭了管道一端通道
        close(cgi_input[1]);
        waitpid(pid, &status, 0);//等待子进程终止
    }
}

      #!/bin/sh
      echo "Content-type:text/html"
      echo
      echo '<html><head><meta charset="utf-8"><title>MyTitle</title></head><body bgcolor="' $0 '">'
      #$0 这个参数传递的听怪异的，主要是 execl 函数没写好，懒得改了
      echo "</body></html>"

chmod +x tinyhttpd-0.1.0/htdocs/test.sh

#include <stdio.h>
int main(int argc, char *argv[])
{
    printf("hahahaha\rxixixi");
    return 0;
}

cd ~/projects/org-notes/org/source-code-analysis/tinyhttpd-analysis/
make

./printf-ret

#include <stdio.h>
int main(int argc, char *argv[])
{
    printf("hahaha\nxixi\n");
    return 0;
}

make

./printf-newline