Nginx的DNS解析过程分析

Nginx怎么做域名解析？怎么在你自己开发的模块里面使用Nginx提供的方法解析域名？它内部实现是什么样的？

本文以Nginx 1.5.1为例，从nginx_mail_smtp模块如何进行域名解析出发，分析Nginx进行域名解析的过程。为了简化流程，突出重点，在示例代码中省掉了一些异常部分的处理，比如内存分配失败等。DNS查询分为两种：根据域名查询地址和根据地址查询域名，在代码结构上这两种方式非常相似，这里只介绍根据域名查询地址这一种方式。本文将从以下几个方面进行介绍：

1. 域名查询的函数接口介绍
2. 域名解析流程分析
3. 查询场景分析及实现介绍

一、域名查询的函数接口介绍

在使用同步IO的情况下，调用gethostbyname()或者gethostbyname_r()就可以根据域名查询到对应的IP地址, 但因为可能会通过网络进行远程查询，所以需要的时间比较长。

为了不阻塞当前线程，Nginx采用了异步的方式进行域名查询。整个查询过程主要分为三个步骤，这点在各种异步处理时都是一样的：

1. 准备函数调用需要的信息，并设置回调方法
2. 调用函数
3. 处理结束后回调方法被调用

另外，为了尽量减少查询花费的时间，Nginx还对查询结果做了本地缓存。为了初始化DNS Server地址和本地缓存等信息，需要在真正查询前需要先进行一些全局的初始化操作。

下面先从调用者的角度对每个步骤做详细的分析：

1. 初始化域名查询所需要的的全局信息

   需要初始化的全局信息包括：

   • DNS 服务器的地址，如果指定了多个服务器，nginx会采用Round Robin的方式轮流查询每个服务器
   • 对查询结果的缓存，采用Red Black Tree的数据结构，以要查询名字的Hash作为Key, 节点信息存放在 struct ngx_resolver_node_t中。

   因为resolver是全局的，与任何一个connection都无关，所有需要放在一个随时都可以取到的地方，如 ngx_mail_core_srv_conf_t结构体上，在使用时从当前session找到ngx_mail_core_srv_conf_t，然后找到resolver。

   DNS 服务器的信息需要在配置文件中明确指出，比如

   1 2 3 4 5 6

   #nginx.conf   resolver 8.8.8.8 #nginx 默认会根据DNS请求结果里的TTL值来进行缓存， #当然也可以通过一个可选的参数valid来设置过期时间，如: #resolver 127.0.0.1 [::1]:5353 valid=30s;

   下面根据配置中的resolver参数，初始化全局的ngx_resolver_t，其中保存了前面提及的DNS服务器地址和查询结果等信息:

   1 2 3 4 5 6 7 8 9 10 11

   static char * ngx_mail_core_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {      ngx_mail_core_srv_conf_t  *cscf = conf;      ngx_str_t  *value;      value = cf->args->elts;        cscf->resolver = ngx_resolver_create(cf, &value[1],                                           cf->args->nelts - 1);      return NGX_CONF_OK; }

2. 准备本次查询的信息

   和本次查询相关的信息放在ngx_resolver_ctx_t结构体中，包括要查询的名称，查询完的回调方法，以及超时时间等。如果本次要查询的地址已经是IPv4用点分隔的地址了，比如74.125.128.100, nginx会在ngx_resolve_start中进行判断，并设置好标志位，在调用ngx_resolve_name时不会发送真正的DNS查询请求。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   static void ngx_mail_smtp_resolve_name(ngx_event_t *rev) {      ngx_connection_t          *c;      ngx_mail_session_t        *s;      ngx_resolver_ctx_t        *ctx;      ngx_mail_core_srv_conf_t  *cscf;        c = rev->data;      s = c->data;        cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);        ctx = ngx_resolve_start(cscf->resolver, NULL);      if (ctx == NULL) {          ngx_mail_close_connection(c);          return ;      }        ctx->name = s->host;      ctx->type = NGX_RESOLVE_A;      ctx->handler = ngx_mail_smtp_resolve_name_handler;      ctx->data = s;      ctx->timeout = cscf->resolver_timeout;        //根据名字进行IP地址查询      if (ngx_resolve_name(ctx) != NGX_OK) {          ngx_mail_close_connection(c);      } }

3. 根据名字进行IP地址查询

   前面方法的最后通过ngx_resolve_name方法进行IP地址查询。查询时，Nginx会先检查本地缓存，如果在缓存中，就更新缓存过期时间，并回调设置的handler, 如前面设置的：ngx_mail_smtp_resolve_name_handler，然后整个查询过程结束。如果没有在缓存中就发送查询请求给dns server，同时方法返回。

4. 查询完成后回调在ngx_resolver_ctx_t中指定的方法

   真正的DNS查询完成后，不管成功，失败或是超时，nginx会回调相应查询的handler, 如前面设置的：ngx_mail_smtp_resolve_name_handler。在handler中都需要调用ngx_resolve_addr_done来标识查询结束。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

   static void ngx_mail_smtp_resolve_name_handler(ngx_resolver_ctx_t *ctx) {      in_addr_t            addr;      ngx_uint_t           i;      ngx_connection_t    *c;      struct sockaddr_in  * sin ;      ngx_mail_session_t  *s;        s = ctx->data;      c = s->connection;        if (ctx->state) {          ngx_log_error(NGX_LOG_ERR, c-> log , 0,                        "" %V " could not be resolved (%i: %s)" ,                        &ctx->name, ctx->state,                        ngx_resolver_strerror(ctx->state));      } else {          /* AF_INET only */          sin = ( struct sockaddr_in *) c->sockaddr;            for (i = 0; i < ctx->naddrs; i++) {              addr = ctx->addrs[i];                ngx_log_debug4(NGX_LOG_DEBUG_MAIL, c-> log , 0,                             "name was resolved to %ud.%ud.%ud.%ud" ,                             (ntohl(addr) >> 24) & 0xff,                             (ntohl(addr) >> 16) & 0xff,                             (ntohl(addr) >> 8) & 0xff,                             ntohl(addr) & 0xff);                if (addr == sin ->sin_addr.s_addr) {                  goto found;              }          }            s->host = smtp_unavailable;      }   found:      //不管成功失败都要执行      ngx_resolve_name_done(ctx); }

二、域名解析流程分析

通过Nginx进行域名查询的流程图如下，颜色越深花费的时间越长。调用过程分为三种：

1. 首先判断是不是IPv4地址，如果是就直接调用Handler
2. 再次检查是不是在缓存中，如果有，就调用Handler
3. 最后发送远程DNS请求，收到回复后调用Handler

三、查询场景分析及实现介绍

1. 查询的地址是IP v4地址

   比如74.125.128.100, nginx会在ngx_resolve_start中通过ngx_inet_addr方法进行判断，如果是IPv4的地址，就设置好标志位 ngx_resolver_ctx_t->quick，在接下来的ngx_resolve_name中会对这个标志位进行判断，如果为1，就直接调用ngx_resolver_ctx_t->handler

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   ngx_resolver_ctx_t * ngx_resolve_start(ngx_resolver_t *r, ngx_resolver_ctx_t *temp) {      in_addr_t            addr;      ngx_resolver_ctx_t  *ctx;        if (temp) {          addr = ngx_inet_addr(temp->name.data, temp->name.len);            if (addr != INADDR_NONE) {              temp->resolver = r;              temp->state = NGX_OK;              temp->naddrs = 1;              temp->addrs = &temp->addr;              temp->addr = addr;              temp->quick = 1;                return temp;          }      }      ... }

2. 超时没有得到查询结果

   调用ngx_resolve_name时设置的回调方法被调用，同时ngx_resolver_ctx_t->state被设置为NGX_RESOLVE_TIMEDOUT。相应的代码为：

   1 2 3 4 5 6 7 8

   static void ngx_resolver_timeout_handler(ngx_event_t *ev) {      ngx_resolver_ctx_t  *ctx;      ctx = ev->data;      ctx->state = NGX_RESOLVE_TIMEDOUT;      ctx->handler(ctx); }

3. 正常查询一个不在缓存中的域名

   如果要查询的域名不在缓存中，首先把域名按hash值放在缓存中，然后准备查询需要的数据，发送DNS查询的UDP请求给DNS服务器，

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

   static ngx_int_t ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx) {      ngx_resolver_node_t  *rn;      rn = ngx_resolver_alloc(r, sizeof (ngx_resolver_node_t));      ngx_rbtree_insert(&r->name_rbtree, &rn->node);      ngx_resolver_create_name_query(rn, ctx);      ngx_resolver_send_query(r, rn);        rn->cnlen = 0;      rn->naddrs = 0;      rn->valid = 0;      rn->waiting = ctx;        ctx->state = NGX_AGAIN; }   //收到DNS查询结果后的回调方法 static void ngx_resolver_read_response(ngx_event_t *rev) {      ssize_t            n;      ngx_connection_t  *c;      u_char             buf[NGX_RESOLVER_UDP_SIZE];      c = rev->data;        do {          n = ngx_udp_recv(c, buf, NGX_RESOLVER_UDP_SIZE);          if (n < 0) {              return ;          }            ngx_resolver_process_response(c->data, buf, n);      } while (rev->ready); }   static void ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,      ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan, ngx_uint_t ans) {      hash = ngx_crc32_short(name.data, name.len);      rn = ngx_resolver_lookup_name(r, &name, hash);        //copy addresses to cached node      rn->u.addrs = addrs;        //回调所有等待本域名解析的请求      next = rn->waiting;      rn->waiting = NULL;        while (next) {           ctx = next;           ctx->state = NGX_OK;           ctx->naddrs = naddrs;           ctx->addrs = (naddrs == 1) ? &ctx->addr : addrs;           ctx->addr = addr;           next = ctx->next;             ctx->handler(ctx);      } }

4. 对同一域名查询多次查询

   如果多次查询时，之前的查询结果还在缓存中并且没有失效，就直接从缓存中取到查询结果，并调用设置的回调方法。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   static ngx_int_t ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx) {      uint32_t              hash;      in_addr_t             addr, *addrs;      ngx_uint_t            naddrs;      ngx_resolver_ctx_t   *next;      ngx_resolver_node_t  *rn;        hash = ngx_crc32_short(ctx->name.data, ctx->name.len);      rn = ngx_resolver_lookup_name(r, &ctx->name, hash);        if (rn) {          if (rn->valid >= ngx_time()) {              naddrs = rn->naddrs;                if (naddrs) {                  ctx->next = rn->waiting;                  rn->waiting = NULL;                    do {                      ctx->state = NGX_OK;                      ctx->naddrs = naddrs;                      ctx->addrs = (naddrs == 1) ? &ctx->addr : addrs;                      ctx->addr = addr;                      next = ctx->next;                        ctx->handler(ctx);                        ctx = next;                  } while (ctx);                    return NGX_OK;              }          }      } }

5. 得到查询结果时同时超时了

   如果在得到查询结果的同时，设置的超时时间也到期了，那该怎么办呢？ Nginx会先处理各种网络读写事件，再处理超时事件，在处理网络事件时，会相应地把设置的定时器删除，所以在执行超时事件时就不会再执行了。

   1 2 3 4 5 6 7 8 9 10 11 12

   void ngx_process_events_and_timers(ngx_cycle_t *cycle) {      ngx_uint_t  flags;      ngx_msec_t  timer, delta;        //处理各种网络事件      ( void ) ngx_process_events(cycle, timer, flags);        //处理各种timer事件，其中包含了查询超时      ngx_event_expire_timers(); }

6. 得到查询结果时客户端已经关闭连接

   如果不做任何处理，那么在收到dns查询结果后，会回调查询时设置的回调方法，但因为连接已经被关闭，相应的内存已经被释放，所以会有非法内存访问的问题。怎么避免呢？在处理连接关闭事件时，同时需要调用ngx_resolve_name_done(ctx)方法,调用时需要把state设为NGX_AGAIN或者NGX_RESOLVE_TIMEDOUT，这样就会删除查询所设置的回调信息:

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

   void ngx_close_xxx_session(ngx_xxx_session_t *s) {      if (s->resolver_ctx != NULL) {          s->resolver_ctx->state = NGX_RESOLVE_TIMEDOUT;          ngx_resolve_name_done(s->resolver_ctx);          s->resolver_ctx = NULL;      } }   void ngx_resolve_name_done(ngx_resolver_ctx_t *ctx) {      uint32_t              hash;      ngx_resolver_t       *r;      ngx_resolver_ctx_t   *w, **p;      ngx_resolver_node_t  *rn;        r = ctx->resolver;      if (ctx->state == NGX_AGAIN || ctx->state == NGX_RESOLVE_TIMEDOUT) {          hash = ngx_crc32_short(ctx->name.data, ctx->name.len);          rn = ngx_resolver_lookup_name(r, &ctx->name, hash);            if (rn) {              p = &rn->waiting;              w = rn->waiting;                while (w) {                  if (w == ctx) {                      *p = w->next;                      goto done;                  }                    p = &w->next;                  w = w->next;              }          }      }   done:      ngx_resolver_free_locked(r, ctx); }

7. 本地缓存的地址没有再次被查询

   每次在查询结束的时候（调用ngx_resolve_addr_done），都会检查有没有缓存过期，如果有，就会进行释放。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   static void ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree,                      ngx_queue_t *queue) {      time_t                now;      ngx_uint_t            i;      ngx_queue_t          *q;      ngx_resolver_node_t  *rn;      now = ngx_time();        for (i = 0; i < 2; i++) {          if (ngx_queue_empty(queue)) {              return ;          }            q = ngx_queue_last(queue);          rn = ngx_queue_data(q, ngx_resolver_node_t, queue);            if (now <= rn->expire) {              return ;          }            ngx_log_debug2(NGX_LOG_DEBUG_CORE, r-> log , 0,              "resolver expire " %*s "" , ( size_t ) rn->nlen, rn->name);            ngx_queue_remove(q);          ngx_rbtree_delete(tree, &rn->node);          ngx_resolver_free_node(r, rn);      } }

8. 域名对应这多个IP地址

   如果对应的有多个ip,那么在每次查询时，会随机的重新排列顺序，然后返回。对于调用者来说，只要去第一个地址，就可以达到取随机地址的目的了。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   static ngx_int_t ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx) {      if (naddrs) {          if (naddrs != 1) {              addr = 0;              addrs = ngx_resolver_rotate(r, rn->u.addrs, naddrs);              if (addrs == NULL) {                  return NGX_ERROR;              }            } else {              addr = rn->u.addr;              addrs = NULL;          }      } }   static in_addr_t * ngx_resolver_rotate(ngx_resolver_t *r, in_addr_t *src, ngx_uint_t n) {      void        *dst, *p;      ngx_uint_t   j;        dst = ngx_resolver_alloc(r, n * sizeof (in_addr_t));      j = ngx_random() % n;        if (j == 0) {          ngx_memcpy(dst, src, n * sizeof (in_addr_t));          return dst;      }        p = ngx_cpymem(dst, &src[j], (n - j) * sizeof (in_addr_t));      ngx_memcpy(p, src, j * sizeof (in_addr_t));        return dst; }

9. 指定了多个dns server地址会怎么查询

   如果在配置文件里指定了多个dns server地址会发生什么呢？比如

   1 2	#nginx.conf resolver 8.8.8.8 8.8.4.4

   那么nginx 会采用Round Robin 的方式轮流查询各个dns server。在方法ngx_resolver_send_query中通过在每次调用时改变last_connection来轮流使用不同的dns server进行查询

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   static ngx_int_t ngx_resolver_send_query(ngx_resolver_t *r, ngx_resolver_node_t *rn) {      ssize_t                n;      ngx_udp_connection_t  *uc;        uc = r->udp_connections.elts;        uc = &uc[r->last_connection++];      if (r->last_connection == r->udp_connections.nelts) {          r->last_connection = 0;      }      ... }   http://theantway.com/2013/09/understanding_the_dns_resolving_in_nginx/