nginx socket初始化

1. 一些相关的数据结构:

//     监听端口配置信息，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;

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;

监听地址配置信息，包含了所有在该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的哈希表，用于快速查找对应虚拟主机的配置信息。

struct ngx_listening_s {
    ngx_socket_t        fd;

    struct sockaddr    *sockaddr;
    socklen_t           socklen;    /* size of sockaddr */
    size_t              addr_text_max_len;
    ngx_str_t           addr_text;

    int                 type;
    
    
    void               *servers;  /* array of ngx_http_in_addr_t, for example */

    ngx_log_t           log;
    ngx_log_t          *logp;
}

2.监听socket的初始化

nginx把需要监听的socket用ngx_listening_t表示，存放在ngx_cycle中的listening数组中.具体的socket初始化的可以分为3个步骤:1.解析配置文件，获取监听socket的相关信息. 2.初始化监听socket 3.打开并监听socket.

1)解析配置文件获取socket相关信息

用于设置监听socket的指令只要有2个:server_name,listen. server_name用于实现虚拟主机的功能，会为每个server块设置一个虚拟主机，在处理请求时会根据请求行中hosts进行转发请求.而listen就是监听socket的信息。这2个指令都在ngx_http_core_module中.首先看一下server_name指令的回调函数ngx_http_core_server_name，这个函数完成的功能很简单就是将server_name指令指定的虚拟主机名添加到ngx_http_core_srv_conf_t的server_names数组中，以便在后面对整个web server支持的虚拟主机进行初始化

a. 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;

    u_char                   ch;
    ngx_str_t               *value;
    ngx_uint_t               i;
    ngx_http_server_name_t  *sn;
    .........
    sn = ngx_array_push(&cscf->server_names);   //将指令sever_name的配置信息，添加到ngx_http_core_srv_conf_t中的sever_names数组中

    .....
      sn->server = cscf;

        if (ngx_strcasecmp(value[i].data, (u_char *) "$hostname") == 0) {
            sn->name = cf->cycle->hostname;

        } else {
            sn->name = value[i];
        }

        if (value[i].data[0] != '~') {
            ngx_strlow(sn->name.data, sn->name.data, sn->name.len);
            continue;
        }
}

b.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等。

    value = cf->args->elts;

    ngx_memzero(&u, sizeof(ngx_url_t));

    u.url = value[1];
    u.listen = 1;
    u.default_port = 80;
     //解析url中的ip地址，端口号,
    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;
    }

    ngx_http_listen_opt_t   lsopt;
    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;

(void) ngx_sock_ntop(&lsopt.u.sockaddr, lsopt.addr,NGX_SOCKADDR_STRLEN, 1);//将2进至的地址信息，转换文件

ngx_http_listen_opt_t 用于存储listen socket配置信息.比如rcvbuf、sndbuf、backlog等，就是一些基本的socket选项.

    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属性等。下面看一下具体实现

c. ngx_http_add_listen

ngx_int_t
ngx_http_add_listen(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
    ngx_http_listen_opt_t *lsopt)
{
    port = ngx_array_push(cmcf->ports);  //将port放到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);
}

d .ngx_http_add_addresses

tatic ngx_int_t
ngx_http_add_addresses(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
    ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
{
      return ngx_http_add_address(cf, cscf, port, lsopt);
}

f ngx_http_add_address

static ngx_int_t
ngx_http_add_address(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
    ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
{
    ngx_http_conf_addr_t  *addr;

    if (port->addrs.elts == NULL) {
        if (ngx_array_init(&port->addrs, cf->temp_pool, 4,
                           sizeof(ngx_http_conf_addr_t))
   
   

    addr = ngx_array_push(&port->addrs);


    addr->opt = *lsopt;
    addr->hash.buckets = NULL;
    addr->hash.size = 0;
    addr->wc_head = NULL;
    addr->wc_tail = NULL;

    addr->default_server = cscf;
    addr->servers.elts = NULL;

    return ngx_http_add_server(cf, cscf, addr);
}

static ngx_int_t
ngx_http_add_server(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
    ngx_http_conf_addr_t *addr)
{
    ngx_uint_t                  i;
    ngx_http_core_srv_conf_t  **server;

    if (addr->servers.elts == NULL) {
        if (ngx_array_init(&addr->servers, cf->temp_pool, 4,
                           sizeof(ngx_http_core_srv_conf_t *))
            != NGX_OK)
        {
            return NGX_ERROR;
        }

    } else {
        server = addr->servers.elts;
        for (i = 0; i < addr->servers.nelts; i++) {
            if (server[i] == cscf) {
                ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                   "a duplicate listen %s", addr->opt.addr);
                return NGX_ERROR;
            }
        }
    }

    server = ngx_array_push(&addr->servers);
    if (server == NULL) {
        return NGX_ERROR;
    }

    *server = cscf;

    return NGX_OK;
}

最后，调用ngx_http_add_server将该server块的server config添加到addr的servers数组中，这个函数逻辑很简单，首先检查是否存在重复的server config，如果存在则报错，否则添加一个新的元素。

2)初始化监听socket

我们介绍了在函数ngx_http_block函数中调用ngx_http_optimize_servers函数完成ngx_listening_t初始化。

1. ngx_http_optimize_server

static ngx_int_t
ngx_http_optimize_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
    ngx_array_t *ports)
{
    ngx_uint_t             p, a;
    ngx_http_conf_port_t  *port;
    ngx_http_conf_addr_t  *addr;



    port = ports->elts;
    for (p = 0; p < ports->nelts; p++) {

        ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
                 sizeof(ngx_http_conf_addr_t), ngx_http_cmp_conf_addrs);


        addr = port[p].addrs.elts;
        for (a = 0; a < port[p].addrs.nelts; a++) {

            if (addr[a].servers.nelts > 1 )
            {

初始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;
                }
            }
        }

        if (ngx_http_init_listening(cf, &port[p]) != NGX_OK) {
            return NGX_ERROR;
        }
    }

    return NGX_OK;
}

这个函数就是遍历所有的端口号，将端口号对应的地址结构的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_create_listengint函数。

4. ngx_create_listening

ngx_listening_t *
ngx_create_listening(ngx_conf_t *cf, void *sockaddr, socklen_t socklen)
{
    size_t            len;
    ngx_listening_t  *ls;
    struct sockaddr  *sa;
    u_char            text[NGX_SOCKADDR_STRLEN];

    ls = ngx_array_push(&cf->cycle->listening);  //将ngx_listening_t中的放到数组cycle->listening中
 
    ls->sockaddr = sa;

ls->socklen = socklen;

len = ngx_sock_ntop(sa, text, NGX_SOCKADDR_STRLEN, 1);
ls->addr_text.len = len;

3.打开socket监听

在ngx_init_cycle函数中，会调用ngx_open_listening_sockets和ngx_configure_listening_sockets函数完成监听socket的打开和配置

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.

通过这3个步骤就完成了监听socket的初始化，接下来就会在ngx_event_process_init函数（ngx_event_core_moduel的process_init回调函数，在创建完worker进程后调用）中将这些监听socket添加到事件循环中。

(责任编辑：IT)

搜索

热门标签:

nginx socket初始化