nginx源码分析（5）——监听socket初始化

我会带着你远行 2022-04-17 05:09 288阅读 0赞

在nginx源码分析（4）中，看到了nginx的事件模型，但其中没有介绍监听socket的初始化。而对于web server来说，需要通过监听socket来监听客户端的连接等。本篇将会具体介绍这方面的内容。还记得在前文介绍ngx\_cycle\_t结构时，它具有一个listening属性，是一个数组，存储所有监听socket，下面就来看看这些信息是什么时候添加的、以及如何初始化的。

1. 重要的数据结构  
1. ngx\_http\_conf\_port\_t

监听端口配置信息，addrs是在该端口上所有监听地址的数组。

typedef struct {
        ngx_int_t                  family;
        in_port_t                  port;
        ngx_array_t                addrs;     /* array of ngx_http_conf_addr_t */
    } ngx_http_conf_port_t;

2. ngx\_http\_conf\_addr\_t

监听地址配置信息，包含了所有在该addr:port监听的所有server块的ngx\_http\_core\_srv\_conf\_t结构，以及hash、wc\_head和wc\_tail这些hash结构，保存了以server name为key，ngx\_http\_core\_srv\_conf\_t为value的哈希表，用于快速查找对应虚拟主机的配置信息。

typedef struct {
        ngx_http_listen_opt_t      opt;
     
        ngx_hash_t                 hash;
        ngx_hash_wildcard_t       *wc_head;
        ngx_hash_wildcard_t       *wc_tail;
     
    #if (NGX_PCRE)
        ngx_uint_t                 nregex;
        ngx_http_server_name_t    *regex;
    #endif
     
        /* the default server configuration for this address:port */
        ngx_http_core_srv_conf_t  *default_server;
        ngx_array_t                servers;  /* array of ngx_http_core_srv_conf_t */
    } ngx_http_conf_addr_t;

2. 监听socket初始化  
nginx把需要监听的socket用ngx\_listening\_t表示，存放在ngx\_cycle\_t的listening数组中。具体监听socket的初始化可以分为3个步骤：1. 解析配置文件、获取监听socket相关信息；2. 初始化监听socket；3. 打开并配置监听socket。下面我们分步骤来查看具体细节。

（1）解析配置文件，获取监听socket信息  
用于设置监听socket的指令主要有两个：server\_name和listen。server\_name指令用于实现虚拟主机的功能，会设置每个server块的虚拟主机名，在处理请求时会根据请求行中的host来转发请求。而listen就是设置监听socket的信息。这两个指令都是ngx\_http\_core\_module的，首先看一下server\_name指令的回调函数ngx\_http\_core\_server\_name，这个函数完成的功能很简单就是将server\_name指令指定的虚拟主机名添加到ngx\_http\_core\_srv\_conf\_t的server\_names数组中，以便在后面对整个web server支持的虚拟主机进行初始化。

1. ngx\_http\_core\_server\_name

static char *
    ngx_http_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
    {
        ngx_http_core_srv_conf_t *cscf = conf;
     
        // 局部变量声明
        ……
     
        value = cf->args->elts;
        for (i = 1; i < cf->args->nelts; i++) {
            ch = value[i].data[0];
     
            // 一些异常的处理
            ……
            sn = ngx_array_push(&cscf->server_names); // 向server_names数组添加元素
            if (sn == NULL) {
                return NGX_CONF_ERROR;
            }
    #if (NGX_PCRE)
            sn->regex = NULL;
    #endif
            sn->server = cscf;
            if (ngx_strcasecmp(value[i].data, (u_char *) "$hostname") == 0) {
                sn->name = cf->cycle->hostname;
            } else {
                sn->name = value[i];
            }
            /* 前缀不是~就不是正则表达式，需要将server name转换为小写 */
            if (value[i].data[0] != '~') {
                ngx_strlow(sn->name.data, sn->name.data, sn->name.len);
                continue;
            }
    #if (NGX_PCRE)
            // 处理server name是正则表达式的情况
            ……      
    #else
            return NGX_CONF_ERROR;
    #endif
        }
        return NGX_CONF_OK;
    }

2. ngx\_http\_core\_listen

下面看一下listen指令的回调函数ngx\_http\_core\_listen。这个函数主要还解析listen指令中的socket配置选项，并保存这些值，在函数的最后会调用ngx\_http\_add\_listen函数添加监听socket的信息。

cscf->listen = 1;
            将core module的server config的listen置为1，表示该server块已经调用listen指令，
    设置了监听socket信息。如果listen等于0，即server块没有调用listen指令，
    后面会对监听信息进行默认初始化，比如监听的端口是80，地址是localhost等。
        // listen指令的参数
        value = cf->args->elts;
     
        ngx_memzero(&u, sizeof(ngx_url_t));
     
        u.url = value[1];
        u.listen = 1;
        u.default_port = 80;
     
        if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
            if (u.err) {
                ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                   "%s in \"%V\" of the \"listen\" directive",
                                   u.err, &u.url);
            }
     
            return NGX_CONF_ERROR;
        }

这段代码意图很简单，就是解析listen指令中的url，ip地址和端口号信息。

ngx_memzero(&lsopt, sizeof(ngx_http_listen_opt_t));
     
        ngx_memcpy(&lsopt.u.sockaddr, u.sockaddr, u.socklen);
     
        lsopt.socklen = u.socklen;
        lsopt.backlog = NGX_LISTEN_BACKLOG;
        lsopt.rcvbuf = -1;
        lsopt.sndbuf = -1;
    #if (NGX_HAVE_SETFIB)
        lsopt.setfib = -1;
    #endif
        lsopt.wildcard = u.wildcard;
     
        /* 将二进制的地址结构，转换为文本格式 */
        (void) ngx_sock_ntop(&lsopt.u.sockaddr, lsopt.addr,
                             NGX_SOCKADDR_STRLEN, 1);

ngx\_http\_listen\_opt\_t用于存储listen socket的配置信息，比如rcvbuf、sndbuf、backlog等，就是一些基本的socket选项。后面的大部分代码主要是处理listen指令指定的配置选项进行初始化，比如：default\_server、rcvbuf、sndbuf、backlog等，代码太冗长，这里不粘贴。

if (ngx_http_add_listen(cf, cscf, &lsopt) == NGX_OK) {
            return NGX_CONF_OK;
        }

在函数的最后部分调用了ngx\_http\_add\_listen添加监听socket信息。在具体介绍这个函数实现之前，先来看一下nginx是如何存储监听socket的地址信息的。  
在ngx\_http\_core\_main\_conf\_t中有ports属性，保存nginx监听的所有端口的信息。ports是ngx\_http\_conf\_port\_t类型的数组，而每个ngx\_http\_conf\_port\_t结构又具有addrs属性，它存放了对应端口上要监听的地址。addrs是ngx\_http\_conf\_addr\_t类型的数组，ngx\_http\_conf\_addr\_t结构包含在addr:port上监听的虚拟主机名及对应的配置信息。

ngx\_http\_core\_main\_conf\_t

|---> prots： 监听的端口号的数组

|---> ngx\_http\_conf\_port\_t：端口号的配置信息

|---> addrs：在该端口号上，监听的所有地址的数组

|---> ngx\_http\_conf\_addr\_t：地址配置信息，包含在该addr:port上的多个虚拟主机

|---> servers：在addr:port上的说个server块的配置信息ngx\_http\_core\_srv\_conf\_t

| |---> ngx\_http\_core\_srv\_conf\_t

|---> opt：ngx\_http\_listen\_opt\_t类型，监听socket的配置信息

|---> hash：以server\_name为key，ngx\_http\_core\_srv\_conf\_t为value的hash表，并且server\_name不含通配符。

|---> wc\_head：同hash，server\_name含前缀通配符。

|---> wc\_tail：同hash，server\_name含后缀通配符。

nginx就通过这种方式将监听的地址信息和端口信息组织起来，这些配置信息在后面回用于初始化ngx\_cycle\_t的listening属性等。下面看一下具体实现。

3. ngx\_http\_add\_listen

cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
     
        if (cmcf->ports == NULL) {
            cmcf->ports = ngx_array_create(cf->temp_pool, 2,
                                           sizeof(ngx_http_conf_port_t));
            if (cmcf->ports == NULL) {
                return NGX_ERROR;
            }
        }
            初始化ngx_http_core_main_conf_t中的ports数组。
    
    
        sa = &lsopt->u.sockaddr;
     
        switch (sa->sa_family) {
     
    #if (NGX_HAVE_INET6)
        case AF_INET6:
            sin6 = &lsopt->u.sockaddr_in6;
            p = sin6->sin6_port;
            break;
    #endif
     
    #if (NGX_HAVE_UNIX_DOMAIN)
        case AF_UNIX:
            p = 0;
            break;
    #endif
     
        default: /* AF_INET */
            sin = &lsopt->u.sockaddr_in;
            p = sin->sin_port;
            break;
        }
            接下来，获取监听socket的端口信息和地址信息。
        port = cmcf->ports->elts;
        for (i = 0; i < cmcf->ports->nelts; i++) {
     
            if (p != port[i].port || sa->sa_family != port[i].family) {
                continue;
            }
     
            /* a port is already in the port list */
     
            return ngx_http_add_addresses(cf, cscf, &port[i], lsopt);
        }

这段代码是遍历ports数组，查看新添加的端口信息是否已经存在，如果该端口信息存在则调用ngx\_http\_add\_addresses函数在对应的端口结构上添加地址信息。否则，在prots数组中添加一个元素，并初始化，然后调用ngx\_http\_add\_address函数添加地址信息。

port = ngx_array_push(cmcf->ports);
        if (port == NULL) {
            return NGX_ERROR;
        }
     
        port->family = sa->sa_family;
        port->port = p;
        port->addrs.elts = NULL;
     
        return ngx_http_add_address(cf, cscf, port, lsopt);

下面先看一下ngx\_http\_add\_addresses函数如何在存在对应port的情况下的添加地址信息。

4. ngx\_http\_add\_addresses

sa = &lsopt->u.sockaddr;
        switch (sa->sa_family) {
    #if (NGX_HAVE_INET6)
        case AF_INET6:
            off = offsetof(struct sockaddr_in6, sin6_addr);
            len = 16;
            break;
    #endif
    #if (NGX_HAVE_UNIX_DOMAIN)
        case AF_UNIX:
            off = offsetof(struct sockaddr_un, sun_path);
            len = sizeof(saun->sun_path);
            break;
    #endif
        default: /* AF_INET */
            off = offsetof(struct sockaddr_in, sin_addr);
            len = 4;
            break;
        }

这段代码是确定具体协议类型的地址信息在地址结构中的偏移量和长度，因为不能比较整个地址结构。

p = lsopt->u.sockaddr_data + off;
        addr = port->addrs.elts;
        /**
         * 在port的addr数组中已经存在该地址时，直接将ngx_http_core_srv_conf_t
         * 结构添加到到addr对应的servers数组中。
         */
        for (i = 0; i < port->addrs.nelts; i++) {
            // 比较地址是否相同
            if (ngx_memcmp(p, addr[i].opt.u.sockaddr_data + off, len) != 0) {
                continue;
            }
     
            /* the address is already in the address list */
            /**
             * 向ngx_http_conf_addr_t的servers数组添加ngx_http_core_srv_conf_t结构
             */
            if (ngx_http_add_server(cf, cscf, &addr[i]) != NGX_OK) {
                return NGX_ERROR;
            }
     
            /* 设置default_server属性 */
            /* preserve default_server bit during listen options overwriting */
            default_server = addr[i].opt.default_server;
     
    #if (NGX_HTTP_SSL)
            ssl = lsopt->ssl || addr[i].opt.ssl;
    #endif
     
            if (lsopt->set) {
                if (addr[i].opt.set) {
                    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                            "a duplicate listen options for %s", addr[i].opt.addr);
                    return NGX_ERROR;
                }
                addr[i].opt = *lsopt;
            }
     
            /* check the duplicate "default" server for this address:port */
            if (lsopt->default_server) {
                if (default_server) {
                    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                            "a duplicate default server for %s", addr[i].opt.addr);
                    return NGX_ERROR;
                }
                default_server = 1;
                addr[i].default_server = cscf;
            }
            addr[i].opt.default_server = default_server;
    #if (NGX_HTTP_SSL)
            addr[i].opt.ssl = ssl;
    #endif
            return NGX_OK;
        }

如果port对应的addrs数组中已经存在要添加的地址对应的ngx\_http\_conf\_addr\_t结构，那么直接向addr添加server块的配置信息。接下来的代码处理port的addrs数组中不存在对应地址的情况，只是很简单的调用ngx\_http\_add\_address函数，它的功能就是向port的addrs数组添加元素，具体看一下这个函数。  
5. ngx\_http\_add\_address

if (port->addrs.elts == NULL) {
            if (ngx_array_init(&port->addrs, cf->temp_pool, 4,
                               sizeof(ngx_http_conf_addr_t))
                != NGX_OK)
            {
                return NGX_ERROR;
            }
        }
            很简单，如果port的addrs数组没有初始化，那么对其初始化。
        addr = ngx_array_push(&port->addrs);
        if (addr == NULL) {
            return NGX_ERROR;
        }
            接下来向addrs添加一个元素。
        addr->opt = *lsopt;
        addr->hash.buckets = NULL;
        addr->hash.size = 0;
        addr->wc_head = NULL;
        addr->wc_tail = NULL;
    #if (NGX_PCRE)
        addr->nregex = 0;
        addr->regex = NULL;
    #endif
        addr->default_server = cscf;    // 对于此addr:port，该server block是默认的
        addr->servers.elts = NULL;

对新添加的元素初始化，会将第一个监听addr:port信息的server块作为default server，后续添加的监听addr:port的server块通过listen指令，并包含default\_server选项可以修改监听addr:port的default server。

return ngx_http_add_server(cf, cscf, addr);

最后，调用ngx\_http\_add\_server将该server块的server config添加到addr的servers数组中，这个函数逻辑很简单，首先检查是否存在重复的server config，如果存在则报错，否则添加一个新的元素。  
通过上面这些函数的调用完成了配置信息的存储，下面看一下ngx\_listening\_t的初始化。

（2）初始化监听socket（ngx\_listening\_t）  
在http模块初始化中，我们介绍了在函数ngx\_http\_block函数中调用ngx\_http\_optimize\_servers函数完成ngx\_listening\_t初始化，下面看一下这个函数的实现。  
1. ngx\_http\_optimize\_servers

port = ports->elts;
        for (p = 0; p < ports->nelts; p++) {
            /**
             * 将addrs排序，带通配符的地址排在后面
             */
            ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
                     sizeof(ngx_http_conf_addr_t), ngx_http_cmp_conf_addrs);
            /*
             * check whether all name-based servers have the same
             * configuraiton as a default server for given address:port
             */
            addr = port[p].addrs.elts;
            for (a = 0; a < port[p].addrs.nelts; a++) {
                if (addr[a].servers.nelts > 1
    #if (NGX_PCRE)
                    || addr[a].default_server->captures
    #endif
                   )
                {
                    /**
                     * 初始addr(ngx_http_conf_addr_t)中的hash、wc_head和wc_tail哈希表。
                     * 这些哈希表以server name（虚拟主机名）为key，server块的ngx_http_core_srv_conf_t为
                     * value，用于在处理请求时，根据请求的host请求行快速找到处理该请求的server配置结构。
                     */
                    if (ngx_http_server_names(cf, cmcf, &addr[a]) != NGX_OK) {
                        return NGX_ERROR;
                    }
                }
            }
     
            /**
             * 初始化ngx_listening_t
             */
            if (ngx_http_init_listening(cf, &port[p]) != NGX_OK) {
                return NGX_ERROR;
            }
        }

这个函数就是遍历所有的端口号，将端口号对应的地址结构的hash、wc\_head和wc\_tail初始化，这个在初始化后面的ngx\_listening\_t的servers字段时会用到。然后调用ngx\_http\_init\_listening函数完成ngx\_listening\_t初始化。  
2. ngx\_http\_init\_listening

while (i < last) {
            if (bind_wildcard && !addr[i].opt.bind) {
                i++;
                continue;
            }
            /**
             * 添加ngx_listening_t
             */
            ls = ngx_http_add_listening(cf, &addr[i]);
            if (ls == NULL) {
                return NGX_ERROR;
            }
     
            hport = ngx_pcalloc(cf->pool, sizeof(ngx_http_port_t));
            if (hport == NULL) {
                return NGX_ERROR;
            }
     
            /**
             * servers会用来保存虚拟主机的信息，在处理请求时会赋值给request
             * 用于进行虚拟主机的匹配
             */
            ls->servers = hport;
     
            if (i == last - 1) {
                hport->naddrs = last;
     
            } else {
                hport->naddrs = 1;
                i = 0;
            }
     
            /* 初始化ngx_http_virtual_names_t */
            switch (ls->sockaddr->sa_family) {
    #if (NGX_HAVE_INET6)
            case AF_INET6:
                if (ngx_http_add_addrs6(cf, hport, addr) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;
    #endif
            default: /* AF_INET */
                if (ngx_http_add_addrs(cf, hport, addr) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;
            }
            addr++;
            last--;
        }

遍历port的addrs数组，因为每个ngx\_http\_conf\_addr\_t有opt属性，也就是ngx\_listening\_t的配置信息，这里会调用ngx\_http\_add\_listening函数创建ngx\_listening\_t并添加到ngx\_cycle\_t中。ngx\_http\_add\_addrs函数用于初始化ls->servers，这个属性主要是存放该监听socket对应的虚拟主机的信息，在处理请求时根据请求行的host匹配，选择对应的一个server块的ngx\_http\_core\_srv\_conf\_t结构，这个结构里存放了刚请求处理的全局配置信息。下面看一下ngx\_http\_add\_listening函数。  
3. ngx\_http\_add\_listening

ls = ngx_create_listening(cf, &addr->opt.u.sockaddr, addr->opt.socklen);
        if (ls == NULL) {
            return NULL;
        }

调用ngx\_create\_listening函数创建ngx\_listening\_t，这个函数的内容在下面分析。

// 设置监听socket的handler，在监听到新的连接时调用，即ngx_event_accept中。
        ls->handler = ngx_http_init_connection;

设置ngx\_listening\_t的handler，这个handler会在监听到客户端连接时被调用，具体就是在ngx\_event\_accept函数中，ngx\_http\_init\_connection函数顾名思义，就是初始化这个新建的连接。后面的代码就是根据addr的opt属性初始化创建的ngx\_listening\_t结构。下面看一下ngx\_http\_create\_listengint函数。  
4. ngx\_http\_create\_listening

ls = ngx_array_push(&cf->cycle->listening);
        if (ls == NULL) {
            return NULL;
        }
            首先向ngx_cycle_t的listenging数组添加一个元素。
        ngx_memzero(ls, sizeof(ngx_listening_t));
     
        sa = ngx_palloc(cf->pool, socklen);
        if (sa == NULL) {
            return NULL;
        }
     
        ngx_memcpy(sa, sockaddr, socklen);
     
        ls->sockaddr = sa;
        ls->socklen = socklen;
     
        len = ngx_sock_ntop(sa, text, NGX_SOCKADDR_STRLEN, 1);
        ls->addr_text.len = len;ls->addr_text.data = ngx_pnalloc(cf->pool, len);
        if (ls->addr_text.data == NULL) {
            return NULL;
        }
        ngx_memcpy(ls->addr_text.data, text, len);
            配置地址信息，包括二进制地址和文本格式地址。
        ls->fd = (ngx_socket_t) -1;
        ls->type = SOCK_STREAM;
        ls->backlog = NGX_LISTEN_BACKLOG;
        ls->rcvbuf = -1;
        ls->sndbuf = -1;
     
    #if (NGX_HAVE_SETFIB)
        ls->setfib = -1;
    #endif

对属性设置默认值。  
（3） 打开并配置监听socket  
在nginx启动过程中，介绍过在ngx\_init\_cycle函数中，会调用ngx\_open\_listening\_sockets和ngx\_configure\_listening\_sockets函数完成监听socket的打开和配置，下面具体看一下这两函数。  
1. ngx\_open\_listening\_sockets

ngx_int_t
    ngx_open_listening_sockets(ngx_cycle_t *cycle)
    {
        int               reuseaddr;
        ngx_uint_t        i, tries, failed;
        ngx_err_t         err;
        ngx_log_t        *log;
        ngx_socket_t      s;
        ngx_listening_t  *ls;
     
        reuseaddr = 1;
    #if (NGX_SUPPRESS_WARN)
        failed = 0;
    #endif
     
        log = cycle->log;
     
        /* TODO: configurable try number */
     
        for (tries = 5; tries; tries--) {
            failed = 0;
     
            /* for each listening socket */
     
            ls = cycle->listening.elts;
            for (i = 0; i < cycle->listening.nelts; i++) {
     
                if (ls[i].ignore) {
                    continue;
                }
     
                /**
                 * 已经从就cycle处继承该socket，不需重新打开
                 */
                if (ls[i].fd != -1) {
                    continue;
                }
     
                if (ls[i].inherited) {
     
                    /* TODO: close on exit */
                    /* TODO: nonblocking */
                    /* TODO: deferred accept */
     
                    continue;
                }
     
                /* 新建一个socket，socket(地址结构的协议族，socket类型tcp/udp，)*/
                s = ngx_socket(ls[i].sockaddr->sa_family, ls[i].type, 0);
     
                if (s == -1) {
                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                  ngx_socket_n " %V failed", &ls[i].addr_text);
                    return NGX_ERROR;
                }
     
                if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
                               (const void *) &reuseaddr, sizeof(int))
                    == -1)
                {
                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                  "setsockopt(SO_REUSEADDR) %V failed",
                                  &ls[i].addr_text);
     
                    if (ngx_close_socket(s) == -1) {
                        ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                      ngx_close_socket_n " %V failed",
                                      &ls[i].addr_text);
                    }
     
                    return NGX_ERROR;
                }
     
    #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
     
                if (ls[i].sockaddr->sa_family == AF_INET6 && ls[i].ipv6only) {
                    int  ipv6only;
     
                    ipv6only = (ls[i].ipv6only == 1);
     
                    if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
                                   (const void *) &ipv6only, sizeof(int))
                        == -1)
                    {
                        ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                      "setsockopt(IPV6_V6ONLY) %V failed, ignored",
                                      &ls[i].addr_text);
                    }
                }
    #endif
                /* TODO: close on exit */
     
                if (!(ngx_event_flags & NGX_USE_AIO_EVENT)) {
                    /* 将socket设置为非阻塞 */
                    if (ngx_nonblocking(s) == -1) {
                        ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                      ngx_nonblocking_n " %V failed",
                                      &ls[i].addr_text);
     
                        if (ngx_close_socket(s) == -1) {
                            ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                          ngx_close_socket_n " %V failed",
                                          &ls[i].addr_text);
                        }
     
                        return NGX_ERROR;
                    }
                }
     
                ngx_log_debug2(NGX_LOG_DEBUG_CORE, log, 0,
                               "bind() %V #%d ", &ls[i].addr_text, s);
     
                /* 将socket绑定到要监听的地址 */
                if (bind(s, ls[i].sockaddr, ls[i].socklen) == -1) {
                    err = ngx_socket_errno;
     
                    if (err == NGX_EADDRINUSE && ngx_test_config) {
                        continue;
                    }
     
                    ngx_log_error(NGX_LOG_EMERG, log, err,
                                  "bind() to %V failed", &ls[i].addr_text);
     
                    if (ngx_close_socket(s) == -1) {
                        ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                      ngx_close_socket_n " %V failed",
                                      &ls[i].addr_text);
                    }
     
                    if (err != NGX_EADDRINUSE) {
                        return NGX_ERROR;
                    }
     
                    failed = 1;
     
                    continue;
                }
     
    #if (NGX_HAVE_UNIX_DOMAIN)
     
                /* 处理unix domain socket */
                if (ls[i].sockaddr->sa_family == AF_UNIX) {
                    mode_t   mode;
                    u_char  *name;
     
                    name = ls[i].addr_text.data + sizeof("unix:") - 1;
                    mode = (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
     
                    if (chmod((char *) name, mode) == -1) {
                        ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
                                      "chmod() \"%s\" failed", name);
                    }
     
                    if (ngx_test_config) {
                        if (ngx_delete_file(name) == -1) {
                            ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
                                          ngx_delete_file_n " %s failed", name);
                        }
                    }
                }
    #endif
     
                /* 将socket转换为监听socket，backlog指定了内核为改监听socket排队的最大值 */
                if (listen(s, ls[i].backlog) == -1) {
                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                  "listen() to %V, backlog %d failed",
                                  &ls[i].addr_text, ls[i].backlog);
     
                    if (ngx_close_socket(s) == -1) {
                        ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                      ngx_close_socket_n " %V failed",
                                      &ls[i].addr_text);
                    }
     
                    return NGX_ERROR;
                }
     
                /* 标识是监听socket */
                ls[i].listen = 1;
     
                /* 设置ngx_listening_t的描述符 */
                ls[i].fd = s;
            }
     
            if (!failed) {
                break;
            }
     
            /* TODO: delay configurable */
     
            ngx_log_error(NGX_LOG_NOTICE, log, 0,
                          "try again to bind() after 500ms");
     
            ngx_msleep(500);
        }
     
        if (failed) {
            ngx_log_error(NGX_LOG_EMERG, log, 0, "still could not bind()");
            return NGX_ERROR;
        }
     
        return NGX_OK;
    }

这个函数就是打开socket，和一般socket编程一样，就是调用socket、bind和listen，具体看一下注释。  
2. ngx\_configure\_listening\_sockets

void
    ngx_configure_listening_sockets(ngx_cycle_t *cycle)
    {
        ngx_uint_t                 i;
        ngx_listening_t           *ls;
     
    #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
        struct accept_filter_arg   af;
    #endif
    #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
        int                        timeout;
    #endif
     
        ls = cycle->listening.elts;
        for (i = 0; i < cycle->listening.nelts; i++) {
     
            ls[i].log = *ls[i].logp;
     
            /**
             * 设置监听socket的接收缓冲区大小
             */
            if (ls[i].rcvbuf != -1) {
                if (setsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF,
                               (const void *) &ls[i].rcvbuf, sizeof(int))
                    == -1)
                {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
                                  "setsockopt(SO_RCVBUF, %d) %V failed, ignored",
                                  ls[i].rcvbuf, &ls[i].addr_text);
                }
            }
     
            /**
             * 设置监听socket的发送缓冲区大小
             */
            if (ls[i].sndbuf != -1) {
                if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF,
                               (const void *) &ls[i].sndbuf, sizeof(int))
                    == -1)
                {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
                                  "setsockopt(SO_SNDBUF, %d) %V failed, ignored",
                                  ls[i].sndbuf, &ls[i].addr_text);
                }
            }
     
    #if (NGX_HAVE_SETFIB)
            if (ls[i].setfib != -1) {
                if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SETFIB,
                               (const void *) &ls[i].setfib, sizeof(int))
                    == -1)
                {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
                                  "setsockopt(SO_SETFIB, %d) %V failed, ignored",
                                  ls[i].setfib, &ls[i].addr_text);
                }
            }
    #endif
     
    #if 0
            if (1) {
                int tcp_nodelay = 1;
     
                if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_NODELAY,
                           (const void *) &tcp_nodelay, sizeof(int))
                    == -1)
                {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
                                  "setsockopt(TCP_NODELAY) %V failed, ignored",
                                  &ls[i].addr_text);
                }
            }
    #endif
     
            if (ls[i].listen) {
     
                /* change backlog via listen() */
     
                if (listen(ls[i].fd, ls[i].backlog) == -1) {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
                                  "listen() to %V, backlog %d failed, ignored",
                                  &ls[i].addr_text, ls[i].backlog);
                }
            }
     
            /*
             * setting deferred mode should be last operation on socket,
             * because code may prematurely continue cycle on failure
             */
     
    #if (NGX_HAVE_DEFERRED_ACCEPT)
     
    #ifdef SO_ACCEPTFILTER
     
            if (ls[i].delete_deferred) {
                /**
                 * set accept filter on listening socket
                 * 将SO_ACCEPTFILTER设置为NULL，也就是删除accept filter
                 */
                if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, NULL, 0)
                    == -1)
                {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                                  "setsockopt(SO_ACCEPTFILTER, NULL) "
                                  "for %V failed, ignored",
                                  &ls[i].addr_text);
     
                    if (ls[i].accept_filter) {
                        ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                                      "could not change the accept filter "
                                      "to \"%s\" for %V, ignored",
                                      ls[i].accept_filter, &ls[i].addr_text);
                    }
     
                    continue;
                }
     
                ls[i].deferred_accept = 0;
            }
     
            if (ls[i].add_deferred) {
                ngx_memzero(&af, sizeof(struct accept_filter_arg));
                (void) ngx_cpystrn((u_char *) af.af_name,
                                   (u_char *) ls[i].accept_filter, 16);
     
                /**
                 * set accept filter on listening socket
                 * 将SO_ACCEPTFILTER设置为ls[i].accept_filter，也就是添加accept filter
                 */
                if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
                               &af, sizeof(struct accept_filter_arg))
                    == -1)
                {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                                  "setsockopt(SO_ACCEPTFILTER, \"%s\") "
                                  " for %V failed, ignored",
                                  ls[i].accept_filter, &ls[i].addr_text);
                    continue;
                }
     
                ls[i].deferred_accept = 1;
            }
     
    #endif
     
    #ifdef TCP_DEFER_ACCEPT
     
            if (ls[i].add_deferred || ls[i].delete_deferred) {
     
                if (ls[i].add_deferred) {
                    timeout = (int) (ls[i].post_accept_timeout / 1000);
     
                } else {
                    timeout = 0;
                }
     
                if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
                               &timeout, sizeof(int))
                    == -1)
                {
                    ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                                  "setsockopt(TCP_DEFER_ACCEPT, %d) for %V failed, "
                                  "ignored",
                                  timeout, &ls[i].addr_text);
     
                    continue;
                }
            }
     
            if (ls[i].add_deferred) {
                ls[i].deferred_accept = 1;
            }
     
    #endif
     
    #endif /* NGX_HAVE_DEFERRED_ACCEPT */
        }
     
        return;
    }

这个函数就是根据配置调用setsockopt函数设置socket选项，比如接收缓冲区、发送缓冲区等，具体也没有什么可讲的。  
通过这3个步骤就完成了监听socket的初始化，接下来就会在ngx\_event\_process\_init函数（ngx\_event\_core\_moduel的process\_init回调函数，在创建完worker进程后调用）中将这些监听socket添加到事件循环中。

\---------------------  
作者：chosen0ne  
来源：CSDN  
原文：https://blog.csdn.net/chosen0ne/article/details/7754608  
版权声明：本文为博主原创文章，转载请附上博文链接！