boa源码分析(3)--代码结构

http://blog.csdn.net/jemofh159/article/details/7913120

1  boa.c

主程序:

----1)  关闭文件
for(i=3;i<=1024;i++)
      close(i);

----2)  设置进程权限掩码
umask(~0600);    rw- --- ---;

----3)  打开黑洞,并将标准输入输出指向它,
open("/dev/null", 0);
dup2(devnullfd, STDIN_FILENO);
dup2(devnullfd, STDOUT_FILENO);

 ----4)  更新时间戳，日志要用到。
time(¤t_time);

----5）解析命令行
-f
server_root = strdup(optaarg);
-r
chdir(optarg);
chroot(optarg);
chdir("/");
-d
do_fork=0;

----6）//确保服务器根目录是有效的。
fixup_server_root();

----7）//读取配置文件通过yyparse 确保必要的变量设置正确。
read_config_files();

----8）//打开access log,error log, [cgi log] ;并设置 close-on-exec为真，即在exec调用后，关闭文件描述符。
open_logs();

----9）//创建TCP socket，设置为nonblock ,同样设置 close-on-exec为真,这样，EXEC调用时，cgi不能向它写入。。。
server_s = create_server_socket();    //打开了地址复用功能 详见 unix网络编程。

---10）//指定各信号的handle
init_signals();

---11）//设置用户ID和进程组ID。
drop_privs();//降 特权

---12) Set up the environment variables that are common to all CGI scripts
 create_common_env();

---13)  fork子进程，父进程退出。之后子进程成为守护进程
if(do_fork)   switch(fork())

---14) 得到PID，用于产生独一无二的临时文件名或路径。
int pid = getpid();

---15)  更新时间戳，然后进入主循环。
timestamp();
select_loop(server_s)
{
  1）清空，block_read_fdset、block_write_fdset;
  2)设置server_s和请求超时时间。
  3)进入while(1)
  {
     1)   处理sighup 、  sigchld 、 sigalrm、 sigterm等信号。
      2）重设max_fd = -1;
     3)   将合适的request从block链表里移到ready链表里。
           if(reques_block)     fdset_update(); //

     4)  process_requests(server_s);

     5)  if (!sigterm_flag && total_connections < (max_connections - 10))          BOA_FD_SET(server_s, &block_read_fdset); /* server always set */

    6)   reset  timeout

     7)   select
调
用，select(max_fd + 1, &block_read_fdset, &block_write_fdset, NULL, (request_ready || request_block ? &req_timeout : NULL))

    8）更新当前时间，time(&curent_time);
    9)  if (FD_ISSET(server_s, &block_read_fdset))   pending_requests = 1;

  }

}

 一、先来看看 fdset_update()

boa里边有三个请求链表

request *request_ready = NULL;  /* ready list head */
request *request_block = NULL;   /* blocked list head */
request *request_free = NULL;      /* free list head */

struct request {                /* pending requests */
    int fd;                     /* client's socket fd */
    int status;                 /* see #defines.h */
    time_t time_last;           /* time of last succ. op. */
    char *pathname;             /* pathname of requested file */
    int simple;                 /* simple request? */
    int keepalive;              /* keepalive status */
    int kacount;                /* keepalive count */

    int data_fd;                /* fd of data */
    unsigned long filesize;     /* filesize */
    unsigned long filepos;      /* position in file */
    char *data_mem;             /* mmapped/malloced char array */
    int method;                 /* M_GET, M_POST, etc. */

    char *logline;              /* line to log file */

    char *header_line;          /* beginning of un or incompletely processed header line */
    char *header_end;           /* last known end of header, or end of processed data */
    int parse_pos;              /* how much have we parsed */
    int client_stream_pos;      /* how much have we read... */

    int buffer_start;           /* where the buffer starts */
    int buffer_end;             /* where the buffer ends */

    char *http_version;         /* HTTP/?.? of req */
    int response_status;        /* R_NOT_FOUND etc. */

    char *if_modified_since;    /* If-Modified-Since */
    time_t last_modified;       /* Last-modified: */

    char local_ip_addr[NI_MAXHOST]; /* for virtualhost */

    /* CGI vars */

    int remote_port;            /* could be used for ident */

    char remote_ip_addr[NI_MAXHOST]; /* after inet_ntoa */

    int is_cgi;                 /* true if CGI/NPH */
    int cgi_status;
    int cgi_env_index;          /* index into array */

    /* Agent and referer for logfiles */
    char *header_user_agent;
    char *header_referer;

    int post_data_fd;           /* fd for post data tmpfile */

    char *path_info;            /* env variable */
    char *path_translated;      /* env variable */
    char *script_name;          /* env variable */
    char *query_string;         /* env variable */
    char *content_type;         /* env variable */
    char *content_length;       /* env variable */

    struct mmap_entry *mmap_entry_var;

    struct request *next;       /* next */
    struct request *prev;       /* previous */

    /* everything below this line is kept regardless */
    char buffer[BUFFER_SIZE + 1]; /* generic I/O buffer */
    char request_uri[MAX_HEADER_LENGTH + 1]; /* uri */
    char client_stream[CLIENT_STREAM_SIZE]; /* data from client - fit or be hosed */
    char *cgi_env[CGI_ENV_MAX + 4];             /* CGI environment */

#ifdef ACCEPT_ON
    char accept[MAX_ACCEPT_LENGTH]; /* Accept: fields */
#endif
};

typedef struct request request;

 

static void fdset_update(void)
{
    request *current, *next;

    for (current = request_block; current; current = next)
    {
        time_t time_since = current_time - current->time_last;
        next = current->next;

        /* hmm, what if we are in "the middle" of a request and not
         * just waiting for a new one... perhaps check to see if anything
         * has been read via header position, etc... */
        if (current->kacount < ka_max && /* we *are* in a keepalive */
        (time_since >= ka_timeout) && /* ka timeout */
        !current->logline) /* haven't read anything yet */
            current->status = DEAD; /* connection keepalive timed out */
        else if (time_since > REQUEST_TIMEOUT)
        {
            log_error_doc(current);
            fputs("connection timed out\n", stderr);
            current->status = DEAD;
        }
        if (current->buffer_end && current->status < DEAD)
        {
            if (FD_ISSET(current->fd, &block_write_fdset))
                ready_request(current);
            else
            {
                BOA_FD_SET(current->fd, &block_write_fdset);
            }
        } else
        {
            switch (current->status)
            {
            case WRITE:
            case PIPE_WRITE:
                if (FD_ISSET(current->fd, &block_write_fdset))
                    ready_request(current);
                else
                {
                    BOA_FD_SET(current->fd, &block_write_fdset);
                }
                break;
            case BODY_WRITE:
                if (FD_ISSET(current->post_data_fd, &block_write_fdset))
                    ready_request(current);
                else
                {
                    BOA_FD_SET(current->post_data_fd, &block_write_fdset);
                }
                break;
            case PIPE_READ:
                if (FD_ISSET(current->data_fd, &block_read_fdset))
                    ready_request(current);
                else
                {
                    BOA_FD_SET(current->data_fd, &block_read_fdset);
                }
                break;
            case DONE:
                if (FD_ISSET(current->fd, &block_write_fdset))
                    ready_request(current);
                else
                {
                    BOA_FD_SET(current->fd, &block_write_fdset);
                }
                break;
            case DEAD:
                ready_request(current);
                break;
            default:
                if (FD_ISSET(current->fd, &block_read_fdset))
                    ready_request(current);
                else
                {
                    BOA_FD_SET(current->fd, &block_read_fdset);
                }
                break;
            }
        }
        current = next;
    }
}

for循环里面，

首先，获取time_since为距离上次成功操作经历的时间。

如果请求出于keepalive中，time_since已经大于ka_timeout（配置文件里可以配置），而且还没有读取到任何东西，那么request的status变为DEAD。

如果time_since大于REQUEST_TIMEOUT（60），那么status变为DEAD。

如果缓冲区有数据，而且status小于DEAD：

        如果不在block_write_fdset里，那么放到block_write_fdset里。

        如果fd已经在block_write_fdset里，调用ready_request，将request从block队列里转移到ready队列里，同时清除block_write_fdset里的标志

ready_request函数的功能是根据status，从fdset中清除对应fd。

其他情况：

        状态为WRITE，PIPE_WRITE，DONE的请求，如果没有那就放到block_write_fdset里，如果已经在了就调用ready_request。

        状态为BODY_WRITE，将request的post_data_fd做以上处理。post_data_fd注释为/* fd for post data tmpfile */，应该是客户端POST方法时的临时文件        

        状态为PIPE_READ，将request的data_fd做类似处理，不过检查的是block_read_fdset。

        状态为DEAD，直接调用ready_request。

        其他的，检查fd是否在block_read_fdset，并作相应处理。

 

 二、再看看process_erquests函数。

void process_requests(int server_s)
{
    int retval = 0;
    request *current, *trailer;

    if (pending_requests) {
        get_request(server_s);
#ifdef ORIGINAL_BEHAVIOR
        pending_requests = 0;
#endif
    }

    current = request_ready;

    while (current) {
        time(¤t_time);
        if (current->buffer_end && /* there is data in the buffer */
            current->status != DEAD && current->status != DONE) {
            retval = req_flush(current);
            /*
             * retval can be -2=error, -1=blocked, or bytes left
             */
            if (retval == -2) { /* error */
                current->status = DEAD;
                retval = 0;
            } else if (retval >= 0) {
                /* notice the >= which is different from below?
                   Here, we may just be flushing headers.
                   We don't want to return 0 because we are not DONE
                   or DEAD */

                retval = 1;
            }
        } else {
            switch (current->status) {
            case READ_HEADER:
            case ONE_CR:
            case ONE_LF:
            case TWO_CR:
                retval = read_header(current);
                break;
            case BODY_READ:
                retval = read_body(current);
                break;
            case BODY_WRITE:
                retval = write_body(current);
                break;
            case WRITE:
                retval = process_get(current);
                break;
            case PIPE_READ:
                retval = read_from_pipe(current);
                break;
            case PIPE_WRITE:
                retval = write_from_pipe(current);
                break;
            case DONE:
                /* a non-status that will terminate the request */
                retval = req_flush(current);
                /*
                 * retval can be -2=error, -1=blocked, or bytes left
                 */
                if (retval == -2) { /* error */
                    current->status = DEAD;
                    retval = 0;
                } else if (retval > 0) {
                    retval = 1;
                }
                break;
            case DEAD:
                retval = 0;
                current->buffer_end = 0;
                SQUASH_KA(current);
                break;
            default:
                retval = 0;
                fprintf(stderr, "Unknown status (%d), "
                        "closing!\n", current->status);
                current->status = DEAD;
                break;
            }

        }

        if (sigterm_flag)
            SQUASH_KA(current);

        /* we put this here instead of after the switch so that
         * if we are on the last request, and get_request is successful,
         * current->next is valid!
         */
        if (pending_requests)
            get_request(server_s);

        switch (retval) {
        case -1:               /* request blocked */
            trailer = current;
            current = current->next;
            block_request(trailer);
            break;
        case 0:                /* request complete */
            current->time_last = current_time;
            trailer = current;
            current = current->next;
            free_request(&request_ready, trailer);
            break;
        case 1:                /* more to do */
            current->time_last = current_time;
            current = current->next;
            break;
        default:
            log_error_time();
            fprintf(stderr, "Unknown retval in process.c - "
                    "Status: %d, retval: %d\n", current->status, retval);
            current = current->next;
            break;
        }
    }
}

 

对于每一个ready queue里的请求遍历处理，返回值-1表示需要进入block queue；返回值0表示请求结束；返回值1表示还要在ready queue里，需进一步处理。

首先检查是否有pending_requests，如果有调用get_request(server_s);，接受一个connection，加入ready_queue。

get_request(server_s);大体功能是，接受一个请求，并做一些简单的初始化，加入ready_queue。

然后开始轮询ready链表：

如果有数据要写，状态不是DEAD或DONE，就调用req_flush（current）。

每一轮最后检查一次，是否还有pending_requests。有的话加入ready_queue。