FastCGI协议详解及代码实现-菜鸟笔记

FastCGI协议是在CGI协议的基础上发展出来的，如果想了解CGI协议，可以看我另一篇文章：动态web技术(二) --- CGI，FastCGI程序本身监听某个socket然后等待来自web服务器的连接，而不是像CGI程序是由web服务器 fork-exec，所以FastCGI本身是一个服务端程序，而web服务器对它来说则是客户端。

FastCGI程序和web服务器之间通过可靠的流式传输（Unix Domain Socket或TCP）来通信，相对于传统的CGI程序，有环境变量和标准输入输出，而FastCGI程序和web服务器之间则只有一条socket连接来传输数据，所以它把数据分成以下多种消息类型：

#define FCGI_BEGIN_REQUEST       1
#define FCGI_ABORT_REQUEST       2
#define FCGI_END_REQUEST         3
#define FCGI_PARAMS              4
#define FCGI_STDIN               5
#define FCGI_STDOUT              6
#define FCGI_STDERR              7
#define FCGI_DATA                8
#define FCGI_GET_VALUES          9
#define FCGI_GET_VALUES_RESULT  10
#define FCGI_UNKNOWN_TYPE       11
#define FCGI_MAXTYPE (FCGI_UNKNOWN_TYPE)

以上由web服务器向FastCGI程序传输的消息类型有以下几种：

FCGI_BEGIN_REQUEST 表示一个请求的开始，

FCGI_ABORT_REQUEST 表示服务器希望终止一个请求

FCGI_PARAMS 对应于CGI程序的环境变量，php $_SERVER 数组中的数据绝大多数来自于此

FCGI_STDIN 对应CGI程序的标准输入，FastCGI程序从此消息获取 http请求的POST数据

此外 FCGI_DATA 和 FCGI_GET_VALUES 这里不做介绍。

由FastCGI程序返回给web服务器的消息类型有以下几种：

FCGI_STDOUT 对应CGI程序的标准输出，web服务器会把此消息当作html返回给浏览器

FCGI_STDERR 对应CGI程序的标准错误输出， web服务器会把此消息记录到错误日志中

FCGI_END_REQUEST 表示该请求处理完毕

FCGI_UNKNOWN_TYPE FastCGI程序无法解析该消息类型

此外还有 FCGI_GET_VALUES_RESULT 这里不做介绍

web服务器和FastCGI程序每传输一个消息，首先会传输一个8字节固定长度的消息头，这个消息头记录了随后要传输的这个消息的类型，长度等等属性，消息头的结构体如下：

struct FCGI_Header {
    unsigned char version;
    unsigned char type;
    unsigned char requestIdB1;
    unsigned char requestIdB0;
    unsigned char contentLengthB1;
    unsigned char contentLengthB0;
    unsigned char paddingLength;
    unsigned char reserved;
} ;

version 表示fastcgi协议版本

type 表示消息的类型，就是前面提到的多种消息类型之一，如 FCGI_BEGIN_REQUEST、FCGI_PARAMS 等等

requestIdB1 和 requestIdB0 这两个字节组合来表示 requestId (对于每个请求web服务器会分配一个requestId)， requestIdB1 是requestId的高八位，requestIdB0是低八位，所以最终的 requestId = （requestIdB1 << 8） + requestIdB0，因为是两个字节来表示，requestId最大取值为65535，同理 contentLengthB1 和 contentLengthB0 共同来表示消息体的长度，对于超过65535的消息体，可以切割成多个消息体来传输

paddingLength 为了使消息8字节对齐，提高传输效率，可以在消息上添加一些字节数来达到消息对齐的目的，paddingLength 为添加的字节数，这些字节是无用数据，读出来可以直接丢弃。

reserved 保留字段，暂时无用

比如在传输 FCGI_BEGIN_REQUEST 消息之前，首先会传输一个消息头类似如下：

0x0000080001000101 粗体 08 对应 requestIdB0 ，粗体00 对应 requestIdB1 ，所以后续要传输的这个消息的长度是八字节，粗体01指代该消息类型为 FCGI_BEGIN_REQUEST

对于 FCGI_BEGIN_REQUEST 和 FCGI_END_REQUEST 消息类型，fastcgi协议分别定义了一个结构体如下，而对于其他类型的消息体，没有专门结构体与之对应，消息体就是普通的二进制数据。

struct FCGI_BeginRequestBody {
    unsigned char roleB1;
    unsigned char roleB0;
    unsigned char flags;
    unsigned char reserved[5];
} ;

struct  FCGI_EndRequestBody {
    unsigned char appStatusB3;
    unsigned char appStatusB2;
    unsigned char appStatusB1;
    unsigned char appStatusB0;
    unsigned char protocolStatus;
    unsigned char reserved[3];
};

从这个结构体可以知道 FCGI_BEGIN_REQUEST 和 FCGI_END_REQUEST 消息体的长度都是固定的8个字节。

FCGI_BeginRequestBody 的 roleB1 和 roleB0 两个字节组合指代 web服务器希望FastCGI程序充当的角色，目前FastCGI协议仅定义了三种角色：

#define FCGI_RESPONDER  1
#define FCGI_AUTHORIZER 2
#define FCGI_FILTER     3

常见的FastCGI程序基本都是作为 FCGI_RESPONDER （响应器角色），所以roleB1的值总是0， roleB0的值可取1~3三个值，但常见都是1，其他两种角色这里不做讨论。

flags 是一个8位掩码， web服务器可以利用该掩码告知FastCGI程序在处理完一个请求后是否关闭socket连接（最初协议的设计者可能还预留了该掩码的其他作用，只是目前只有这一个作用)

flags & FCGI_KEEP_CONN 的值为1，则FastCGI程序请求结束不关闭连接，为0 则关键连接

其中 FCGI_KEEP_CONN 是一个宏，定义如下：

#define FCGI_KEEP_CONN  1

以下是协议对于响应器角色的解释：

Responder FastCGI应用程序具有与CGI / 1.1程序相同的用途：它接收与HTTP请求相关的所有信息并生成HTTP响应。

以下解释CGI / 1.1的每个元素和响应者角色的消息类型的对应关系：

Responder应用程序通过FCGI_PARAMS从Web服务器接收CGI / 1.1环境变量。
接下来，Responder应用程序通过FCGI_STDIN从Web服务器接收CGI / 1.1 stdin数据。在接收流结束指示之前，应用程序最多从此流接收CONTENT_LENGTH个字节。（仅当HTTP客户端无法提供时，应用程序才会收到少于CONTENT_LENGTH的字节，例如，因为客户端崩溃了。）
响应者应用程序通过FCGI_STDOUT发送CGI / 1.1 标准输出数据到Web服务器，通过FCGI_STDERR发送CGI / 1.1 标准错误数据。应用程序并发地发送这些，而不是一个接一个地发送。应用程序必须等待读完FCGI_PARAMS数据之后才可以写FCGI_STDOUT和FCGI_STDERR，但它不需要等待读完FCGI_STDIN才可以写这两个流。
发送所有stdout和stderr数据后，Responder应用程序将发送FCGI_END_REQUEST记录。应用程序将protocolStatus组件设置为FCGI_REQUEST_COMPLETE，将appStatus组件设置为CGI程序通过退出系统调用返回的状态代码。

处理POST请求的响应方应比较FCGI_STDIN上接收到的字节数和CONTENT_LENGTH，如果两个数不相等，则中止请求。

FCGI_EndRequestBody 中 appStatus是应用级别的状态码。每个角色记录其对appStatus的使用情况，不做深入讨论
所述的protocolStatus 是协议级别的状态码，可能的protocolStatus值是：

#define FCGI_REQUEST_COMPLETE 0
#define FCGI_CANT_MPX_CONN    1
#define FCGI_OVERLOADED       2
#define FCGI_UNKNOWN_ROLE     3

FCGI_REQUEST_COMPLETE：请求的正常结束，典型的应该都是该个值。
FCGI_CANT_MPX_CONN：拒绝新的请求。当Web服务器通过一个连接将并发请求发送到每个连接一次处理一个请求的应用程序时，会发生这种情况。
FCGI_OVERLOADED：拒绝新的请求。当应用程序耗尽某些资源（例如数据库连接）时会发生这种情况。
FCGI_UNKNOWN_ROLE：拒绝新的请求。当Web服务器指定了应用程序未知的角色时，会发生这种情况。

所以，当FastCGI程序从web服务器读取数据时，总是先读取一个8字节的消息头，然后得到消息的类型和长度信息，然后再读取消息体，一种消息过长可以切割成多个消息传输，当一个消息头里的 contentLength 为0（也即 contentLengthB1和contentLengthB0 的值都为0）时，则表明这种消息传输完毕，然后我们可以把之前读到的这种类型的多个消息合并得到最终完整的消息。反之，当我们要从FastCGI程序向web服务器返回数据时，总是每发送一个8字节消息头，紧接发送一次消息体，循环往复，直到最后发送 FCGI_END_REQUEST类型的消息头和消息体结束请求。

总结一下web服务器和FastCGi程序之间大概的消息发送流程：

1、web服务器向FastCGI程序发送一个 8 字节 type=FCGI_BEGIN_REQUEST的消息头和一个8字节 FCGI_BeginRequestBody 结构的消息体，标志一个新请求的开始

2、web服务器向FastCGI程序发送一个 8 字节 type=FCGI_PARAMS 的消息头和一个消息头中指定长度的FCGI_PARAMS类型消息体

3、根据FCGI_PARAMS消息的长度可能重复步骤 2 多次，最终发送一个 8 字节 type=FCGI_PARAMS 并且 contentLengthB1 和 contentLengthB0 都为 0 的消息头标志 FCGI_PARAMS 消息发送结束

4、以和步骤2、3相同的方式发送 FCGI_STDIN 消息

5、FastCGI程序处理完请求后以和步骤2、3相同的方式发送 FCGI_STDOUT消息和 FCGI_STDERR 消息返回给服务器

6、FastCGI程序发送一个 type= FCGI_END_REQUEST 的消息头和一个8字节 FCGI_EndRequestBody 结构的消息体，标志此次请求结束

FastCGI协议的完整规范请查看： https://fastcgi-archives.github.io/FastCGI_Specification.html

下面用c 编写一个简单的实现fastcgi协议的demo，这个demo主要是用来向大家更直观的展示FastCGI协议，错误处理和内存泄漏检测都不到位，专业的协议实现可以看官方提供的 Fastcgi Developer‘s kit ： https://fastcgi-archives.github.io/FastCGI_Developers_Kit_FastCGI.html ，其中封装的c库在 libfcgi 文件中。

完整代码托管在github上： https://github.com/zhyee/fastcgi-demo

#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>


#define HEAD_LEN                8  //消息头长度固定为8个字节
#define BUFLEN                  4096
#define FCGI_VERSION_1           1  //版本号




// 消息类型
enum fcgi_request_type {
    FCGI_BEGIN_REQUEST      = 1,
    FCGI_ABORT_REQUEST      = 2,
    FCGI_END_REQUEST        = 3,
    FCGI_PARAMS             = 4,
    FCGI_STDIN              = 5,
    FCGI_STDOUT             = 6,
    FCGI_STDERR             = 7,
    FCGI_DATA               = 8,
    FCGI_GET_VALUES         = 9,
    FCGI_GET_VALUES_RESULT  = 10,
    FCGI_UNKOWN_TYPE        = 11
};

// 服务器希望fastcgi程序充当的角色, 这里只讨论 FCGI_RESPONDER 响应器角色
enum fcgi_role {
    FCGI_RESPONDER      = 1,
    FCGI_AUTHORIZER     = 2,
    FCGI_FILTER         = 3
};

//消息头
struct fcgi_header {
    unsigned char version;
    unsigned char type;
    unsigned char requestIdB1;
    unsigned char requestIdB0;
    unsigned char contentLengthB1;
    unsigned char contentLengthB0;
    unsigned char paddingLength;
    unsigned char reserved;
};

//请求开始发送的消息体
struct FCGI_BeginRequestBody {
    unsigned char roleB1;
    unsigned char roleB0;
    unsigned char flags;
    unsigned char reserved[5];
};

//请求结束发送的消息体
struct FCGI_EndRequestBody {
    unsigned char appStatusB3;
    unsigned char appStatusB2;
    unsigned char appStatusB1;
    unsigned char appStatusB0;
    unsigned char protocolStatus;
    unsigned char reserved[3];
};

// protocolStatus
enum protocolStatus {
    FCGI_REQUEST_COMPLETE = 0,
    FCGI_CANT_MPX_CONN = 1,
    FCGI_OVERLOADED = 2,
    FCGI_UNKNOWN_ROLE = 3
};


// 打印错误并退出
void haltError(char *type, int errnum)
{
    fprintf(stderr, "%s: %s\n", type, strerror(errnum));
    exit(EXIT_FAILURE);
}

// 存储键值对的结构体
struct paramNameValue {
    char **pname;
    char **pvalue;
    int maxLen;
    int curLen;
};




// 初始化一个键值结构体
void init_paramNV(struct paramNameValue *nv)
{
    nv->maxLen = 16;
    nv->curLen = 0;
    nv->pname = (char **)malloc(nv->maxLen * sizeof(char *));
    nv->pvalue = (char **)malloc(nv->maxLen * sizeof(char *));
}

// 扩充一个结键值构体的容量为之前的两倍
void extend_paramNV(struct paramNameValue *nv)
{
    nv->maxLen *= 2;
    nv->pname = realloc(nv->pname, nv->maxLen * sizeof(char *));
    nv->pvalue = realloc(nv->pvalue, nv->maxLen * sizeof(char *));
}

// 释放一个键值结构体
void free_paramNV(struct paramNameValue *nv)
{
    int i;

    for(i = 0; i < nv->curLen; i++)
    {
        free(nv->pname[i]);
        free(nv->pvalue[i]);
    }
    free(nv->pname);
    free(nv->pvalue);
}


// 获取指定 paramName 的值
char *getParamvalue(struct paramNameValue *nv, char *paramName)
{

    int i;

    for(i = 0; i < nv->curLen; i++)
    {
        if (strncmp(paramName, nv->pname[i], strlen(paramName)) == 0)
        {
            return nv->pvalue[i];
        }
    }

    return NULL;
}


int main(){

    int servfd, connfd;
    int ret, i;
    struct sockaddr_in servaddr, cliaddr;
    socklen_t slen, clen;

    struct fcgi_header header, headerBuf;
    struct FCGI_BeginRequestBody brBody;
    struct paramNameValue  paramNV;
    struct FCGI_EndRequestBody erBody;

    ssize_t rdlen;
    int requestId, contentLen;
    unsigned char paddingLen;
    int paramNameLen, paramValueLen;

    char buf[BUFLEN];

    unsigned char c;
    unsigned char lenbuf[3];
    char *paramName, *paramValue;

    char *htmlHead, *htmlBody;


    /*socket bind listen*/
    servfd = socket(AF_INET, SOCK_STREAM, 0);

    if (servfd == -1)
    {
        haltError("socket", errno);
    }

    slen = clen = sizeof(struct sockaddr_in);


    bzero(&servaddr, slen);

    //这里让 fastcgi程序监听 127.0.0.1:9000  和 php-fpm 监听的地址相同， 方便我们用 nginx 来测试
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(9000);
    servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    ret = bind(servfd, (struct sockaddr *)&servaddr, slen);

    if (ret == -1)
    {
        haltError("bind", errno);
    }

    ret = listen(servfd, 16);

    if (ret == -1)
    {
        haltError("listen", errno);
    }


    while (1)
    {
        bzero(&cliaddr, clen);
        connfd = accept(servfd, (struct sockaddr *)&cliaddr, &clen);
        if (connfd == -1)
        {
            haltError("accept", errno);
            break;
        }

        fcntl(connfd, F_SETFL, O_NONBLOCK); // 设置socket为非阻塞

        init_paramNV(&paramNV);

        while (1) {

            //读取消息头
            bzero(&header, HEAD_LEN);
            rdlen = read(connfd, &header, HEAD_LEN);

            if (rdlen == -1)
            {
                // 无数据可读
                if (errno == EAGAIN)
                {
                    break;
                }
                else
                {
                    haltError("read", errno);
                }
            }

            if (rdlen == 0)
            {
                break; //消息读取结束
            }

            headerBuf = header;

            requestId = (header.requestIdB1 << 8) + header.requestIdB0;
            contentLen = (header.contentLengthB1 << 8) + header.contentLengthB0;
            paddingLen = header.paddingLength;


            printf("version = %d, type = %d, requestId = %d, contentLen = %d, paddingLength = %d\n",
                   header.version, header.type, requestId, contentLen, paddingLen);

            printf("%lx\n", header);


            switch (header.type) {

                case FCGI_BEGIN_REQUEST:
                    printf("******************************* begin request *******************************\n");

                    //读取开始请求的请求体
                    bzero(&brBody, sizeof(brBody));
                    read(connfd, &brBody, sizeof(brBody));

                    printf("role = %d, flags = %d\n", (brBody.roleB1 << 8) + brBody.roleB0, brBody.flags);

                    break;

                case FCGI_PARAMS:
                    printf("begin read params...\n");

                    // 消息头中的contentLen = 0 表明此类消息已发送完毕
                    if (contentLen == 0)
                    {
                        printf("read params end...\n");
                    }

                    //循环读取键值对
                    while (contentLen > 0)
                    {
                        /*
                        FCGI_PARAMS 以键值对的方式传送，键和值之间没有'=',每个键值对之前会分别用1或4个字节来标识键和值的长度 例如：
                        \x0B\x02SERVER_PORT80\x0B\x0ESERVER_ADDR199.170.183.42
                         上面的长度是用十六进制表示的  \x0B = 11  正好为SERVER_PORT的长度， \x02 = 2 为80的长度
                        */

                        // 获取paramName的长度
                        rdlen = read(connfd, &c, 1);  //先读取一个字节，这个字节标识 paramName 的长度
                        contentLen -= rdlen;

                        if ((c & 0x80) != 0)  //如果 c 的值大于 128，则该 paramName 的长度用四个字节表示
                        {
                            rdlen = read(connfd, lenbuf, 3);
                            contentLen -= rdlen;
                            paramNameLen = ((c & 0x7f) << 24) + (lenbuf[0] << 16) + (lenbuf[1] << 8) + lenbuf[2];
                        } else
                        {
                            paramNameLen = c;
                        }

                        // 同样的方式获取paramValue的长度
                        rdlen = read(connfd, &c, 1);
                        contentLen -= rdlen;
                        if ((c & 0x80) != 0)
                        {
                            rdlen = read(connfd, lenbuf, 3);
                            contentLen -= rdlen;
                            paramValueLen = ((c & 0x7f) << 24) + (lenbuf[0] << 16) + (lenbuf[1] << 8) + lenbuf[2];
                        }
                        else
                        {
                            paramValueLen = c;
                        }

                        //读取paramName
                        paramName = (char *)calloc(paramNameLen + 1, sizeof(char));
                        rdlen = read(connfd, paramName, paramNameLen);
                        contentLen -= rdlen;

                        //读取paramValue
                        paramValue = (char *)calloc(paramValueLen + 1, sizeof(char));
                        rdlen = read(connfd, paramValue, paramValueLen);
                        contentLen -= rdlen;

                        printf("read param: %s=%s\n", paramName, paramValue);

                        if (paramNV.curLen == paramNV.maxLen)
                        {
                            // 如果键值结构体已满则把容量扩充一倍
                            extend_paramNV(&paramNV);
                        }

                        paramNV.pname[paramNV.curLen] = paramName;
                        paramNV.pvalue[paramNV.curLen] = paramValue;
                        paramNV.curLen++;

                    }

                    if (paddingLen > 0)
                    {
                        rdlen = read(connfd, buf, paddingLen);
                        contentLen -= rdlen;
                    }

                    break;

                case FCGI_STDIN:
                    printf("begin read post...\n");

                    if(contentLen == 0)
                    {
                        printf("read post end....\n");
                    }

                    if (contentLen > 0)
                    {
                        while (contentLen > 0)
                        {
                            if (contentLen > BUFLEN)
                            {
                                rdlen = read(connfd, buf, BUFLEN);
                            }
                            else
                            {
                                rdlen = read(connfd, buf, contentLen);
                            }

                            contentLen -= rdlen;
                            fwrite(buf, sizeof(char), rdlen, stdout);
                        }
                        printf("\n");
                    }

                    if (paddingLen > 0)
                    {
                        rdlen = read(connfd, buf, paddingLen);
                        contentLen -= rdlen;
                    }

                    break;

                case FCGI_DATA:
                    printf("begin read data....\n");

                    if (contentLen > 0)
                    {
                        while (contentLen > 0)
                        {
                            if (contentLen > BUFLEN)
                            {
                                rdlen = read(connfd, buf, BUFLEN);
                            }
                            else
                            {
                                rdlen = read(connfd, buf, contentLen);
                            }

                            contentLen -= rdlen;
                            fwrite(buf, sizeof(char), rdlen, stdout);
                        }
                        printf("\n");
                    }

                    if (paddingLen > 0)
                    {
                        rdlen = read(connfd, buf, paddingLen);
                        contentLen -= rdlen;
                    }

                    break;

            }
        }


        /* 以上是从web服务器读取数据，下面向web服务器返回数据 */


        headerBuf.version = FCGI_VERSION_1;
        headerBuf.type = FCGI_STDOUT;

        htmlHead = "Content-type: text/html\r\n\r\n";  //响应头
        htmlBody = getParamValue(&paramNV, "SCRIPT_FILENAME");  // 把请求文件路径作为响应体返回

        printf("html: %s%s\n",htmlHead, htmlBody);

        contentLen = strlen(htmlHead) + strlen(htmlBody);

        headerBuf.contentLengthB1 = (contentLen >> 8) & 0xff;
        headerBuf.contentLengthB0 = contentLen & 0xff;
        headerBuf.paddingLength = (contentLen % 8) > 0 ? 8 - (contentLen % 8) : 0;  // 让数据 8 字节对齐


        write(connfd, &headerBuf, HEAD_LEN);
        write(connfd, htmlHead, strlen(htmlHead));
        write(connfd, htmlBody, strlen(htmlBody));

        if (headerBuf.paddingLength > 0)
        {
            write(connfd, buf, headerBuf.paddingLength);  //填充数据随便写什么，数据会被服务器忽略
        }

        free_paramNV(&paramNV);

        //回写一个空的 FCGI_STDOUT 表明 该类型消息已发送结束
        headerBuf.type = FCGI_STDOUT;
        headerBuf.contentLengthB1 = 0;
        headerBuf.contentLengthB0 = 0;
        headerBuf.paddingLength = 0;
        write(connfd, &headerBuf, HEAD_LEN);


        // 发送结束请求消息头
        headerBuf.type = FCGI_END_REQUEST;
        headerBuf.contentLengthB1 = 0;
        headerBuf.contentLengthB0 = 8;
        headerBuf.paddingLength = 0;

        bzero(&erBody, sizeof(erBody));
        erBody.protocolStatus = FCGI_REQUEST_COMPLETE;

        write(connfd, &headerBuf, HEAD_LEN);
        write(connfd, &erBody, sizeof(erBody));

        close(connfd);

        printf("******************************* end request *******************************\n");
    }

    close(servfd);

    return 0;
}

运行结果：

先运行FastCGI程序，为了方便测试程序监听和php-fpm相同的端口，所以启程序前先关闭php-fpm

[root@localhost fastcgi-demo]# make
gcc fastcgi.c -o fastcgi
[root@localhost fastcgi-demo]# ls
fastcgi  fastcgi.c  Makefile  README.md
[root@localhost fastcgi-demo]# ./fastcgi

然后请求一个php页面：

[root@localhost hello]# curl -i '127.0.0.1/test.php?user=Tom&password=123456' -d 'gender=male&weight=60kg'
HTTP/1.1 200 OK
Server: nginx/1.11.3
Date: Wed, 27 Dec 2017 12:16:38 GMT
Content-Type: text/html
Transfer-Encoding: chunked
Connection: keep-alive

/usr/share/nginx/html/test.php[root@localhost hello]#

然后可以看到FastCGI程序的打印结果：

[root@localhost fastcgi-demo]# ./fastcgi
version = 1, type = 1, requestId = 1, contentLen = 8, paddingLength = 0
80001000101
******************************* begin request *******************************
role = 1, flags = 0
version = 1, type = 4, requestId = 1, contentLen = 717, paddingLength = 3
3cd0201000401
begin read params...
read param: SCRIPT_FILENAME=/usr/share/nginx/html/test.php
read param: QUERY_STRING=user=Tom&password=123456
read param: REQUEST_METHOD=POST
read param: CONTENT_TYPE=application/x-www-form-urlencoded
read param: CONTENT_LENGTH=23
read param: SCRIPT_NAME=/test.php
read param: REQUEST_URI=/test.php?user=Tom&password=123456
read param: DOCUMENT_URI=/test.php
read param: DOCUMENT_ROOT=/usr/share/nginx/html
read param: SERVER_PROTOCOL=HTTP/1.1
read param: GATEWAY_INTERFACE=CGI/1.1
read param: SERVER_SOFTWARE=nginx/1.11.3
read param: REMOTE_ADDR=127.0.0.1
read param: REMOTE_PORT=56896
read param: SERVER_ADDR=127.0.0.1
read param: SERVER_PORT=80
read param: SERVER_NAME=_
read param: REDIRECT_STATUS=200
read param: HTTP_USER_AGENT=curl/7.19.7 (x86_64-redhat-linux-gnu) libcurl/7.19.7 NSS/3.27.1 zlib/1.2.3 libidn/1.18 libssh2/1.4.2
read param: HTTP_HOST=127.0.0.1
read param: HTTP_ACCEPT=*/*
read param: HTTP_CONTENT_LENGTH=23
read param: HTTP_CONTENT_TYPE=application/x-www-form-urlencoded
version = 1, type = 4, requestId = 1, contentLen = 0, paddingLength = 0
1000401
begin read params...
read params end...
version = 1, type = 5, requestId = 1, contentLen = 23, paddingLength = 1
1170001000501
begin read post...
gender=male&weight=60kg
version = 1, type = 5, requestId = 1, contentLen = 0, paddingLength = 0
1000501
begin read post...
read post end....
html: Content-type: text/html

/usr/share/nginx/html/test.php
******************************* end request *******************************

写在后面：大家都知道 php-fpm 实现了fastcgi协议，但php-fpm所做的事远不止于此，他还负责进程管理（fastcgi进程数控制，重启down调的fastcgi子进程等等），初始化 php 运行环境，以及执行 php 脚本，php-fpm的实现原理值得另写一篇文章来介绍它。

FastCGI协议详解及代码实现

相关推荐

菜鸟笔记

热门教程