nginx监听事件流程

╰半橙微兮° 2022-04-16 02:14 201阅读 0赞

在前面的几篇文章中已经分析了master进程、work进程的初始化流程。但一直没有分析监听socket的创建流程，nginx服务器只有在创建socket, 绑定socet，监听socket执行完成后，才能处理来自客户端的连接。ngx\_cycle\_t结构中有一个listening成员，存放的就是所有监听socket。接下来首先分析socket内部结构的维护，不同域名的管理，然后分析什么时候把监听socket添加到listening数组中，最后分析何时创建监听socket。

一、socket内部结构管理

static ngx_command_t  ngx_http_core_commands[] = 
    {
        { ngx_string("listen"),
          NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
          ngx_http_core_listen,
          NGX_HTTP_SRV_CONF_OFFSET,
          0,
          NULL },
    }

在ngx\_http\_core\_module模块的命令列表中，listen命令的实现函数为ngx\_http\_core\_listen。nginx.conf配置文件中，每一个server块都可以监听不同的端口，listen命令函数的作用就一个，就是为了维护socket的内部结构。如果直接分析源代码，则不好表达，也不太好理解。还是以一个例子来说明socket内部结构的维护吧!

http
    {
        #server1，监听80端口，ip为192.168.100.1
        server
        {
            listen 192.168.100.1:80;
            server_name www.server1.com;
        }
        
        #server2，监听80端口,ip位192.168.100.2
        server
        {
            listen 192.168.100.2:80;
            server_name www.server2.com;
        }
        
        #server3，监听80端口,ip位192.168.100.1
        server
        {
            listen 192.168.100.1:80;
            server_name www.server3.com;
        }
        
        #server4，监听90端口,ip位192.168.100.4
        server
        {
            listen 192.168.100.4:90;
            server_name www.server4.com;
        }
    }

假设有这样一个nginx.conf配置文件。192.168.100.1 ---192.168.100.2这两个ip监听同一个端口80， 而 192.168.100.4监听端口90。nginx一共监听了2个端口，则nginx维护的内部结构如下图：

在这张图中，192.168.100.1 ---192.168.100.2这两个ip监听端口80。192.168.100.1:80这个socket对应有www.server1.com; www.server3.com共两个域名。 192.168.100.2:80这个socket对应有www.server2.com共一个域名。

192.168.100.4这个ip监听90端口，对应的域名为www.server4.com

nginx维护这样的结构是为了做什么? 假设nginx在192.168.100.1 :80这个socket收到来自客户端的连接，http请求头部的host=www.server3.com。则查找过程如下:

(1)先在ports数组中查找80端口对应的结构ngx\_http\_conf\_port\_t;

(2)接着查找ngx\_http\_conf\_port\_t中的addrs数组，从而获取到192.168.100.1所在的ngx\_http\_conf\_addr\_t;

(3)然后查找ngx\_http\_conf\_addr\_t结构中的servers数组，从而获取得到www.server3.com域名所在的server块。

从这个例子可以看出，即便来自同一个ip:port的客户端连接，由于请求域名的不同，从而会获取到不同的server块进行处理。而listen命令的函数ngx\_http\_core\_listen就是用来维护这样的一种socket结构

//解析listen命令
    static char * ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
    {
        cscf->listen = 1;    //表示server块配置了listen配置项
        value = cf->args->elts;
        u.url = value[1];
        u.listen = 1;
        u.default_port = 80;
        //解析listen的参数1，获取监听的ip地址以及端口信息
        ngx_parse_url(cf->pool, &u);
        ngx_memcpy(&lsopt.u.sockaddr, u.sockaddr, u.socklen);
        //给监听选项结构赋值默认值
        lsopt.socklen = u.socklen;
        lsopt.backlog = NGX_LISTEN_BACKLOG;
        lsopt.rcvbuf = -1;
        lsopt.sndbuf = -1;
        //将struct sockaddr结构转为点分十进制的ip地址格式，例如172.16.3.180
        (void) ngx_sock_ntop(&lsopt.u.sockaddr, lsopt.addr,
                             NGX_SOCKADDR_STRLEN, 1);
     
        //listen配置的参数保存到监听选项结构
        for (n = 2; n < cf->args->nelts; n++)
        {
            //设置默认的server块
            if (ngx_strcmp(value[n].data, "default_server") == 0
                || ngx_strcmp(value[n].data, "default") == 0)
            {
                lsopt.default_server = 1;
                continue;
            }
     
            //设置监听队列大小
            if (ngx_strncmp(value[n].data, "backlog=", 8) == 0)
            {
                lsopt.backlog = ngx_atoi(value[n].data + 8, value[n].len - 8);
                lsopt.set = 1;
                lsopt.bind = 1;
     
                if (lsopt.backlog == NGX_ERROR || lsopt.backlog == 0) 
                {
                    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                       "invalid backlog \"%V\"", &value[n]);
                    return NGX_CONF_ERROR;
                }
     
                continue;
            }
        }
        //将server块添加到监听端口中，表示有多少个server块在监听同一个端口
        if (ngx_http_add_listen(cf, cscf, &lsopt) == NGX_OK) 
        {
            return NGX_CONF_OK;
        }
     
        return NGX_CONF_ERROR;
    }

而ngx\_parse\_url函数是从listen配置项格式中提取到需要监听的ip地址，端口号等信息。

//根据listen命令格式"listen ip:port"获取ip， port，保存到u对应的成员中
    ngx_int_t ngx_parse_url(ngx_pool_t *pool, ngx_url_t *u)
    {
        u_char  *p;
     
        p = u->url.data;
     
        //格式: listen unix:/var/run/nginx.sock
        if (ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0)
        {
            return ngx_parse_unix_domain_url(pool, u);
        }
     
        if ((p[0] == ':' || p[0] == '/') && !u->listen) 
        {
            u->err = "invalid host";
            return NGX_ERROR;
        }
     
        //格式: listen [fe80::1];
        if (p[0] == '[')
        {
            return ngx_parse_inet6_url(pool, u);
        }
     
        //根据url获取ipv4格式的地址信息()
        return ngx_parse_inet_url(pool, u);
    }

ngx\_http\_add\_listen这个函数开始就是要创建图中的ports数组内容了，使得nginx能监听不同的端口。  
//将server块添加到监听端口中，表示有多少个server块在监听同一个端口

ngx_int_t ngx_http_add_listen(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
                                            ngx_http_listen_opt_t *lsopt)
    {
        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));
       
        }
     
        sa = &lsopt->u.sockaddr;
        //获取监听端口
        switch (sa->sa_family)
        {
        default: /* AF_INET */
            sin = &lsopt->u.sockaddr_in;
            p = sin->sin_port;
            break;
        }
     
        //查找是否存在相同的监听端口，相同则只添加server块
        port = cmcf->ports->elts;
        for (i = 0; i < cmcf->ports->nelts; i++) 
        {
            if (p != port[i].port || sa->sa_family != port[i].family) 
            {
                continue;
            }
                
            //查找到有多个ip监听同一个端口时的处理逻辑
            return ngx_http_add_addresses(cf, cscf, &port[i], lsopt);
        }
     
        //指向到此，说明没有查找到相同的监听端口,则需要创建一个端口
        port = ngx_array_push(cmcf->ports);
        port->family = sa->sa_family;
        port->port = p;
        port->addrs.elts = NULL;
     
        //如果有多个不同的ip监听同一个端口，则需要把这些ip信息保持到ngx_http_conf_port_t结构中的addrs数组中
        return ngx_http_add_address(cf, cscf, port, lsopt);
    }
            如果有多个不同的ip监听同一个端口，则需要把这些ip信息保持到ngx_http_conf_port_t结构中的addrs数组中。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)
    {
        if (port->addrs.elts == NULL) 
        {
            ngx_array_init(&port->addrs, cf->temp_pool, 4, sizeof(ngx_http_conf_addr_t)
        }
     
        //同一个监听端口，但对于不同的ip逻辑，则需要创建一个ngx_http_conf_addr_t结构。
        //表示有多个ip地址监听同一个端口
        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;        //多个server块监听同一个端口时，有一个默认的server块
        addr->servers.elts = NULL;
     
        //将监听同一个端口的server块加入到server数组中
        return ngx_http_add_server(cf, cscf, addr);
    }
            最终将将监听ip:port的server保存到数组中，则是由ngx_http_add_server这个函数完成。
    //将监听同一个端口的server块加入到server数组中
    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)
        {
            ngx_array_init(&addr->servers, cf->temp_pool, 4, sizeof(ngx_http_core_srv_conf_t *)
        }
        else 
        {
            //查找是否同一个server块两次调用listen监听同一个端口
            //在同一个server块中调用两次listen监听同一个端口是不允许的；例如:
            //listen 80; listen 80；是非法的
            server = addr->servers.elts;
            for (i = 0; i < addr->servers.nelts; i++) 
            {
                if (server[i] == cscf) 
                {
                    return NGX_ERROR;
                }
            }
        }
     
        //获取一个server块
        server = ngx_array_push(&addr->servers);
        if (server == NULL)
        {
            return NGX_ERROR;
        }
        //保存server块，表示这个server块监听ip:portsocket
        *server = cscf;
    }

到此为止，nginx对于监听socket维护的内部结构已经分析完成了。接下里分析下nginx服务器对不同域名的管理  
二、域名管理  
在解析http配置块中，调用了ngx\_http\_optimize\_servers函数，将把各个监听端口下的所有域名加入到相应哈希表中(例如:普通哈希表，前置通配符哈希表，后置通配符哈希表)。这样nginx在收到客户端连接请求时，就可以直接根据http请求头部host字段查找这些哈希表，从而获取到server块，由这个server块处理这个http请求。

//开始解析http块
    static char * ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
    {
    //功能: 将所有监听socket对应的服务器名加入到哈希表中。例如:有80?90两个端口。则将80端口所有server块下的
    //所有服务器名加入到哈希表；将90端口所有server块下的所有服务器名加入到哈希表
        if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK)
        {
            return NGX_CONF_ERROR;
        }
    }

ngx\_http\_optimize\_servers这个函数负责将各个监听端口下的所有域名加入到相应哈希表中；该函数同时也会创建一个监听对象

//功能: 将所有监听socket对应的服务器名加入到哈希表中。例如:有80?90两个端口。则将80端口所有server块下的
    //所有服务器名加入到哈希表；将90端口所有server块下的所有服务器名加入到哈希表
    static ngx_int_t ngx_http_optimize_servers(ngx_conf_t *cf, 
                                    ngx_http_core_main_conf_t *cmcf, ngx_array_t *ports)
    {
        //对于每一个监听端口，都会有对应多个server块监听这个端口。这每一个server块又可能有多少server名称。
        //下面这个循环处理每一个端口，构成一个哈希表
        port = ports->elts;
        for (p = 0; p < ports->nelts; p++)
        {
            //将把监听同一个端口的所有ip信息排序
            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++) 
            {
                //处理监听同一个端口的所有server块，构成一个哈希表
                if (ngx_http_server_names(cf, cmcf, &addr[a]) != NGX_OK) 
                {
                    return NGX_ERROR;
                }
            }
            //创建ngx_listening_s对象，并用port数组给这个对象赋值
            if (ngx_http_init_listening(cf, &port[p]) != NGX_OK)
            {
                return NGX_ERROR;
            }
        }
    }

函数ngx\_http\_server\_names将创建由所有域名构成的普通哈希表，前置通配符哈希表、后置通配符哈希表。这样在收到来自客户端的请求时，可以根据http头部的host字段查找这些哈希表，进而获取到server块。

//创建服务名哈希表
    static ngx_int_t ngx_http_server_names(ngx_conf_t *cf, 
                                                        ngx_http_core_main_conf_t *cmcf,
                                                        ngx_http_conf_addr_t *addr)
    {
        //创建一个哈希数组
        if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) 
        {
            goto failed;
        }
     
        cscfp = addr->servers.elts;
     
        //多个server块监听同一个端口
        for (s = 0; s < addr->servers.nelts; s++) 
        {
            name = cscfp[s]->server_names.elts;
            //每一个server块又可能有多个服务器名
            for (n = 0; n < cscfp[s]->server_names.nelts; n++)
            {
                //将服务器名加入到哈希数组中
                rc = ngx_hash_add_key(&ha, &name[n].name, name[n].server,NGX_HASH_WILDCARD_KEY);
            }
        }
     
        //创建普通哈希表
        if (ha.keys.nelts) 
        {
            hash.hash = &addr->hash;
            hash.temp_pool = NULL;
            if (ngx_hash_init(&hash, ha.keys.elts, ha.keys.nelts) != NGX_OK) 
            {
                goto failed;
            }
        }
        //创建前置哈希表
        if (ha.dns_wc_head.nelts)
        {
            ngx_qsort(ha.dns_wc_head.elts, (size_t) ha.dns_wc_head.nelts,
                      sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);
     
            ngx_hash_wildcard_init(&hash, ha.dns_wc_head.elts, ha.dns_wc_head.nelts);
            addr->wc_head = (ngx_hash_wildcard_t *) hash.hash;
        }
        //创建后置通配符哈希表
        if (ha.dns_wc_tail.nelts) 
        {
            ngx_hash_wildcard_init(&hash, ha.dns_wc_tail.elts,ha.dns_wc_tail.nelts);
            addr->wc_tail = (ngx_hash_wildcard_t *) hash.hash;
        }
    }

三、监听对象的创建

而ngx\_http\_init\_listening函数将创建一个创建一个ngx\_listening\_t对象，并个这个对象的成员赋值。同时将创建后的这个对象存放到cf->cycle->listening这个监听数组中保存。

static ngx_int_t ngx_http_init_listening(ngx_conf_t *cf, ngx_http_conf_port_t *port)
    {
        while (i < last) 
        {
            //创建一个ngx_listening_t对象，并个这个对象的成员赋值。例如设置监听回调
            ls = ngx_http_add_listening(cf, &addr[i]);
            if (ls == NULL)
            {
                return NGX_ERROR;
            }
        }
    }

ngx\_http\_add\_listening函数创建监听对象，并设置监听的回调为ngx\_http\_init\_connection。在监听到客户端的连接时，这个回调将被调用。

//创建一个ngx_listening_t对象，并个这个对象的成员赋值。例如设置监听回调
    static ngx_listening_t * ngx_http_add_listening(ngx_conf_t *cf, ngx_http_conf_addr_t *addr)
    {
        //创建一个ngx_listening_t对象
        ls = ngx_create_listening(cf, &addr->opt.u.sockaddr, addr->opt.socklen);
        ls->addr_ntop = 1;
        //监听回调
        ls->handler = ngx_http_init_connection;
     
        //在有多少server块监听同一个端口时，使用默认块的配置
        cscf = addr->default_server;
        ls->pool_size = cscf->connection_pool_size;
        ls->post_accept_timeout = cscf->client_header_timeout;
     
        return ls;
    }

四、监听socket  
在函数ngx\_init\_cycle有这样的代码段，用来创建socket,绑定socekt,监听socket

//初始化ngx_cycle_t结构
    ngx_cycle_t * ngx_init_cycle(ngx_cycle_t *old_cycle)
    {
        //创建监听数组中的所有socket
        if (ngx_open_listening_sockets(cycle) != NGX_OK)
        {
            goto failed;
        }
     
        //获取发送缓冲区，接收缓冲区大小，以及监听socket
        ngx_configure_listening_sockets(cycle);
    }

而函数ngx\_open\_listening\_sockets将对监听数组中存放的所有ip,port , 执行socket, 绑定socket, 监听socket操作。如果失败，则最多重复执行5次。

//创建监听数组中的所有socket
    ngx_int_t ngx_open_listening_sockets(ngx_cycle_t *cycle)
    {
        //因此创建soceket,绑定socket， 监听socket等操作有可能调用失败。
        //失败后最多尝试5次
        for (tries = 5; tries; tries--) 
        {
            //将对所有监听数组中的ip,port,开始创建socket
            ls = cycle->listening.elts;
            for (i = 0; i < cycle->listening.nelts; i++)
            {
                //创建套接字
                s = ngx_socket(ls[i].sockaddr->sa_family, ls[i].type, 0);
     
                //绑定套接字
                bind(s, ls[i].sockaddr, ls[i].socklen);
     
                //监听套接字
                listen(s, ls[i].backlog);
                ls[i].listen = 1;
     
                ls[i].fd = s;
            }
     
            ngx_msleep(500);
        }
    }

而ngx\_configure\_listening\_sockets(ngx\_cycle\_t \*cycle)函数只是简单设置socket的一些选项，例如设置发送缓冲区，接收缓冲区大小，以及监听队列大小等。  
到此监听事件已经分析完了，至于把监听socket加入到epoll中，则在ngx\_trylock\_accept\_mutex函数中完成。将监听socket加入到epoll在前面的文章中已经分析过了，在这里就不在分析了，可以参考master进程、work进程初始化这两篇文章。  
\---------------------  
作者：ApeLife  
来源：CSDN  
原文：https://blog.csdn.net/apelife/article/details/53647316  
版权声明：本文为博主原创文章，转载请附上博文链接！