lighttpd代码分析

原文链接

watcher,worker模型

lighttpd是目前非常流行的web服务器,很多流量非常大的网站(如youtube)使用的就是lighttpd,它的代码量不多,但是设计巧妙,效率高,功能完备(这是它将来能取代Apache的重要因素),编码风格优美, 是学习网络编程,熟悉http服务器编写的良好范例.在我初学网络编程的时候,就是看的lighttpd的源码进行学习,在其中学到了不少的技巧.我打算将这些写出来与别人分享,可能开始比较杂乱,也不会作完全的分析,因为很多部分的代码我也没有看过,写一点是一点吧.我进行阅读和分析的lighttpd版本是1.4.18.

lighttpd采用的是多进程+多路复用(如select,epoll)的网络模型,它对多路复用IO操作的封装将作为下一个专题的内容,本次将讲解它所采用的多进程模型.

lighttpd中的配置文件有一项server.max-worker配置的是服务器生成的工作进城数.在lighttpd中, 服务器主进程被称为watcher(监控者),而由这个主进程创建出来的子进程被称为woker(工作者),而woker的数量正是由上面提到的配置项进行配置的.watcher创建并且监控woker的代码如下所示,我觉得这是一段很巧妙的代码,在我阅读了这段代码之后,到目前为止,我所写的所有服务器采用的都是类似lighttpd的watcher-woker多进程模型,这段代码在src目录中server.c文件的main函数中:

#ifdef HAVE_FORK
    /* start watcher and workers */
    num_childs = srv->srvconf.max_worker;
    if (num_childs > 0) {
        int child = 0;
        while (!child && !srv_shutdown && !graceful_shutdown) {
            if (num_childs > 0) {
                switch (fork()) {
                case -1:
                    return -1;
                case 0:
                    child = 1;
                    break;
                default:
                    num_childs--;
                    break;
                }
            } else {
                int status;

                if (-1 != wait(&status)) {
                    /** 
                     * one of our workers went away 
                     */
                    num_childs++;
                } else {
                    switch (errno) {
                    case EINTR:
                        /**
                         * if we receive a SIGHUP we have to close our logs ourself as we don't 
                         * have the mainloop who can help us here
                         */
                        if (handle_sig_hup) {
                            handle_sig_hup = 0;

                            log_error_cycle(srv);

                            /**
                             * forward to all procs in the process-group
                             * 
                             * we also send it ourself
                             */
                            if (!forwarded_sig_hup) {
                                forwarded_sig_hup = 1;
                                kill(0, SIGHUP);
                            }
                        }
                        break;
                    default:
                        break;
                    }
                }
            }
        }

        /**
         * for the parent this is the exit-point 
         */
        if (!child) {
            /** 
             * kill all children too 
             */
            if (graceful_shutdown) {
                kill(0, SIGINT);
            } else if (srv_shutdown) {
                kill(0, SIGTERM);
            }

            log_error_close(srv);
            network_close(srv);
            connections_free(srv);
            plugins_free(srv);
            server_free(srv);
            return 0;
        }
    }
#endif

(二)--fdevents结构体解析

lighttpd中采取了类似于OO中面向对象的方式封装了各种平台对网络IO的事件处理,这其中包括:
OS                 Method         Config Value
all             select         select
Unix             poll         poll
Linux 2.4+         rt-signals     linux-rtsig
Linux 2.6+         epoll         linux-sysepoll
Solaris         /dev/poll     solaris-devpoll
FreeBSD, ...     kqueue         freebsd-kqueue
NetBSD     kqueue     kqueue

所有的网络IO事件都要满足这个数据结构的要求, 这个名为fdevents的结构体可以看成是OO中虚拟基类, 而每种具体的实现则可以看成是
继承并且实现了该虚拟基类中纯虚函数的派生类:

typedef struct fdevents {
    fdevent_handler_t type;

    fdnode **fdarray;
    size_t maxfds;

#ifdef USE_LINUX_SIGIO
    int in_sigio;
    int signum;
    sigset_t sigset;
    siginfo_t siginfo;
    bitset *sigbset;
#endif
#ifdef USE_LINUX_EPOLL
    int epoll_fd;
    struct epoll_event *epoll_events;
#endif
#ifdef USE_POLL
    struct pollfd *pollfds;

    size_t size;
    size_t used;

    buffer_int unused;
#endif
#ifdef USE_SELECT
    fd_set select_read;
    fd_set select_write;
    fd_set select_error;

    fd_set select_set_read;
    fd_set select_set_write;
    fd_set select_set_error;

    int select_max_fd;
#endif
#ifdef USE_SOLARIS_DEVPOLL
    int devpoll_fd;
    struct pollfd *devpollfds;
#endif
#ifdef USE_FREEBSD_KQUEUE
    int kq_fd;
    struct kevent *kq_results;
    bitset *kq_bevents;
#endif
#ifdef USE_SOLARIS_PORT
    int port_fd;
#endif
    int (*reset)(struct fdevents *ev);
    void (*free)(struct fdevents *ev);

    int (*event_add)(struct fdevents *ev, int fde_ndx, int fd, int events);
    int (*event_del)(struct fdevents *ev, int fde_ndx, int fd);
    int (*event_get_revent)(struct fdevents *ev, size_t ndx);
    int (*event_get_fd)(struct fdevents *ev, size_t ndx);

    int (*event_next_fdndx)(struct fdevents *ev, int ndx);

    int (*poll)(struct fdevents *ev, int timeout_ms);

    int (*fcntl_set)(struct fdevents *ev, int fd);
} fdevents;

该结构体中包含了一些公有的参数, 也就是类似OO中虚拟基类中的成员变量, 无论是哪个派生类继承之后都会有这部分的成员,
如最前面的几个成员:
    fdevent_handler_t type;

    fdnode **fdarray;
    size_t maxfds;

其中type是如下类型的枚举:

typedef enum
{
    FDEVENT_HANDLER_UNSET,
    FDEVENT_HANDLER_SELECT,
    FDEVENT_HANDLER_POLL,
    FDEVENT_HANDLER_LINUX_RTSIG,
    FDEVENT_HANDLER_LINUX_SYSEPOLL,
    FDEVENT_HANDLER_SOLARIS_DEVPOLL,
    FDEVENT_HANDLER_FREEBSD_KQUEUE,
    FDEVENT_HANDLER_SOLARIS_PORT
} fdevent_handler_t;

, 其实也就是各个不同IO事件类型.

fdarray是一个存放fdnode *类型的数组:

typedef struct _fdnode {
    fdevent_handler handler;
    void *ctx;
    int fd;

    struct _fdnode *prev, *next;
} fdnode;

这个结构体中, handler是一个回调函数, 在事件触发时进行回调(后面我们会讲到), ctx是一个context, 根据不同的fd进行区分.
fd就不必多说了, 是socket fd, 可能是服务器监听所有的fd, 也可能是accept之后与client相关的fd.再后面的两个参数, 将这个结构体
变为了一个链表中的一个节点.

maxfds, 这个成员用于存放可以处理的最大数量.

除了这些公有成员外, 根据编译时的预编译宏, 该结构体还有其它的成员, 这些成员就相当于OO中具体每个派生类自己私有的成员.

在这个结构体的最后, 是一组函数指针, 也就是OO中的纯虚函数, 每个派生类都要根据这些接口自己进行实现,我分别给加上了一些简单的注释:

    // 重置某个fdevents
    int (*reset)(struct fdevents *ev);
    // 释放fdevents指针
    void (*free)(struct fdevents *ev);

    // 向fdevents中添加一个fd, events表示这个fd对哪些事件感兴趣
    int (*event_add)(struct fdevents *ev, int fde_ndx, int fd, int events);
    // 向fdevents中删除一个fd
    int (*event_del)(struct fdevents *ev, int fde_ndx, int fd);
    // 根据fd在fdevents中的fdarray中的index, 获取该fd目前对哪些事件感兴趣
    int (*event_get_revent)(struct fdevents *ev, size_t ndx);
    // 根据fd在fdevents中的fdarray中的index, 获取要进行处理的fd
    int (*event_get_fd)(struct fdevents *ev, size_t ndx);
    // 获取下一个需要进行处理的fd在fdarray中的index
    int (*event_next_fdndx)(struct fdevents *ev, int ndx);
    // 轮询, timeout_ms是超时参数, 单位是微秒
    int (*poll)(struct fdevents *ev, int timeout_ms);
    // 这个接口一般都没有实现, 为NULL
    int (*fcntl_set)(struct fdevents *ev, int fd);

在上面的函数中, 参数int events的值为以下几种:

#define BV(x) (1 << x)

#define FDEVENT_IN     BV(0)
#define FDEVENT_PRI    BV(1)
#define FDEVENT_OUT    BV(2)
#define FDEVENT_ERR    BV(3)
#define FDEVENT_HUP    BV(4)
#define FDEVENT_NVAL   BV(5)

从这里可以看到, 具体判断某个事件是否发生, 需要采用的掩码操作进行判断, 而不是一般的比较操作, 如:
if (events & FDEVENT_IN) 而不是 if (events == FDEVENT_IN)
因此, 一个fd, 当前所关注的事件类型可以不止一个而是有多个.

了解了这个结构体之后, 也就了解了lighttpd中每种网络IO事件必须处理的事件类型及它们对外的接口.下一节开始讲解在lighttpd中是如何使用这个事件处理器的.

(三)--网络IO事件处理器的使用

上一节已经对lighttpd中的fdevent结构体进行了分析,前面提过,fdevent结构体是网络IO事件处理器的"虚拟基类",提供了网络IO事件处理器的公共成员,私有成员以及对外接口,这一节将对这个事件处理器的实现和使用进行解析.与这些相关的文件有这些:fdevent.h提供了fdevent结构体的定义, 在这个头文件中声明的函数可以看作是fdevent这个结构体对外暴露的接口, 也就是OO中所谓的类public函数, fdevent.c则是这些函数的实现,而以fdevent_为开头的几个C文件则是不同的网络IO模型的实现,比如fdevent_select.c文件是select模型的实现.我不打算对各种类型的网络IO模型做详细的介绍,事实上,所有这里用到的网络IO模型,我只用过select和epoll,所以我打算以select模型为例展开这里的讨论,因为select是相对而言用的最多也是大多数人在学习多路复用IO的时候学到的第一个模型,即使在epoll横行的今天,select模型仍然有着它的一席之地.

1)初始化
如何配置使用的是哪种网络IO模型?在配置文件中有一项server.event-handler就是配置需要使用的网络IO的,比如server.event-handler="select"就是选择select, 其它的配置字符串参见前一节最开始提到的那些类型.服务器在初始化的时候读取该配置项, 将网络IO事件类型存放在结构体server的成员event_handler中.
接着, 在server.c的main函数中服务器调用fdevent_init(size_t maxfds, fdevent_handler_t type)初始化一个fdevents指针, 返回的结果存放在server结构体中的ev成员中.
在这个函数中, 根据type参数进行初始化, 生成具体各种不同类型的fdevents指针, 这些初始化的函数都是以init为后缀的, 而所有具体实现的文件名为
fdevent_***.c(如fdevent_select.c是select模型的实现), 对外暴露的仅仅是那个以init为后缀的函数, 而上面那些函数接口的实现全都是这些文件中
静态函数, 很好的限制了它们的使用范围, 做到了信息隐藏, 这些函数可以看作是类中的私有函数, 以select模型为例:
对外暴露的初始化函数是fdevent_select_init, 它在fdevent.h中声明, 也就是说这个函数是对外暴露的, 而这个函数在fdevent_select.c被定义:

int fdevent_select_init(fdevents *ev) {
    ev->type = FDEVENT_HANDLER_SELECT;
#define SET(x) \
    ev->x = fdevent_select_##x;

    SET(reset);
    SET(poll);

    SET(event_del);
    SET(event_add);

    SET(event_next_fdndx);
    SET(event_get_fd);
    SET(event_get_revent);

    return 0;
}

查看fdevent_secelt.c文件,可以看到,名为fdevent_select_***的函数都是这个文件的静态函数, 再从面向对象的观点出发,这些函数属于采用select模型实现的fdevent的"私有函数", 如此做法, 很好的满足了所谓的"信息隐藏".

2) 使用
在服务器创建一个socket fd并且进行监听后, 要将该fd注册到fdevent中, 这样才能使用使用这个事件处理机制.
在server.c文件的main函数中, 调用network_register_fdevents函数将所有监听的fd注册到事件处理器中:

int network_register_fdevents(server *srv) {
    size_t i;

    if (-1 == fdevent_reset(srv->ev)) {
        return -1;
    }

    /* register fdevents after reset */
    for (i = 0; i < srv->srv_sockets.used; i++) {
        server_socket *srv_socket = srv->srv_sockets.ptr[i];

        fdevent_register(srv->ev, srv_socket->fd, network_server_handle_fdevent, srv_socket);
        fdevent_event_add(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN);
    }
    return 0;
}

关键是在循环体中的两个函数, fdevent_register的第三个参数是一个回调函数, 就是fdevents的成员fdarray中每个fdnode的成员handler:

int fdevent_register(fdevents *ev, int fd, fdevent_handler handler, void *ctx) {
    fdnode *fdn;

    // 分配一个fdnode指针
    fdn = fdnode_init();

    // 保存回调函数
    fdn->handler = handler;
    // 保存fd
    fdn->fd      = fd;
    // 保存context 对server是server为socket指针, 对client是connection指针
    fdn->ctx     = ctx;

    // 以fd为索引在fdarray中保存这个fdnode
    ev->fdarray[fd] = fdn;

    return 0;
}

这里有一个小技巧, 函数中的倒数第二行, 以fd为索引保存fdnode, 因为这里的fdarray是一个数组, 因此这个方法可以以O(1)的速度找到与该fd相关的fdnode指针.但是, 因为0,1,2这三个fd已经提前预留给了标准输入输出错误这三个IO, 所以采用这样的算法将会至少浪费三个fdnode指针.

现在, 可以对fdnode结构体中两个成员进一步进行解析了:
fdevent_handler handler;
void *ctx;
其中, 如果该fd是服务器监听客户端连接的fd, 那么handler = network_server_handle_fdevent(在network.c文件中), ctx保存的就是server指针;
如果该fd是accapt客户端连接之后的fd, 那么handler = connection_handle_fdevent(在connections.c文件中), ctx保存的就是connection指针.

回过头来看,在将服务器监听fd注册到网络IO事件处理器中之后, 这个处理器就要开始循环处理了, 在server.c中的main.c函数中是这个轮询的主过程:

        // 轮询FD
        if ((n = fdevent_poll(srv->ev, 1000)) > 0) {
            /* n is the number of events */
            int revents;
            int fd_ndx;

            fd_ndx = -1;
            do {
                fdevent_handler handler;
                void *context;
                handler_t r;

                // 获得处理这些事件的函数指针 fd等

                // 获得下一个fd在fdarray中的索引
                fd_ndx = fdevent_event_next_fdndx (srv->ev, fd_ndx);
                // 获得这个fd要处理的事件类型
                revents = fdevent_event_get_revent (srv->ev, fd_ndx);
                // 获取fd
                fd      = fdevent_event_get_fd     (srv->ev, fd_ndx);
                // 获取回调函数
                handler = fdevent_get_handler(srv->ev, fd);
                // 获取处理相关的context(对server是server_socket指针, 对client是connection指针)
                context = fdevent_get_context(srv->ev, fd);

                /* connection_handle_fdevent needs a joblist_append */
                // 进行处理
                switch (r = (*handler)(srv, context, revents)) {
                case HANDLER_FINISHED:
                case HANDLER_GO_ON:
                case HANDLER_WAIT_FOR_EVENT:
                case HANDLER_WAIT_FOR_FD:
                    break;
                case HANDLER_ERROR:
                    /* should never happen */
                    SEGFAULT();
                    break;
                default:
                    log_error_write(srv, __FILE__, __LINE__, "d", r);
                    break;
                }
            } while (--n > 0);

简单的说, 这个过程就是:首先调用poll函数指针获取相关网络IO被触发的事件数, 保存在整型变量n中, 然后根据这个n值进行以下循环, 每次处理完n值减一, 为0之后退出, 这个循环的大致过程是: 首先获取下一个被触发的网络事件在fdnode数组中的索引, 接着根据该索引获取相关的事件类型, fd, 回调函数, contex, ,接着根据这些调用回调函数(也就是我们上面提到的函数 network_server_handle_fdevent和connection_handle_fdevent),请注意, 在本节的最开始部分曾经提到过fdevent.h中声明的函数都是对外暴露的fdevent结构体"public函数", 在上面这个轮询的过程中使用的正是这些"public函数", 在这些"public函数"中再根据曾经初始化的函数指针进行调用, 实现了OO中所谓的"多态".

以上就是通过fdevent结构体实现的网络IO处理器模型, 在这里体现如何使用C实现OO面向对象编程的种种常用技巧,不放在本节最后做一个总结:
1) fdevent结构体是一个虚拟基类, 其中的函数指针就是虚拟基类中的纯虚函数, 由具体实现去初始化之.fdevent结构体中的对象为所有派生类的公共成员, 而用各个预编译宏包围的成员则是各个派生类的私有成员.

2) 在fdevent.h中声明的函数可以理解为虚拟基类对外暴露的接口, 也就是public函数.

3) 各个具体的实现分别是各个实现C文件中的静态函数, 也就是派生类的private函数.

如果阅读到这里仍然对lighttpd中网络IO处理器模型有疑问, 可以具体参看前面提到的fdevent.h/c文件, 以及以fdevent_为前缀的c文件.

(四)--处理监听fd的流程

前面介绍了lighttpd使用的watcher-worker模型, 它对IO事件处理的封装, 现在可以把这些结合起来看看这大概的流程.

首先, 服务器创建监听socket, 然后在server.c中调用函数network_register_fdevents将监听socket注册到IO事件处理器中:

在这里, 调用函数fdevent_register注册fd到IO事件处理器中, 对于服务器监听fd而言,
它在fdnode中的回调函数handler是函数network_server_handle_fdevent, 而ctx则是srv_socket.
接着调用函数fdevent_event_add, 其中传入的第三个参数是FDEVENT_IN, 也就是当该fd上有可读数据时触发调用, 对于所有监听的fd而言,
有可读事件就意味着有新的连接到达.

然后服务器创建子进程worker, 服务器父进程自己成为watcher, 自此下面的工作由子进程进行处理,
每个子进程所完成的工作都是一样的.有的书上说有多个进程在等待accept连接的时候会造成所谓的惊群现象,在lighttpd的代码中,
没有看到在accaept之前进行加锁操作, 这是否会造成惊群不得而知.

现在, 在IO事件处理器中仅有一个fd等待触发, 就是前面注册的监听fd, 我们看看当一个连接到来的时候处理的流程, 首先看我们曾经说过的
轮询fd进行处理的主循环:

当一个连接到来的时候, 调用fdevent_poll返回值是1, 因为这个函数的返回值表示的是有多少网络IO事件被触发了, 接着由于n>0, 进入循环中
获得被触发的fd, 回调函数, 以及ctx指针, 在这里由于是监听fd被触发, 那么返回的回调函数是前面提到的network_server_handle_fdevent,
接着就要调用这个函数处理IO事件了:

// 这个函数是处理server事件的函数, 与connection_handle_fdevent对应
handler_t network_server_handle_fdevent(void *s, void *context, int revents) {
    server     *srv = (server *)s;
    server_socket *srv_socket = (server_socket *)context;
    connection *con;
    int loops = 0;

    UNUSED(context);

    if (revents != FDEVENT_IN) {
        log_error_write(srv, __FILE__, __LINE__, "sdd",
                "strange event for server socket",
                srv_socket->fd,
                revents);
        return HANDLER_ERROR;
    }

    /* accept()s at most 100 connections directly
     *
     * we jump out after 100 to give the waiting connections a chance */
    // 一次最多接受100个链接
    for (loops = 0; loops < 100 && NULL != (con = connection_accept(srv, srv_socket)); loops++) {
        handler_t r;

        // 这里马上进入状态机中进行处理仅仅对应状态为CON_STATE_REQUEST_START这一段
        // 也就是保存连接的时间以及设置一些计数罢了
        connection_state_machine(srv, con);

        switch(r = plugins_call_handle_joblist(srv, con)) {
        case HANDLER_FINISHED:
        case HANDLER_GO_ON:
            break;
        default:
            log_error_write(srv, __FILE__, __LINE__, "d", r);
            break;
        }
    }
    return HANDLER_GO_ON;
}

我给这段代码加了一些注释, 有几个地方做一些解释:
1)UNUSED(context)是一个宏, 扩展开来就是( (void)(context) ), 实际上是一段看似无用的代码, 因为没有起什么明显的作用, 是一句废话,
在这个函数中, 实际上没有使用到参数context, 如果在比较严格的编译器中, 这样无用的参数会产生一条警告, 说有一个参数没有使用到, 加上了
这么一句无用的语句, 就可以避免这个警告.那么, 有人就会问了, 为什么要传入这么一个无用的参数呢?回答是, 为了满足这个接口的需求,
来看看回调函数的类型定义:
typedef handler_t (*fdevent_handler)(void *srv, void *ctx, int revents);
这个函数指针要求的第二个参数是一个ctx指针, 对于监听fd的回调函数network_server_handle_fdevent而言, 它是无用的, 但是对于处理连接fd
的回调函数而言, 这个指针是有用的.

2) 在函数的前面, 首先要判断传入的event事件是否是FDEVENT_IN, 也就是说, 只可能在fd有可读数据的时候才触发该函数, 其它的情况都是错误.

3)函数在最后进入一个循环, 循环的最多次数是100次, 并且当connection_accept函数返回NULL时也终止循环, 也就是说, 当监听fd被触发时,
服务器尽量的去接收新的连接, 最多接收100个新连接, 这样有一个好处, 假如服务器监听fd是每次触发只接收一个新的连接, 那么效率是比较低的,
不如每次被触发的时候"尽力"的去接收, 一直到接收了100个新的连接或者没有可接收的连接之后才返回.接着来看看负责接收新连接的函数
connection_accept做了什么:

// 接收一个新的连接
connection *connection_accept(server *srv, server_socket *srv_socket) {
    /* accept everything */

    /* search an empty place */
    int cnt;
    sock_addr cnt_addr;
    socklen_t cnt_len;
    /* accept it and register the fd */

    /**
     * check if we can still open a new connections
     *
     * see #1216
     */

    // 如果正在使用的连接数大于最大连接数就返回NULL
    if (srv->conns->used >= srv->max_conns) {
        return NULL;
    }

    cnt_len = sizeof(cnt_addr);

    if (-1 == (cnt = accept(srv_socket->fd, (struct sockaddr *) &cnt_addr, &cnt_len))) {
        switch (errno) {
        case EAGAIN:
#if EWOULDBLOCK != EAGAIN
        case EWOULDBLOCK:
#endif
        case EINTR:
            /* we were stopped _before_ we had a connection */
        case ECONNABORTED: /* this is a FreeBSD thingy */
            /* we were stopped _after_ we had a connection */
            break;
        case EMFILE:
            /* out of fds */
            break;
        default:
            log_error_write(srv, __FILE__, __LINE__, "ssd", "accept failed:", strerror(errno), errno);
        }
        return NULL;
    } else {
        connection *con;

        // 当前使用的fd数量+1
        srv->cur_fds++;

        /* ok, we have the connection, register it */
        // 打开的connection+1(这个成员貌似没有用)
        srv->con_opened++;

        // 获取一个新的connection
        con = connections_get_new_connection(srv);

        // 保存接收到的fd
        con->fd = cnt;
        // 索引为-1
        con->fde_ndx = -1;
#if 0
        gettimeofday(&(con->start_tv), NULL);
#endif
        // 注册函数指针和connection指针
        fdevent_register(srv->ev, con->fd, connection_handle_fdevent, con);

        // 状态为可以接收请求
        connection_set_state(srv, con, CON_STATE_REQUEST_START);

        // 保存接收连接的时间
        con->connection_start = srv->cur_ts;
        // 保存目标地址
        con->dst_addr = cnt_addr;
        buffer_copy_string(con->dst_addr_buf, inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
        // 保存server_socket指针
        con->srv_socket = srv_socket;

        // 设置一下接收来的FD, 设置为非阻塞
        if (-1 == (fdevent_fcntl_set(srv->ev, con->fd))) {
            log_error_write(srv, __FILE__, __LINE__, "ss", "fcntl failed: ", strerror(errno));
            return NULL;
        }
#ifdef USE_OPENSSL
        /* connect FD to SSL */
        if (srv_socket->is_ssl) {
            if (NULL == (con->ssl = SSL_new(srv_socket->ssl_ctx))) {
                log_error_write(srv, __FILE__, __LINE__, "ss", "SSL:",
                        ERR_error_string(ERR_get_error(), NULL));

                return NULL;
            }

            SSL_set_accept_state(con->ssl);
            con->conf.is_ssl=1;

            if (1 != (SSL_set_fd(con->ssl, cnt))) {
                log_error_write(srv, __FILE__, __LINE__, "ss", "SSL:",
                        ERR_error_string(ERR_get_error(), NULL));
                return NULL;
            }
        }
#endif
        return con;
    }
}

抛开出错处理这部分不解释, 一旦出错, 就返回NULL指针, 这时可以终止上面那个循环接收新连接的过程,下面重点看看接收了一个新的连接之后需要
做哪些事情, 在上面的代码中我加了一些简单的注释, 下面加一些更加详细些的解释:
1)要将服务器已经接收的fd数量(成员cur_fds)加一, 这个数量用于判断是否可以接收新的连接的, 超过一定的数量时, 服务器就暂停接收,
等一些fd释放之后才能继续接收

2) 调用函数connections_get_new_connection返回一个connection指针, 用于保存新到的连接, 获得这个指针之后要保存接收这个连接的时间
(成员connection_start中), 保存新到连接的地址(成员dst_addr和dst_addr_buf中), 此外还要保存一个server指针, 并且调用函数fdevent_fcntl_set
将该fd设置为非阻塞的, 最后别忘了要调用fdevent_register函数将该fd注册到IO事件处理器中, 另外该fd当前的状态通过connection_set_state设置为
CON_STATE_REQUEST_START, 这是后面进入状态机处理连接的基础.

了解了这个函数的处理过程, 回头看看上面的循环:

    for (loops = 0; loops < 100 && NULL != (con = connection_accept(srv, srv_socket)); loops++) {
        handler_t r;

        // 这里马上进入状态机中进行处理仅仅对应状态为CON_STATE_REQUEST_START这一段
        // 也就是保存连接的时间以及设置一些计数罢了
        connection_state_machine(srv, con);

        switch(r = plugins_call_handle_joblist(srv, con)) {
        case HANDLER_FINISHED:
        case HANDLER_GO_ON:
            break;
        default:
            log_error_write(srv, __FILE__, __LINE__, "d", r);
            break;
        }
    }

我们已经分析完了函数connection_accept, 当一个新的连接调用这个函数成功返回的时候, 这个循环执行函数connection_state_machine
进行处理.这是一个非常关键的函数, 可以说, 我们后面讲解lighttpd的很多笔墨都将花费在这个函数上, 这也是我认为lighttpd实现中最精妙的
地方之一, 在这里我们先不进行讲解, 你所需要知道的是, 在这里, connection_state_machine调用了函数fdevent_event_add, 传入的事件参数仍然是
FDEVENT_IN, 也就是说, 对于新加入的fd, 它所首先关注的IO事件也是可读事件.

我们大体理一理上面的流程, 省略去对watcher-worker模型的描述:
创建服务器监听fd-->
调用fdevent_register函数将监听fd注册到IO事件处理器中-->
调用fdevent_event_add函数添加FDEVENT_IN到监听fd所关注的事件中-->

当一个新的连接到来时:
IO事件处理器轮询返回一个>0的值-->
IO事件处理返回被触发的fd, 回调函数, ctx指针,在这里就是监听fd,回调函数则是network_server_handle_fdevent->
调用监听fd注册的回调函数network_server_handle_fdevent-->
network_server_handle_fdevent函数尽力接收新的连接, 除非已经接收了100个新连接, 或者没有新连接到来-->
对于新到来的连接, 同样是调用fdevent_register函数将它注册到IO事件处理器中, 同样调用fdevent_event_add函数添加该fd所关注的事件是FDEVENT_IN

以上, 就是lighttpd监听fd处理新连接的大体流程.
我们知道, fd分为两种:一种是服务器自己创建的监听fd, 负责监听端口, 接收新到来的连接;
另一种, 就是由监听fd调用accept函数返回的连接fd, 这两种fd在处理时都会注册到IO事件处理器中(调用fdevent_register函数),
同时添加它们所关注的IO事件(可读/可写等)(调用fdevent_event_add函数).

也就是说,对IO事件处理器而言, 它并不关注所处理的fd是什么类型的, 你要使用它, 那么就把你的fd以及它的回调函数注册到其中, 同时添加你所关注的IO事件是什么, 当一个fd所关注的IO事件被触发时, IO事件处理器自动会根据你所注册的回调函数进行回调处理, 这是关键点, 如果你没有明白, 请回头看看前面提到的IO事件处理器.

这些的基础就是我们前面提到IO事件处理器, 前面我们提到过, lighttpd对IO事件处理的封装很漂亮, 每个具体实现都按照接口的规范进行处理.
我们在讲解时, 也没有涉及到任何一个具体实现的细节, 这也是因为lighttpd的封装很好, 以至于我们只需要了解它们对外的接口不需要深入细节就
可以明白其运行的原理.在本节中, 我们结合IO事件处理器, 对上面提到的第一种fd也就是监听fd的处理流程做了介绍, 在后面的内容中, 将重点讲解对
连接fd的处理.

posted @ 2009-07-22 16:44 辛勤耕耘阅读(1415) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

辛勤耕耘

未曾清贫难成人，不经打击老天真，从来英雄出炼狱，自古富贵入凡尘，醉生梦死谁成器，拓马长枪定乾坤