One Level Up Top Level

src/core/ngx_resolver.c - nginx-1.7.10

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>


  13. ‌#define NGX_RESOLVER_UDP_SIZE   4096


  16. typedef struct {
  17.     u_char  ident_hi;
  18.     u_char  ident_lo;
  19.     u_char  flags_hi;
  20.     u_char  flags_lo;
  21.     u_char  nqs_hi;
  22.     u_char  nqs_lo;
  23.     u_char  nan_hi;
  24.     u_char  nan_lo;
  25.     u_char  nns_hi;
  26.     u_char  nns_lo;
  27.     u_char  nar_hi;
  28.     u_char  nar_lo;
  29. ‌} ngx_resolver_hdr_t;


  32. typedef struct {
  33.     u_char  type_hi;
  34.     u_char  type_lo;
  35.     u_char  class_hi;
  36.     u_char  class_lo;
  37. ‌} ngx_resolver_qs_t;


  40. typedef struct {
  41.     u_char  type_hi;
  42.     u_char  type_lo;
  43.     u_char  class_hi;
  44.     u_char  class_lo;
  45.     u_char  ttl[4];
  46.     u_char  len_hi;
  47.     u_char  len_lo;
  48. ‌} ngx_resolver_an_t;


  51. ‌#define ngx_resolver_node(n)                                                 \
  52.     (ngx_resolver_node_t *)                                                  \
  53.         ((u_char *) (n) - offsetof(ngx_resolver_node_t, node))


  56. ngx_int_t ngx_udp_connect(ngx_udp_connection_t *uc);


  59. static void ngx_resolver_cleanup(void *data);
  60. static void ngx_resolver_cleanup_tree(ngx_resolver_t *r, ngx_rbtree_t *tree);
  61. static ngx_int_t ngx_resolve_name_locked(ngx_resolver_t *r,
  62.     ngx_resolver_ctx_t *ctx);
  63. static void ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree,
  64.     ngx_queue_t *queue);
  65. static ngx_int_t ngx_resolver_send_query(ngx_resolver_t *r,
  66.     ngx_resolver_node_t *rn);
  67. static ngx_int_t ngx_resolver_create_name_query(ngx_resolver_node_t *rn,
  68.     ngx_resolver_ctx_t *ctx);
  69. static ngx_int_t ngx_resolver_create_addr_query(ngx_resolver_node_t *rn,
  70.     ngx_resolver_ctx_t *ctx);
  71. static void ngx_resolver_resend_handler(ngx_event_t *ev);
  72. static time_t ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree,
  73.     ngx_queue_t *queue);
  74. static void ngx_resolver_read_response(ngx_event_t *rev);
  75. static void ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf,
  76.     size_t n);
  77. static void ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
  78.     ngx_uint_t ident, ngx_uint_t code, ngx_uint_t qtype,
  79.     ngx_uint_t nan, ngx_uint_t ans);
  80. static void ngx_resolver_process_ptr(ngx_resolver_t *r, u_char *buf, size_t n,
  81.     ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan);
  82. static ngx_resolver_node_t *ngx_resolver_lookup_name(ngx_resolver_t *r,
  83.     ngx_str_t *name, uint32_t hash);
  84. static ngx_resolver_node_t *ngx_resolver_lookup_addr(ngx_resolver_t *r,
  85.     in_addr_t addr);
  86. static void ngx_resolver_rbtree_insert_value(ngx_rbtree_node_t *temp,
  87.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
  88. static ngx_int_t ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name,
  89.     u_char *buf, u_char *src, u_char *last);
  90. static void ngx_resolver_timeout_handler(ngx_event_t *ev);
  91. static void ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn);
  92. static void *ngx_resolver_alloc(ngx_resolver_t *r, size_t size);
  93. static void *ngx_resolver_calloc(ngx_resolver_t *r, size_t size);
  94. static void ngx_resolver_free(ngx_resolver_t *r, void *p);
  95. static void ngx_resolver_free_locked(ngx_resolver_t *r, void *p);
  96. static void *ngx_resolver_dup(ngx_resolver_t *r, void *src, size_t size);
  97. static ngx_addr_t *ngx_resolver_export(ngx_resolver_t *r,
  98.     ngx_resolver_node_t *rn, ngx_uint_t rotate);
  99. static u_char *ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len);

  101. #if (NGX_HAVE_INET6)
  102. static void ngx_resolver_rbtree_insert_addr6_value(ngx_rbtree_node_t *temp,
  103.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
  104. static ngx_resolver_node_t *ngx_resolver_lookup_addr6(ngx_resolver_t *r,
  105.     struct in6_addr *addr, uint32_t hash);
  106. #endif


  109. ngx_resolver_t *
  110. ‌ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
  111. {
  112.     ngx_str_t              s;
  113.     ngx_url_t              u;
  114.     ngx_uint_t             i, j;
  115.     ngx_resolver_t        *r;
  116.     ngx_pool_cleanup_t    *cln;
  117.     ngx_udp_connection_t  *uc;

  119.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  120.     if (cln == NULL) {
  121.         return NULL;
  122.     }

  124.     cln->handler = ngx_resolver_cleanup;

  126.     r = ngx_calloc(sizeof(ngx_resolver_t), cf->log);
  127.     if (r == NULL) {
  128.         return NULL;
  129.     }

  131.     cln->data = r;

  133.     r->event = ngx_calloc(sizeof(ngx_event_t), cf->log);
  134.     if (r->event == NULL) {
  135.         return NULL;
  136.     }

  138.     ngx_rbtree_init(&r->name_rbtree, &r->name_sentinel,
  139.                     ngx_resolver_rbtree_insert_value);

  141.     ngx_rbtree_init(&r->addr_rbtree, &r->addr_sentinel,
  142.                     ngx_rbtree_insert_value);

  144.     ngx_queue_init(&r->name_resend_queue);
  145.     ngx_queue_init(&r->addr_resend_queue);

  147.     ngx_queue_init(&r->name_expire_queue);
  148.     ngx_queue_init(&r->addr_expire_queue);

  150. #if (NGX_HAVE_INET6)
  151.     r->ipv6 = 1;

  153.     ngx_rbtree_init(&r->addr6_rbtree, &r->addr6_sentinel,
  154.                     ngx_resolver_rbtree_insert_addr6_value);

  156.     ngx_queue_init(&r->addr6_resend_queue);

  158.     ngx_queue_init(&r->addr6_expire_queue);
  159. #endif

  161.     r->event->handler = ngx_resolver_resend_handler;
  162.     r->event->data = r;
  163.     r->event->log = &cf->cycle->new_log;
  164.     r->ident = -1;

  166.     r->resend_timeout = 5;
  167.     r->expire = 30;
  168.     r->valid = 0;

  170.     r->log = &cf->cycle->new_log;
  171.     r->log_level = NGX_LOG_ERR;

  173.     if (n) {
  174.         if (ngx_array_init(&r->udp_connections, cf->pool, n,
  175.                            sizeof(ngx_udp_connection_t))
  176.             != NGX_OK)
  177.         {
  178.             return NULL;
  179.         }
  180.     }

  182.     for (i = 0; i < n; i++) {
  183.         if (ngx_strncmp(names[i].data, "valid=", 6) == 0) {
  184.             s.len = names[i].len - 6;
  185.             s.data = names[i].data + 6;

  187.             r->valid = ngx_parse_time(&s, 1);

  189.             if (r->valid == (time_t) NGX_ERROR) {
  190.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  191.                                    "invalid parameter: %V", &names[i]);
  192.                 return NULL;
  193.             }

  195.             continue;
  196.         }

  198. #if (NGX_HAVE_INET6)
  199.         if (ngx_strncmp(names[i].data, "ipv6=", 5) == 0) {

  201.             if (ngx_strcmp(&names[i].data[5], "on") == 0) {
  202.                 r->ipv6 = 1;

  204.             } else if (ngx_strcmp(&names[i].data[5], "off") == 0) {
  205.                 r->ipv6 = 0;

  207.             } else {
  208.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  209.                                    "invalid parameter: %V", &names[i]);
  210.                 return NULL;
  211.             }

  213.             continue;
  214.         }
  215. #endif

  217.         ngx_memzero(&u, sizeof(ngx_url_t));

  219.         u.url = names[i];
  220.         u.default_port = 53;

  222.         if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  223.             if (u.err) {
  224.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  225.                                    "%s in resolver \"%V\"",
  226.                                    u.err, &u.url);
  227.             }

  229.             return NULL;
  230.         }

  232.         uc = ngx_array_push_n(&r->udp_connections, u.naddrs);
  233.         if (uc == NULL) {
  234.             return NULL;
  235.         }

  237.         ngx_memzero(uc, u.naddrs * sizeof(ngx_udp_connection_t));

  239.         for (j = 0; j < u.naddrs; j++) {
  240.             uc[j].sockaddr = u.addrs[j].sockaddr;
  241.             uc[j].socklen = u.addrs[j].socklen;
  242.             uc[j].server = u.addrs[j].name;
  243.         }
  244.     }

  246.     return r;
  247. }


  250. static void
  251. ‌ngx_resolver_cleanup(void *data)
  252. {
  253.     ngx_resolver_t  *r = data;

  255.     ngx_uint_t             i;
  256.     ngx_udp_connection_t  *uc;

  258.     if (r) {
  259.         ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
  260.                        "cleanup resolver");

  262.         ngx_resolver_cleanup_tree(r, &r->name_rbtree);

  264.         ngx_resolver_cleanup_tree(r, &r->addr_rbtree);

  266. #if (NGX_HAVE_INET6)
  267.         ngx_resolver_cleanup_tree(r, &r->addr6_rbtree);
  268. #endif

  270.         if (r->event) {
  271.             ngx_free(r->event);
  272.         }


  275.         uc = r->udp_connections.elts;

  277.         for (i = 0; i < r->udp_connections.nelts; i++) {
  278.             if (uc[i].connection) {
  279.                 ngx_close_connection(uc[i].connection);
  280.             }
  281.         }

  283.         ngx_free(r);
  284.     }
  285. }


  288. static void
  289. ‌ngx_resolver_cleanup_tree(ngx_resolver_t *r, ngx_rbtree_t *tree)
  290. {
  291.     ngx_resolver_ctx_t   *ctx, *next;
  292.     ngx_resolver_node_t  *rn;

  294.     while (tree->root != tree->sentinel) {

  296.         rn = ngx_resolver_node(ngx_rbtree_min(tree->root, tree->sentinel));

  298.         ngx_queue_remove(&rn->queue);

  300.         for (ctx = rn->waiting; ctx; ctx = next) {
  301.             next = ctx->next;

  303.             if (ctx->event) {
  304.                 ngx_resolver_free(r, ctx->event);
  305.             }

  307.             ngx_resolver_free(r, ctx);
  308.         }

  310.         ngx_rbtree_delete(tree, &rn->node);

  312.         ngx_resolver_free_node(r, rn);
  313.     }
  314. }


  317. ngx_resolver_ctx_t *
  318. ‌ngx_resolve_start(ngx_resolver_t *r, ngx_resolver_ctx_t *temp)
  319. {
  320.     in_addr_t            addr;
  321.     ngx_resolver_ctx_t  *ctx;

  323.     if (temp) {
  324.         addr = ngx_inet_addr(temp->name.data, temp->name.len);

  326.         if (addr != INADDR_NONE) {
  327.             temp->resolver = r;
  328.             temp->state = NGX_OK;
  329.             temp->naddrs = 1;
  330.             temp->addrs = &temp->addr;
  331.             temp->addr.sockaddr = (struct sockaddr *) &temp->sin;
  332.             temp->addr.socklen = sizeof(struct sockaddr_in);
  333.             ngx_memzero(&temp->sin, sizeof(struct sockaddr_in));
  334.             temp->sin.sin_family = AF_INET;
  335.             temp->sin.sin_addr.s_addr = addr;
  336.             temp->quick = 1;

  338.             return temp;
  339.         }
  340.     }

  342.     if (r->udp_connections.nelts == 0) {
  343.         return NGX_NO_RESOLVER;
  344.     }

  346.     ctx = ngx_resolver_calloc(r, sizeof(ngx_resolver_ctx_t));

  348.     if (ctx) {
  349.         ctx->resolver = r;
  350.     }

  352.     return ctx;
  353. }


  356. ngx_int_t
  357. ‌ngx_resolve_name(ngx_resolver_ctx_t *ctx)
  358. {
  359.     ngx_int_t        rc;
  360.     ngx_resolver_t  *r;

  362.     r = ctx->resolver;

  364.     if (ctx->name.len > 0 && ctx->name.data[ctx->name.len - 1] == '.') {
  365.         ctx->name.len--;
  366.     }

  368.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
  369.                    "resolve: \"%V\"", &ctx->name);

  371.     if (ctx->quick) {
  372.         ctx->handler(ctx);
  373.         return NGX_OK;
  374.     }

  376.     /* lock name mutex */

  378.     rc = ngx_resolve_name_locked(r, ctx);

  380.     if (rc == NGX_OK) {
  381.         return NGX_OK;
  382.     }

  384.     /* unlock name mutex */

  386.     if (rc == NGX_AGAIN) {
  387.         return NGX_OK;
  388.     }

  390.     /* NGX_ERROR */

  392.     if (ctx->event) {
  393.         ngx_resolver_free(r, ctx->event);
  394.     }

  396.     ngx_resolver_free(r, ctx);

  398.     return NGX_ERROR;
  399. }


  402. void
  403. ‌ngx_resolve_name_done(ngx_resolver_ctx_t *ctx)
  404. {
  405.     uint32_t              hash;
  406.     ngx_resolver_t       *r;
  407.     ngx_resolver_ctx_t   *w, **p;
  408.     ngx_resolver_node_t  *rn;

  410.     r = ctx->resolver;

  412.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
  413.                    "resolve name done: %i", ctx->state);

  415.     if (ctx->quick) {
  416.         return;
  417.     }

  419.     if (ctx->event && ctx->event->timer_set) {
  420.         ngx_del_timer(ctx->event);
  421.     }

  423.     /* lock name mutex */

  425.     if (ctx->state == NGX_AGAIN) {

  427.         hash = ngx_crc32_short(ctx->name.data, ctx->name.len);

  429.         rn = ngx_resolver_lookup_name(r, &ctx->name, hash);

  431.         if (rn) {
  432.             p = &rn->waiting;
  433.             w = rn->waiting;

  435.             while (w) {
  436.                 if (w == ctx) {
  437.                     *p = w->next;

  439.                     goto done;
  440.                 }

  442.                 p = &w->next;
  443.                 w = w->next;
  444.             }
  445.         }

  447.         ngx_log_error(NGX_LOG_ALERT, r->log, 0,
  448.                       "could not cancel %V resolving", &ctx->name);
  449.     }

  451. done:

  453.     ngx_resolver_expire(r, &r->name_rbtree, &r->name_expire_queue);

  455.     /* unlock name mutex */

  457.     /* lock alloc mutex */

  459.     if (ctx->event) {
  460.         ngx_resolver_free_locked(r, ctx->event);
  461.     }

  463.     ngx_resolver_free_locked(r, ctx);

  465.     /* unlock alloc mutex */
  466. }


  469. static ngx_int_t
  470. ‌ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx)
  471. {
  472.     uint32_t              hash;
  473.     ngx_int_t             rc;
  474.     ngx_uint_t            naddrs;
  475.     ngx_addr_t           *addrs;
  476.     ngx_resolver_ctx_t   *next;
  477.     ngx_resolver_node_t  *rn;

  479.     ngx_strlow(ctx->name.data, ctx->name.data, ctx->name.len);

  481.     hash = ngx_crc32_short(ctx->name.data, ctx->name.len);

  483.     rn = ngx_resolver_lookup_name(r, &ctx->name, hash);

  485.     if (rn) {

  487.         if (rn->valid >= ngx_time()) {

  489.             ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolve cached");

  491.             ngx_queue_remove(&rn->queue);

  493.             rn->expire = ngx_time() + r->expire;

  495.             ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);

  497.             naddrs = (rn->naddrs == (u_short) -1) ? 0 : rn->naddrs;
  498. #if (NGX_HAVE_INET6)
  499.             naddrs += (rn->naddrs6 == (u_short) -1) ? 0 : rn->naddrs6;
  500. #endif

  502.             if (naddrs) {

  504.                 if (naddrs == 1 && rn->naddrs == 1) {
  505.                     addrs = NULL;

  507.                 } else {
  508.                     addrs = ngx_resolver_export(r, rn, 1);
  509.                     if (addrs == NULL) {
  510.                         return NGX_ERROR;
  511.                     }
  512.                 }

  514.                 ctx->next = rn->waiting;
  515.                 rn->waiting = NULL;

  517.                 /* unlock name mutex */

  519.                 do {
  520.                     ctx->state = NGX_OK;
  521.                     ctx->naddrs = naddrs;

  523.                     if (addrs == NULL) {
  524.                         ctx->addrs = &ctx->addr;
  525.                         ctx->addr.sockaddr = (struct sockaddr *) &ctx->sin;
  526.                         ctx->addr.socklen = sizeof(struct sockaddr_in);
  527.                         ngx_memzero(&ctx->sin, sizeof(struct sockaddr_in));
  528.                         ctx->sin.sin_family = AF_INET;
  529.                         ctx->sin.sin_addr.s_addr = rn->u.addr;

  531.                     } else {
  532.                         ctx->addrs = addrs;
  533.                     }

  535.                     next = ctx->next;

  537.                     ctx->handler(ctx);

  539.                     ctx = next;
  540.                 } while (ctx);

  542.                 if (addrs != NULL) {
  543.                     ngx_resolver_free(r, addrs->sockaddr);
  544.                     ngx_resolver_free(r, addrs);
  545.                 }

  547.                 return NGX_OK;
  548.             }

  550.             /* NGX_RESOLVE_CNAME */

  552.             if (ctx->recursion++ < NGX_RESOLVER_MAX_RECURSION) {

  554.                 ctx->name.len = rn->cnlen;
  555.                 ctx->name.data = rn->u.cname;

  557.                 return ngx_resolve_name_locked(r, ctx);
  558.             }

  560.             ctx->next = rn->waiting;
  561.             rn->waiting = NULL;

  563.             /* unlock name mutex */

  565.             do {
  566.                 ctx->state = NGX_RESOLVE_NXDOMAIN;
  567.                 next = ctx->next;

  569.                 ctx->handler(ctx);

  571.                 ctx = next;
  572.             } while (ctx);

  574.             return NGX_OK;
  575.         }

  577.         if (rn->waiting) {

  579.             ctx->next = rn->waiting;
  580.             rn->waiting = ctx;
  581.             ctx->state = NGX_AGAIN;

  583.             return NGX_AGAIN;
  584.         }

  586.         ngx_queue_remove(&rn->queue);

  588.         /* lock alloc mutex */

  590.         if (rn->query) {
  591.             ngx_resolver_free_locked(r, rn->query);
  592.             rn->query = NULL;
  593. #if (NGX_HAVE_INET6)
  594.             rn->query6 = NULL;
  595. #endif
  596.         }

  598.         if (rn->cnlen) {
  599.             ngx_resolver_free_locked(r, rn->u.cname);
  600.         }

  602.         if (rn->naddrs > 1 && rn->naddrs != (u_short) -1) {
  603.             ngx_resolver_free_locked(r, rn->u.addrs);
  604.         }

  606. #if (NGX_HAVE_INET6)
  607.         if (rn->naddrs6 > 1 && rn->naddrs6 != (u_short) -1) {
  608.             ngx_resolver_free_locked(r, rn->u6.addrs6);
  609.         }
  610. #endif

  612.         /* unlock alloc mutex */

  614.     } else {

  616.         rn = ngx_resolver_alloc(r, sizeof(ngx_resolver_node_t));
  617.         if (rn == NULL) {
  618.             return NGX_ERROR;
  619.         }

  621.         rn->name = ngx_resolver_dup(r, ctx->name.data, ctx->name.len);
  622.         if (rn->name == NULL) {
  623.             ngx_resolver_free(r, rn);
  624.             return NGX_ERROR;
  625.         }

  627.         rn->node.key = hash;
  628.         rn->nlen = (u_short) ctx->name.len;
  629.         rn->query = NULL;
  630. #if (NGX_HAVE_INET6)
  631.         rn->query6 = NULL;
  632. #endif

  634.         ngx_rbtree_insert(&r->name_rbtree, &rn->node);
  635.     }

  637.     rc = ngx_resolver_create_name_query(rn, ctx);

  639.     if (rc == NGX_ERROR) {
  640.         goto failed;
  641.     }

  643.     if (rc == NGX_DECLINED) {
  644.         ngx_rbtree_delete(&r->name_rbtree, &rn->node);

  646.         ngx_resolver_free(r, rn->query);
  647.         ngx_resolver_free(r, rn->name);
  648.         ngx_resolver_free(r, rn);

  650.         ctx->state = NGX_RESOLVE_NXDOMAIN;
  651.         ctx->handler(ctx);

  653.         return NGX_OK;
  654.     }

  656.     rn->naddrs = (u_short) -1;
  657. #if (NGX_HAVE_INET6)
  658.     rn->naddrs6 = r->ipv6 ? (u_short) -1 : 0;
  659. #endif

  661.     if (ngx_resolver_send_query(r, rn) != NGX_OK) {
  662.         goto failed;
  663.     }

  665.     if (ctx->event == NULL) {
  666.         ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
  667.         if (ctx->event == NULL) {
  668.             goto failed;
  669.         }

  671.         ctx->event->handler = ngx_resolver_timeout_handler;
  672.         ctx->event->data = rn;
  673.         ctx->event->log = r->log;
  674.         rn->ident = -1;

  676.         ngx_add_timer(ctx->event, ctx->timeout);
  677.     }

  679.     if (ngx_queue_empty(&r->name_resend_queue)) {
  680.         ngx_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
  681.     }

  683.     rn->expire = ngx_time() + r->resend_timeout;

  685.     ngx_queue_insert_head(&r->name_resend_queue, &rn->queue);

  687.     rn->code = 0;
  688.     rn->cnlen = 0;
  689.     rn->valid = 0;
  690.     rn->ttl = NGX_MAX_UINT32_VALUE;
  691.     rn->waiting = ctx;

  693.     ctx->state = NGX_AGAIN;

  695.     return NGX_AGAIN;

  697. failed:

  699.     ngx_rbtree_delete(&r->name_rbtree, &rn->node);

  701.     if (rn->query) {
  702.         ngx_resolver_free(r, rn->query);
  703.     }

  705.     ngx_resolver_free(r, rn->name);

  707.     ngx_resolver_free(r, rn);

  709.     return NGX_ERROR;
  710. }


  713. ngx_int_t
  714. ‌ngx_resolve_addr(ngx_resolver_ctx_t *ctx)
  715. {
  716.     u_char               *name;
  717.     in_addr_t             addr;
  718.     ngx_queue_t          *resend_queue, *expire_queue;
  719.     ngx_rbtree_t         *tree;
  720.     ngx_resolver_t       *r;
  721.     struct sockaddr_in   *sin;
  722.     ngx_resolver_node_t  *rn;
  723. #if (NGX_HAVE_INET6)
  724.     uint32_t              hash;
  725.     struct sockaddr_in6  *sin6;
  726. #endif

  728. #if (NGX_SUPPRESS_WARN)
  729.     addr = 0;
  730. #if (NGX_HAVE_INET6)
  731.     hash = 0;
  732.     sin6 = NULL;
  733. #endif
  734. #endif

  736.     r = ctx->resolver;

  738.     switch (ctx->addr.sockaddr->sa_family) {

  740. #if (NGX_HAVE_INET6)
  741.     case AF_INET6:
  742.         sin6 = (struct sockaddr_in6 *) ctx->addr.sockaddr;
  743.         hash = ngx_crc32_short(sin6->sin6_addr.s6_addr, 16);

  745.         /* lock addr mutex */

  747.         rn = ngx_resolver_lookup_addr6(r, &sin6->sin6_addr, hash);

  749.         tree = &r->addr6_rbtree;
  750.         resend_queue = &r->addr6_resend_queue;
  751.         expire_queue = &r->addr6_expire_queue;

  753.         break;
  754. #endif

  756.     default: /* AF_INET */
  757.         sin = (struct sockaddr_in *) ctx->addr.sockaddr;
  758.         addr = ntohl(sin->sin_addr.s_addr);

  760.         /* lock addr mutex */

  762.         rn = ngx_resolver_lookup_addr(r, addr);

  764.         tree = &r->addr_rbtree;
  765.         resend_queue = &r->addr_resend_queue;
  766.         expire_queue = &r->addr_expire_queue;
  767.     }

  769.     if (rn) {

  771.         if (rn->valid >= ngx_time()) {

  773.             ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolve cached");

  775.             ngx_queue_remove(&rn->queue);

  777.             rn->expire = ngx_time() + r->expire;

  779.             ngx_queue_insert_head(expire_queue, &rn->queue);

  781.             name = ngx_resolver_dup(r, rn->name, rn->nlen);
  782.             if (name == NULL) {
  783.                 goto failed;
  784.             }

  786.             ctx->name.len = rn->nlen;
  787.             ctx->name.data = name;

  789.             /* unlock addr mutex */

  791.             ctx->state = NGX_OK;

  793.             ctx->handler(ctx);

  795.             ngx_resolver_free(r, name);

  797.             return NGX_OK;
  798.         }

  800.         if (rn->waiting) {

  802.             ctx->next = rn->waiting;
  803.             rn->waiting = ctx;
  804.             ctx->state = NGX_AGAIN;

  806.             /* unlock addr mutex */

  808.             return NGX_OK;
  809.         }

  811.         ngx_queue_remove(&rn->queue);

  813.         ngx_resolver_free(r, rn->query);
  814.         rn->query = NULL;
  815. #if (NGX_HAVE_INET6)
  816.         rn->query6 = NULL;
  817. #endif

  819.     } else {
  820.         rn = ngx_resolver_alloc(r, sizeof(ngx_resolver_node_t));
  821.         if (rn == NULL) {
  822.             goto failed;
  823.         }

  825.         switch (ctx->addr.sockaddr->sa_family) {

  827. #if (NGX_HAVE_INET6)
  828.         case AF_INET6:
  829.             rn->addr6 = sin6->sin6_addr;
  830.             rn->node.key = hash;
  831.             break;
  832. #endif

  834.         default: /* AF_INET */
  835.             rn->node.key = addr;
  836.         }

  838.         rn->query = NULL;
  839. #if (NGX_HAVE_INET6)
  840.         rn->query6 = NULL;
  841. #endif

  843.         ngx_rbtree_insert(tree, &rn->node);
  844.     }

  846.     if (ngx_resolver_create_addr_query(rn, ctx) != NGX_OK) {
  847.         goto failed;
  848.     }

  850.     rn->naddrs = (u_short) -1;
  851. #if (NGX_HAVE_INET6)
  852.     rn->naddrs6 = (u_short) -1;
  853. #endif

  855.     if (ngx_resolver_send_query(r, rn) != NGX_OK) {
  856.         goto failed;
  857.     }

  859.     ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
  860.     if (ctx->event == NULL) {
  861.         goto failed;
  862.     }

  864.     ctx->event->handler = ngx_resolver_timeout_handler;
  865.     ctx->event->data = rn;
  866.     ctx->event->log = r->log;
  867.     rn->ident = -1;

  869.     ngx_add_timer(ctx->event, ctx->timeout);

  871.     if (ngx_queue_empty(resend_queue)) {
  872.         ngx_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
  873.     }

  875.     rn->expire = ngx_time() + r->resend_timeout;

  877.     ngx_queue_insert_head(resend_queue, &rn->queue);

  879.     rn->code = 0;
  880.     rn->cnlen = 0;
  881.     rn->name = NULL;
  882.     rn->nlen = 0;
  883.     rn->valid = 0;
  884.     rn->ttl = NGX_MAX_UINT32_VALUE;
  885.     rn->waiting = ctx;

  887.     /* unlock addr mutex */

  889.     ctx->state = NGX_AGAIN;

  891.     return NGX_OK;

  893. failed:

  895.     if (rn) {
  896.         ngx_rbtree_delete(tree, &rn->node);

  898.         if (rn->query) {
  899.             ngx_resolver_free(r, rn->query);
  900.         }

  902.         ngx_resolver_free(r, rn);
  903.     }

  905.     /* unlock addr mutex */

  907.     if (ctx->event) {
  908.         ngx_resolver_free(r, ctx->event);
  909.     }

  911.     ngx_resolver_free(r, ctx);

  913.     return NGX_ERROR;
  914. }


  917. void
  918. ‌ngx_resolve_addr_done(ngx_resolver_ctx_t *ctx)
  919. {
  920.     in_addr_t             addr;
  921.     ngx_queue_t          *expire_queue;
  922.     ngx_rbtree_t         *tree;
  923.     ngx_resolver_t       *r;
  924.     ngx_resolver_ctx_t   *w, **p;
  925.     struct sockaddr_in   *sin;
  926.     ngx_resolver_node_t  *rn;
  927. #if (NGX_HAVE_INET6)
  928.     uint32_t              hash;
  929.     struct sockaddr_in6  *sin6;
  930. #endif

  932.     r = ctx->resolver;

  934.     switch (ctx->addr.sockaddr->sa_family) {

  936. #if (NGX_HAVE_INET6)
  937.     case AF_INET6:
  938.         tree = &r->addr6_rbtree;
  939.         expire_queue = &r->addr6_expire_queue;
  940.         break;
  941. #endif

  943.     default: /* AF_INET */
  944.         tree = &r->addr_rbtree;
  945.         expire_queue = &r->addr_expire_queue;
  946.     }

  948.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
  949.                    "resolve addr done: %i", ctx->state);

  951.     if (ctx->event && ctx->event->timer_set) {
  952.         ngx_del_timer(ctx->event);
  953.     }

  955.     /* lock addr mutex */

  957.     if (ctx->state == NGX_AGAIN) {

  959.         switch (ctx->addr.sockaddr->sa_family) {

  961. #if (NGX_HAVE_INET6)
  962.         case AF_INET6:
  963.             sin6 = (struct sockaddr_in6 *) ctx->addr.sockaddr;
  964.             hash = ngx_crc32_short(sin6->sin6_addr.s6_addr, 16);
  965.             rn = ngx_resolver_lookup_addr6(r, &sin6->sin6_addr, hash);
  966.             break;
  967. #endif

  969.         default: /* AF_INET */
  970.             sin = (struct sockaddr_in *) ctx->addr.sockaddr;
  971.             addr = ntohl(sin->sin_addr.s_addr);
  972.             rn = ngx_resolver_lookup_addr(r, addr);
  973.         }

  975.         if (rn) {
  976.             p = &rn->waiting;
  977.             w = rn->waiting;

  979.             while (w) {
  980.                 if (w == ctx) {
  981.                     *p = w->next;

  983.                     goto done;
  984.                 }

  986.                 p = &w->next;
  987.                 w = w->next;
  988.             }
  989.         }

  991.         {
  992.             u_char     text[NGX_SOCKADDR_STRLEN];
  993.             ngx_str_t  addrtext;

  995.             addrtext.data = text;
  996.             addrtext.len = ngx_sock_ntop(ctx->addr.sockaddr, ctx->addr.socklen,
  997.                                          text, NGX_SOCKADDR_STRLEN, 0);

  999.             ngx_log_error(NGX_LOG_ALERT, r->log, 0,
  1000.                           "could not cancel %V resolving", &addrtext);
  1001.         }
  1002.     }

  1004. done:

  1006.     ngx_resolver_expire(r, tree, expire_queue);

  1008.     /* unlock addr mutex */

  1010.     /* lock alloc mutex */

  1012.     if (ctx->event) {
  1013.         ngx_resolver_free_locked(r, ctx->event);
  1014.     }

  1016.     ngx_resolver_free_locked(r, ctx);

  1018.     /* unlock alloc mutex */
  1019. }


  1022. static void
  1023. ‌ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree, ngx_queue_t *queue)
  1024. {
  1025.     time_t                now;
  1026.     ngx_uint_t            i;
  1027.     ngx_queue_t          *q;
  1028.     ngx_resolver_node_t  *rn;

  1030.     ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver expire");

  1032.     now = ngx_time();

  1034.     for (i = 0; i < 2; i++) {
  1035.         if (ngx_queue_empty(queue)) {
  1036.             return;
  1037.         }

  1039.         q = ngx_queue_last(queue);

  1041.         rn = ngx_queue_data(q, ngx_resolver_node_t, queue);

  1043.         if (now <= rn->expire) {
  1044.             return;
  1045.         }

  1047.         ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
  1048.                        "resolver expire \"%*s\"", (size_t) rn->nlen, rn->name);

  1050.         ngx_queue_remove(q);

  1052.         ngx_rbtree_delete(tree, &rn->node);

  1054.         ngx_resolver_free_node(r, rn);
  1055.     }
  1056. }


  1059. static ngx_int_t
  1060. ‌ngx_resolver_send_query(ngx_resolver_t *r, ngx_resolver_node_t *rn)
  1061. {
  1062.     ssize_t                n;
  1063.     ngx_udp_connection_t  *uc;

  1065.     uc = r->udp_connections.elts;

  1067.     uc = &uc[r->last_connection++];
  1068.     if (r->last_connection == r->udp_connections.nelts) {
  1069.         r->last_connection = 0;
  1070.     }

  1072.     if (uc->connection == NULL) {

  1074.         uc->log = *r->log;
  1075.         uc->log.handler = ngx_resolver_log_error;
  1076.         uc->log.data = uc;
  1077.         uc->log.action = "resolving";

  1079.         if (ngx_udp_connect(uc) != NGX_OK) {
  1080.             return NGX_ERROR;
  1081.         }

  1083.         uc->connection->data = r;
  1084.         uc->connection->read->handler = ngx_resolver_read_response;
  1085.         uc->connection->read->resolver = 1;
  1086.     }

  1088.     if (rn->naddrs == (u_short) -1) {
  1089.         n = ngx_send(uc->connection, rn->query, rn->qlen);

  1091.         if (n == -1) {
  1092.             return NGX_ERROR;
  1093.         }

  1095.         if ((size_t) n != (size_t) rn->qlen) {
  1096.             ngx_log_error(NGX_LOG_CRIT, &uc->log, 0, "send() incomplete");
  1097.             return NGX_ERROR;
  1098.         }
  1099.     }

  1101. #if (NGX_HAVE_INET6)
  1102.     if (rn->query6 && rn->naddrs6 == (u_short) -1) {
  1103.         n = ngx_send(uc->connection, rn->query6, rn->qlen);

  1105.         if (n == -1) {
  1106.             return NGX_ERROR;
  1107.         }

  1109.         if ((size_t) n != (size_t) rn->qlen) {
  1110.             ngx_log_error(NGX_LOG_CRIT, &uc->log, 0, "send() incomplete");
  1111.             return NGX_ERROR;
  1112.         }
  1113.     }
  1114. #endif

  1116.     return NGX_OK;
  1117. }


  1120. static void
  1121. ‌ngx_resolver_resend_handler(ngx_event_t *ev)
  1122. {
  1123.     time_t           timer, atimer, ntimer;
  1124. #if (NGX_HAVE_INET6)
  1125.     time_t           a6timer;
  1126. #endif
  1127.     ngx_resolver_t  *r;

  1129.     r = ev->data;

  1131.     ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0,
  1132.                    "resolver resend handler");

  1134.     /* lock name mutex */

  1136.     ntimer = ngx_resolver_resend(r, &r->name_rbtree, &r->name_resend_queue);

  1138.     /* unlock name mutex */

  1140.     /* lock addr mutex */

  1142.     atimer = ngx_resolver_resend(r, &r->addr_rbtree, &r->addr_resend_queue);

  1144.     /* unlock addr mutex */

  1146. #if (NGX_HAVE_INET6)

  1148.     /* lock addr6 mutex */

  1150.     a6timer = ngx_resolver_resend(r, &r->addr6_rbtree, &r->addr6_resend_queue);

  1152.     /* unlock addr6 mutex */

  1154. #endif

  1156.     timer = ntimer;

  1158.     if (timer == 0) {
  1159.         timer = atimer;

  1161.     } else if (atimer) {
  1162.         timer = ngx_min(timer, atimer);
  1163.     }

  1165. #if (NGX_HAVE_INET6)

  1167.     if (timer == 0) {
  1168.         timer = a6timer;

  1170.     } else if (a6timer) {
  1171.         timer = ngx_min(timer, a6timer);
  1172.     }

  1174. #endif

  1176.     if (timer) {
  1177.         ngx_add_timer(r->event, (ngx_msec_t) (timer * 1000));
  1178.     }
  1179. }


  1182. static time_t
  1183. ‌ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree, ngx_queue_t *queue)
  1184. {
  1185.     time_t                now;
  1186.     ngx_queue_t          *q;
  1187.     ngx_resolver_node_t  *rn;

  1189.     now = ngx_time();

  1191.     for ( ;; ) {
  1192.         if (ngx_queue_empty(queue)) {
  1193.             return 0;
  1194.         }

  1196.         q = ngx_queue_last(queue);

  1198.         rn = ngx_queue_data(q, ngx_resolver_node_t, queue);

  1200.         if (now < rn->expire) {
  1201.             return rn->expire - now;
  1202.         }

  1204.         ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
  1205.                        "resolver resend \"%*s\" %p",
  1206.                        (size_t) rn->nlen, rn->name, rn->waiting);

  1208.         ngx_queue_remove(q);

  1210.         if (rn->waiting) {

  1212.             (void) ngx_resolver_send_query(r, rn);

  1214.             rn->expire = now + r->resend_timeout;

  1216.             ngx_queue_insert_head(queue, q);

  1218.             continue;
  1219.         }

  1221.         ngx_rbtree_delete(tree, &rn->node);

  1223.         ngx_resolver_free_node(r, rn);
  1224.     }
  1225. }


  1228. static void
  1229. ‌ngx_resolver_read_response(ngx_event_t *rev)
  1230. {
  1231.     ssize_t            n;
  1232.     ngx_connection_t  *c;
  1233.     u_char             buf[NGX_RESOLVER_UDP_SIZE];

  1235.     c = rev->data;

  1237.     do {
  1238.         n = ngx_udp_recv(c, buf, NGX_RESOLVER_UDP_SIZE);

  1240.         if (n < 0) {
  1241.             return;
  1242.         }

  1244.         ngx_resolver_process_response(c->data, buf, n);

  1246.     } while (rev->ready);
  1247. }


  1250. static void
  1251. ‌ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n)
  1252. {
  1253.     char                 *err;
  1254.     ngx_uint_t            i, times, ident, qident, flags, code, nqs, nan,
  1255.                           qtype, qclass;
  1256. #if (NGX_HAVE_INET6)
  1257.     ngx_uint_t            qident6;
  1258. #endif
  1259.     ngx_queue_t          *q;
  1260.     ngx_resolver_qs_t    *qs;
  1261.     ngx_resolver_hdr_t   *response;
  1262.     ngx_resolver_node_t  *rn;

  1264.     if (n < sizeof(ngx_resolver_hdr_t)) {
  1265.         goto short_response;
  1266.     }

  1268.     response = (ngx_resolver_hdr_t *) buf;

  1270.     ident = (response->ident_hi << 8) + response->ident_lo;
  1271.     flags = (response->flags_hi << 8) + response->flags_lo;
  1272.     nqs = (response->nqs_hi << 8) + response->nqs_lo;
  1273.     nan = (response->nan_hi << 8) + response->nan_lo;

  1275.     ngx_log_debug6(NGX_LOG_DEBUG_CORE, r->log, 0,
  1276.                    "resolver DNS response %ui fl:%04Xui %ui/%ui/%ud/%ud",
  1277.                    ident, flags, nqs, nan,
  1278.                    (response->nns_hi << 8) + response->nns_lo,
  1279.                    (response->nar_hi << 8) + response->nar_lo);

  1281.     /* response to a standard query */
  1282.     if ((flags & 0xf870) != 0x8000) {
  1283.         ngx_log_error(r->log_level, r->log, 0,
  1284.                       "invalid DNS response %ui fl:%04Xui", ident, flags);
  1285.         return;
  1286.     }

  1288.     code = flags & 0xf;

  1290.     if (code == NGX_RESOLVE_FORMERR) {

  1292.         times = 0;

  1294.         for (q = ngx_queue_head(&r->name_resend_queue);
  1295.              q != ngx_queue_sentinel(&r->name_resend_queue) || times++ < 100;
  1296.              q = ngx_queue_next(q))
  1297.         {
  1298.             rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
  1299.             qident = (rn->query[0] << 8) + rn->query[1];

  1301.             if (qident == ident) {
  1302.                 goto dns_error_name;
  1303.             }

  1305. #if (NGX_HAVE_INET6)
  1306.             if (rn->query6) {
  1307.                 qident6 = (rn->query6[0] << 8) + rn->query6[1];

  1309.                 if (qident6 == ident) {
  1310.                     goto dns_error_name;
  1311.                 }
  1312.             }
  1313. #endif
  1314.         }

  1316.         goto dns_error;
  1317.     }

  1319.     if (code > NGX_RESOLVE_REFUSED) {
  1320.         goto dns_error;
  1321.     }

  1323.     if (nqs != 1) {
  1324.         err = "invalid number of questions in DNS response";
  1325.         goto done;
  1326.     }

  1328.     i = sizeof(ngx_resolver_hdr_t);

  1330.     while (i < (ngx_uint_t) n) {
  1331.         if (buf[i] == '\0') {
  1332.             goto found;
  1333.         }

  1335.         i += 1 + buf[i];
  1336.     }

  1338.     goto short_response;

  1340. found:

  1342.     if (i++ == sizeof(ngx_resolver_hdr_t)) {
  1343.         err = "zero-length domain name in DNS response";
  1344.         goto done;
  1345.     }

  1347.     if (i + sizeof(ngx_resolver_qs_t) + nan * (2 + sizeof(ngx_resolver_an_t))
  1348.         > (ngx_uint_t) n)
  1349.     {
  1350.         goto short_response;
  1351.     }

  1353.     qs = (ngx_resolver_qs_t *) &buf[i];

  1355.     qtype = (qs->type_hi << 8) + qs->type_lo;
  1356.     qclass = (qs->class_hi << 8) + qs->class_lo;

  1358.     ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
  1359.                    "resolver DNS response qt:%ui cl:%ui", qtype, qclass);

  1361.     if (qclass != 1) {
  1362.         ngx_log_error(r->log_level, r->log, 0,
  1363.                       "unknown query class %ui in DNS response", qclass);
  1364.         return;
  1365.     }

  1367.     switch (qtype) {

  1369.     case NGX_RESOLVE_A:
  1370. #if (NGX_HAVE_INET6)
  1371.     case NGX_RESOLVE_AAAA:
  1372. #endif

  1374.         ngx_resolver_process_a(r, buf, n, ident, code, qtype, nan,
  1375.                                i + sizeof(ngx_resolver_qs_t));

  1377.         break;

  1379.     case NGX_RESOLVE_PTR:

  1381.         ngx_resolver_process_ptr(r, buf, n, ident, code, nan);

  1383.         break;

  1385.     default:
  1386.         ngx_log_error(r->log_level, r->log, 0,
  1387.                       "unknown query type %ui in DNS response", qtype);
  1388.         return;
  1389.     }

  1391.     return;

  1393. short_response:

  1395.     err = "short DNS response";

  1397. done:

  1399.     ngx_log_error(r->log_level, r->log, 0, err);

  1401.     return;

  1403. dns_error_name:

  1405.     ngx_log_error(r->log_level, r->log, 0,
  1406.                   "DNS error (%ui: %s), query id:%ui, name:\"%*s\"",
  1407.                   code, ngx_resolver_strerror(code), ident,
  1408.                   rn->nlen, rn->name);
  1409.     return;

  1411. dns_error:

  1413.     ngx_log_error(r->log_level, r->log, 0,
  1414.                   "DNS error (%ui: %s), query id:%ui",
  1415.                   code, ngx_resolver_strerror(code), ident);
  1416.     return;
  1417. }


  1420. static void
  1421. ‌ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
  1422.     ngx_uint_t ident, ngx_uint_t code, ngx_uint_t qtype,
  1423.     ngx_uint_t nan, ngx_uint_t ans)
  1424. {
  1425.     char                 *err;
  1426.     u_char               *cname;
  1427.     size_t                len;
  1428.     int32_t               ttl;
  1429.     uint32_t              hash;
  1430.     in_addr_t            *addr;
  1431.     ngx_str_t             name;
  1432.     ngx_addr_t           *addrs;
  1433.     ngx_uint_t            type, class, qident, naddrs, a, i, n, start;
  1434. #if (NGX_HAVE_INET6)
  1435.     struct in6_addr      *addr6;
  1436. #endif
  1437.     ngx_resolver_an_t    *an;
  1438.     ngx_resolver_ctx_t   *ctx, *next;
  1439.     ngx_resolver_node_t  *rn;

  1441.     if (ngx_resolver_copy(r, &name, buf,
  1442.                           buf + sizeof(ngx_resolver_hdr_t), buf + last)
  1443.         != NGX_OK)
  1444.     {
  1445.         return;
  1446.     }

  1448.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver qs:%V", &name);

  1450.     hash = ngx_crc32_short(name.data, name.len);

  1452.     /* lock name mutex */

  1454.     rn = ngx_resolver_lookup_name(r, &name, hash);

  1456.     if (rn == NULL) {
  1457.         ngx_log_error(r->log_level, r->log, 0,
  1458.                       "unexpected response for %V", &name);
  1459.         ngx_resolver_free(r, name.data);
  1460.         goto failed;
  1461.     }

  1463.     switch (qtype) {

  1465. #if (NGX_HAVE_INET6)
  1466.     case NGX_RESOLVE_AAAA:

  1468.         if (rn->query6 == NULL || rn->naddrs6 != (u_short) -1) {
  1469.             ngx_log_error(r->log_level, r->log, 0,
  1470.                           "unexpected response for %V", &name);
  1471.             ngx_resolver_free(r, name.data);
  1472.             goto failed;
  1473.         }

  1475.         qident = (rn->query6[0] << 8) + rn->query6[1];

  1477.         break;
  1478. #endif

  1480.     default: /* NGX_RESOLVE_A */

  1482.         if (rn->query == NULL || rn->naddrs != (u_short) -1) {
  1483.             ngx_log_error(r->log_level, r->log, 0,
  1484.                           "unexpected response for %V", &name);
  1485.             ngx_resolver_free(r, name.data);
  1486.             goto failed;
  1487.         }

  1489.         qident = (rn->query[0] << 8) + rn->query[1];
  1490.     }

  1492.     if (ident != qident) {
  1493.         ngx_log_error(r->log_level, r->log, 0,
  1494.                       "wrong ident %ui response for %V, expect %ui",
  1495.                       ident, &name, qident);
  1496.         ngx_resolver_free(r, name.data);
  1497.         goto failed;
  1498.     }

  1500.     ngx_resolver_free(r, name.data);

  1502.     if (code == 0 && rn->code) {
  1503.         code = rn->code;
  1504.     }

  1506.     if (code == 0 && nan == 0) {

  1508. #if (NGX_HAVE_INET6)
  1509.         switch (qtype) {

  1511.         case NGX_RESOLVE_AAAA:

  1513.             rn->naddrs6 = 0;

  1515.             if (rn->naddrs == (u_short) -1) {
  1516.                 goto next;
  1517.             }

  1519.             if (rn->naddrs) {
  1520.                 goto export;
  1521.             }

  1523.             break;

  1525.         default: /* NGX_RESOLVE_A */

  1527.             rn->naddrs = 0;

  1529.             if (rn->naddrs6 == (u_short) -1) {
  1530.                 goto next;
  1531.             }

  1533.             if (rn->naddrs6) {
  1534.                 goto export;
  1535.             }
  1536.         }
  1537. #endif

  1539.         code = NGX_RESOLVE_NXDOMAIN;
  1540.     }

  1542.     if (code) {

  1544. #if (NGX_HAVE_INET6)
  1545.         switch (qtype) {

  1547.         case NGX_RESOLVE_AAAA:

  1549.             rn->naddrs6 = 0;

  1551.             if (rn->naddrs == (u_short) -1) {
  1552.                 rn->code = (u_char) code;
  1553.                 goto next;
  1554.             }

  1556.             break;

  1558.         default: /* NGX_RESOLVE_A */

  1560.             rn->naddrs = 0;

  1562.             if (rn->naddrs6 == (u_short) -1) {
  1563.                 rn->code = (u_char) code;
  1564.                 goto next;
  1565.             }
  1566.         }
  1567. #endif

  1569.         next = rn->waiting;
  1570.         rn->waiting = NULL;

  1572.         ngx_queue_remove(&rn->queue);

  1574.         ngx_rbtree_delete(&r->name_rbtree, &rn->node);

  1576.         /* unlock name mutex */

  1578.         while (next) {
  1579.             ctx = next;
  1580.             ctx->state = code;
  1581.             next = ctx->next;

  1583.             ctx->handler(ctx);
  1584.         }

  1586.         ngx_resolver_free_node(r, rn);

  1588.         return;
  1589.     }

  1591.     i = ans;
  1592.     naddrs = 0;
  1593.     cname = NULL;

  1595.     for (a = 0; a < nan; a++) {

  1597.         start = i;

  1599.         while (i < last) {

  1601.             if (buf[i] & 0xc0) {
  1602.                 i += 2;
  1603.                 goto found;
  1604.             }

  1606.             if (buf[i] == 0) {
  1607.                 i++;
  1608.                 goto test_length;
  1609.             }

  1611.             i += 1 + buf[i];
  1612.         }

  1614.         goto short_response;

  1616.     test_length:

  1618.         if (i - start < 2) {
  1619.             err = "invalid name in DNS response";
  1620.             goto invalid;
  1621.         }

  1623.     found:

  1625.         if (i + sizeof(ngx_resolver_an_t) >= last) {
  1626.             goto short_response;
  1627.         }

  1629.         an = (ngx_resolver_an_t *) &buf[i];

  1631.         type = (an->type_hi << 8) + an->type_lo;
  1632.         class = (an->class_hi << 8) + an->class_lo;
  1633.         len = (an->len_hi << 8) + an->len_lo;
  1634.         ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16)
  1635.             + (an->ttl[2] << 8) + (an->ttl[3]);

  1637.         if (class != 1) {
  1638.             ngx_log_error(r->log_level, r->log, 0,
  1639.                           "unexpected RR class %ui", class);
  1640.             goto failed;
  1641.         }

  1643.         if (ttl < 0) {
  1644.             ttl = 0;
  1645.         }

  1647.         rn->ttl = ngx_min(rn->ttl, (uint32_t) ttl);

  1649.         i += sizeof(ngx_resolver_an_t);

  1651.         switch (type) {

  1653.         case NGX_RESOLVE_A:

  1655.             if (qtype != NGX_RESOLVE_A) {
  1656.                 err = "unexpected A record in DNS response";
  1657.                 goto invalid;
  1658.             }

  1660.             if (len != 4) {
  1661.                 err = "invalid A record in DNS response";
  1662.                 goto invalid;
  1663.             }

  1665.             if (i + 4 > last) {
  1666.                 goto short_response;
  1667.             }

  1669.             naddrs++;

  1671.             break;

  1673. #if (NGX_HAVE_INET6)
  1674.         case NGX_RESOLVE_AAAA:

  1676.             if (qtype != NGX_RESOLVE_AAAA) {
  1677.                 err = "unexpected AAAA record in DNS response";
  1678.                 goto invalid;
  1679.             }

  1681.             if (len != 16) {
  1682.                 err = "invalid AAAA record in DNS response";
  1683.                 goto invalid;
  1684.             }

  1686.             if (i + 16 > last) {
  1687.                 goto short_response;
  1688.             }

  1690.             naddrs++;

  1692.             break;
  1693. #endif

  1695.         case NGX_RESOLVE_CNAME:

  1697.             cname = &buf[i];

  1699.             break;

  1701.         case NGX_RESOLVE_DNAME:

  1703.             break;

  1705.         default:

  1707.             ngx_log_error(r->log_level, r->log, 0,
  1708.                           "unexpected RR type %ui", type);
  1709.         }

  1711.         i += len;
  1712.     }

  1714.     ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
  1715.                    "resolver naddrs:%ui cname:%p ttl:%uD",
  1716.                    naddrs, cname, rn->ttl);

  1718.     if (naddrs) {

  1720.         switch (qtype) {

  1722. #if (NGX_HAVE_INET6)
  1723.         case NGX_RESOLVE_AAAA:

  1725.             if (naddrs == 1) {
  1726.                 addr6 = &rn->u6.addr6;
  1727.                 rn->naddrs6 = 1;

  1729.             } else {
  1730.                 addr6 = ngx_resolver_alloc(r, naddrs * sizeof(struct in6_addr));
  1731.                 if (addr6 == NULL) {
  1732.                     goto failed;
  1733.                 }

  1735.                 rn->u6.addrs6 = addr6;
  1736.                 rn->naddrs6 = (u_short) naddrs;
  1737.             }

  1739. #if (NGX_SUPPRESS_WARN)
  1740.             addr = NULL;
  1741. #endif

  1743.             break;
  1744. #endif

  1746.         default: /* NGX_RESOLVE_A */

  1748.             if (naddrs == 1) {
  1749.                 addr = &rn->u.addr;
  1750.                 rn->naddrs = 1;

  1752.             } else {
  1753.                 addr = ngx_resolver_alloc(r, naddrs * sizeof(in_addr_t));
  1754.                 if (addr == NULL) {
  1755.                     goto failed;
  1756.                 }

  1758.                 rn->u.addrs = addr;
  1759.                 rn->naddrs = (u_short) naddrs;
  1760.             }

  1762. #if (NGX_HAVE_INET6 && NGX_SUPPRESS_WARN)
  1763.             addr6 = NULL;
  1764. #endif
  1765.         }

  1767.         n = 0;
  1768.         i = ans;

  1770.         for (a = 0; a < nan; a++) {

  1772.             for ( ;; ) {

  1774.                 if (buf[i] & 0xc0) {
  1775.                     i += 2;
  1776.                     break;
  1777.                 }

  1779.                 if (buf[i] == 0) {
  1780.                     i++;
  1781.                     break;
  1782.                 }

  1784.                 i += 1 + buf[i];
  1785.             }

  1787.             an = (ngx_resolver_an_t *) &buf[i];

  1789.             type = (an->type_hi << 8) + an->type_lo;
  1790.             len = (an->len_hi << 8) + an->len_lo;

  1792.             i += sizeof(ngx_resolver_an_t);

  1794.             if (type == NGX_RESOLVE_A) {

  1796.                 addr[n] = htonl((buf[i] << 24) + (buf[i + 1] << 16)
  1797.                                 + (buf[i + 2] << 8) + (buf[i + 3]));

  1799.                 if (++n == naddrs) {

  1801. #if (NGX_HAVE_INET6)
  1802.                     if (rn->naddrs6 == (u_short) -1) {
  1803.                         goto next;
  1804.                     }
  1805. #endif

  1807.                     break;
  1808.                 }
  1809.             }

  1811. #if (NGX_HAVE_INET6)
  1812.             else if (type == NGX_RESOLVE_AAAA) {

  1814.                 ngx_memcpy(addr6[n].s6_addr, &buf[i], 16);

  1816.                 if (++n == naddrs) {

  1818.                     if (rn->naddrs == (u_short) -1) {
  1819.                         goto next;
  1820.                     }

  1822.                     break;
  1823.                 }
  1824.             }
  1825. #endif

  1827.             i += len;
  1828.         }
  1829.     }

  1831.     switch (qtype) {

  1833. #if (NGX_HAVE_INET6)
  1834.     case NGX_RESOLVE_AAAA:

  1836.         if (rn->naddrs6 == (u_short) -1) {
  1837.             rn->naddrs6 = 0;
  1838.         }

  1840.         break;
  1841. #endif

  1843.     default: /* NGX_RESOLVE_A */

  1845.         if (rn->naddrs == (u_short) -1) {
  1846.             rn->naddrs = 0;
  1847.         }
  1848.     }

  1850.     if (rn->naddrs != (u_short) -1
  1851. #if (NGX_HAVE_INET6)
  1852.         && rn->naddrs6 != (u_short) -1
  1853. #endif
  1854.         && rn->naddrs
  1855. #if (NGX_HAVE_INET6)
  1856.            + rn->naddrs6
  1857. #endif
  1858.            > 0)
  1859.     {

  1861. #if (NGX_HAVE_INET6)
  1862.     export:
  1863. #endif

  1865.         naddrs = rn->naddrs;
  1866. #if (NGX_HAVE_INET6)
  1867.         naddrs += rn->naddrs6;
  1868. #endif

  1870.         if (naddrs == 1 && rn->naddrs == 1) {
  1871.             addrs = NULL;

  1873.         } else {
  1874.             addrs = ngx_resolver_export(r, rn, 0);
  1875.             if (addrs == NULL) {
  1876.                 goto failed;
  1877.             }
  1878.         }

  1880.         ngx_queue_remove(&rn->queue);

  1882.         rn->valid = ngx_time() + (r->valid ? r->valid : (time_t) rn->ttl);
  1883.         rn->expire = ngx_time() + r->expire;

  1885.         ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);

  1887.         next = rn->waiting;
  1888.         rn->waiting = NULL;

  1890.         /* unlock name mutex */

  1892.         while (next) {
  1893.             ctx = next;
  1894.             ctx->state = NGX_OK;
  1895.             ctx->naddrs = naddrs;

  1897.             if (addrs == NULL) {
  1898.                 ctx->addrs = &ctx->addr;
  1899.                 ctx->addr.sockaddr = (struct sockaddr *) &ctx->sin;
  1900.                 ctx->addr.socklen = sizeof(struct sockaddr_in);
  1901.                 ngx_memzero(&ctx->sin, sizeof(struct sockaddr_in));
  1902.                 ctx->sin.sin_family = AF_INET;
  1903.                 ctx->sin.sin_addr.s_addr = rn->u.addr;

  1905.             } else {
  1906.                 ctx->addrs = addrs;
  1907.             }

  1909.             next = ctx->next;

  1911.             ctx->handler(ctx);
  1912.         }

  1914.         if (addrs != NULL) {
  1915.             ngx_resolver_free(r, addrs->sockaddr);
  1916.             ngx_resolver_free(r, addrs);
  1917.         }

  1919.         ngx_resolver_free(r, rn->query);
  1920.         rn->query = NULL;
  1921. #if (NGX_HAVE_INET6)
  1922.         rn->query6 = NULL;
  1923. #endif

  1925.         return;
  1926.     }

  1928.     if (cname) {

  1930.         /* CNAME only */

  1932.         if (rn->naddrs == (u_short) -1
  1933. #if (NGX_HAVE_INET6)
  1934.             || rn->naddrs6 == (u_short) -1
  1935. #endif
  1936.             )
  1937.         {
  1938.             goto next;
  1939.         }

  1941.         if (ngx_resolver_copy(r, &name, buf, cname, buf + last) != NGX_OK) {
  1942.             goto failed;
  1943.         }

  1945.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
  1946.                        "resolver cname:\"%V\"", &name);

  1948.         ngx_queue_remove(&rn->queue);

  1950.         rn->cnlen = (u_short) name.len;
  1951.         rn->u.cname = name.data;

  1953.         rn->valid = ngx_time() + (r->valid ? r->valid : (time_t) rn->ttl);
  1954.         rn->expire = ngx_time() + r->expire;

  1956.         ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);

  1958.         ctx = rn->waiting;
  1959.         rn->waiting = NULL;

  1961.         if (ctx) {
  1962.             ctx->name = name;

  1964.             (void) ngx_resolve_name_locked(r, ctx);
  1965.         }

  1967.         ngx_resolver_free(r, rn->query);
  1968.         rn->query = NULL;
  1969. #if (NGX_HAVE_INET6)
  1970.         rn->query6 = NULL;
  1971. #endif

  1973.         /* unlock name mutex */

  1975.         return;
  1976.     }

  1978.     ngx_log_error(r->log_level, r->log, 0,
  1979.                   "no A or CNAME types in DNS response");
  1980.     return;

  1982. short_response:

  1984.     err = "short DNS response";

  1986. invalid:

  1988.     /* unlock name mutex */

  1990.     ngx_log_error(r->log_level, r->log, 0, err);

  1992.     return;

  1994. failed:

  1996. next:

  1998.     /* unlock name mutex */

  2000.     return;
  2001. }


  2004. static void
  2005. ‌ngx_resolver_process_ptr(ngx_resolver_t *r, u_char *buf, size_t n,
  2006.     ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan)
  2007. {
  2008.     char                 *err;
  2009.     size_t                len;
  2010.     u_char                text[NGX_SOCKADDR_STRLEN];
  2011.     in_addr_t             addr;
  2012.     int32_t               ttl;
  2013.     ngx_int_t             octet;
  2014.     ngx_str_t             name;
  2015.     ngx_uint_t            i, mask, qident, class;
  2016.     ngx_queue_t          *expire_queue;
  2017.     ngx_rbtree_t         *tree;
  2018.     ngx_resolver_an_t    *an;
  2019.     ngx_resolver_ctx_t   *ctx, *next;
  2020.     ngx_resolver_node_t  *rn;
  2021. #if (NGX_HAVE_INET6)
  2022.     uint32_t              hash;
  2023.     ngx_int_t             digit;
  2024.     struct in6_addr       addr6;
  2025. #endif

  2027.     if (ngx_resolver_copy(r, NULL, buf,
  2028.                           buf + sizeof(ngx_resolver_hdr_t), buf + n)
  2029.         != NGX_OK)
  2030.     {
  2031.         return;
  2032.     }

  2034.     /* AF_INET */

  2036.     addr = 0;
  2037.     i = sizeof(ngx_resolver_hdr_t);

  2039.     for (mask = 0; mask < 32; mask += 8) {
  2040.         len = buf[i++];

  2042.         octet = ngx_atoi(&buf[i], len);
  2043.         if (octet == NGX_ERROR || octet > 255) {
  2044.             goto invalid_in_addr_arpa;
  2045.         }

  2047.         addr += octet << mask;
  2048.         i += len;
  2049.     }

  2051.     if (ngx_strcasecmp(&buf[i], (u_char *) "\7in-addr\4arpa") == 0) {
  2052.         i += sizeof("\7in-addr\4arpa");

  2054.         /* lock addr mutex */

  2056.         rn = ngx_resolver_lookup_addr(r, addr);

  2058.         tree = &r->addr_rbtree;
  2059.         expire_queue = &r->addr_expire_queue;

  2061.         addr = htonl(addr);
  2062.         name.len = ngx_inet_ntop(AF_INET, &addr, text, NGX_SOCKADDR_STRLEN);
  2063.         name.data = text;

  2065.         goto valid;
  2066.     }

  2068. invalid_in_addr_arpa:

  2070. #if (NGX_HAVE_INET6)

  2072.     i = sizeof(ngx_resolver_hdr_t);

  2074.     for (octet = 15; octet >= 0; octet--) {
  2075.         if (buf[i++] != '\1') {
  2076.             goto invalid_ip6_arpa;
  2077.         }

  2079.         digit = ngx_hextoi(&buf[i++], 1);
  2080.         if (digit == NGX_ERROR) {
  2081.             goto invalid_ip6_arpa;
  2082.         }

  2084.         addr6.s6_addr[octet] = (u_char) digit;

  2086.         if (buf[i++] != '\1') {
  2087.             goto invalid_ip6_arpa;
  2088.         }

  2090.         digit = ngx_hextoi(&buf[i++], 1);
  2091.         if (digit == NGX_ERROR) {
  2092.             goto invalid_ip6_arpa;
  2093.         }

  2095.         addr6.s6_addr[octet] += (u_char) (digit * 16);
  2096.     }

  2098.     if (ngx_strcasecmp(&buf[i], (u_char *) "\3ip6\4arpa") == 0) {
  2099.         i += sizeof("\3ip6\4arpa");

  2101.         /* lock addr mutex */

  2103.         hash = ngx_crc32_short(addr6.s6_addr, 16);
  2104.         rn = ngx_resolver_lookup_addr6(r, &addr6, hash);

  2106.         tree = &r->addr6_rbtree;
  2107.         expire_queue = &r->addr6_expire_queue;

  2109.         name.len = ngx_inet6_ntop(addr6.s6_addr, text, NGX_SOCKADDR_STRLEN);
  2110.         name.data = text;

  2112.         goto valid;
  2113.     }

  2115. invalid_ip6_arpa:
  2116. #endif

  2118.     ngx_log_error(r->log_level, r->log, 0,
  2119.                   "invalid in-addr.arpa or ip6.arpa name in DNS response");
  2120.     return;

  2122. valid:

  2124.     if (rn == NULL || rn->query == NULL) {
  2125.         ngx_log_error(r->log_level, r->log, 0,
  2126.                       "unexpected response for %V", &name);
  2127.         goto failed;
  2128.     }

  2130.     qident = (rn->query[0] << 8) + rn->query[1];

  2132.     if (ident != qident) {
  2133.         ngx_log_error(r->log_level, r->log, 0,
  2134.                       "wrong ident %ui response for %V, expect %ui",
  2135.                       ident, &name, qident);
  2136.         goto failed;
  2137.     }

  2139.     if (code == 0 && nan == 0) {
  2140.         code = NGX_RESOLVE_NXDOMAIN;
  2141.     }

  2143.     if (code) {
  2144.         next = rn->waiting;
  2145.         rn->waiting = NULL;

  2147.         ngx_queue_remove(&rn->queue);

  2149.         ngx_rbtree_delete(tree, &rn->node);

  2151.         /* unlock addr mutex */

  2153.         while (next) {
  2154.             ctx = next;
  2155.             ctx->state = code;
  2156.             next = ctx->next;

  2158.             ctx->handler(ctx);
  2159.         }

  2161.         ngx_resolver_free_node(r, rn);

  2163.         return;
  2164.     }

  2166.     i += sizeof(ngx_resolver_qs_t);

  2168.     if (i + 2 + sizeof(ngx_resolver_an_t) >= n) {
  2169.         goto short_response;
  2170.     }

  2172.     /* compression pointer to *.arpa */

  2174.     if (buf[i] != 0xc0 || buf[i + 1] != sizeof(ngx_resolver_hdr_t)) {
  2175.         err = "invalid in-addr.arpa or ip6.arpa name in DNS response";
  2176.         goto invalid;
  2177.     }

  2179.     an = (ngx_resolver_an_t *) &buf[i + 2];

  2181.     class = (an->class_hi << 8) + an->class_lo;
  2182.     len = (an->len_hi << 8) + an->len_lo;
  2183.     ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16)
  2184.         + (an->ttl[2] << 8) + (an->ttl[3]);

  2186.     if (class != 1) {
  2187.         ngx_log_error(r->log_level, r->log, 0,
  2188.                       "unexpected RR class %ui", class);
  2189.         goto failed;
  2190.     }

  2192.     if (ttl < 0) {
  2193.         ttl = 0;
  2194.     }

  2196.     ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
  2197.                   "resolver qt:%ui cl:%ui len:%uz",
  2198.                   (an->type_hi << 8) + an->type_lo,
  2199.                   class, len);

  2201.     i += 2 + sizeof(ngx_resolver_an_t);

  2203.     if (i + len > n) {
  2204.         goto short_response;
  2205.     }

  2207.     if (ngx_resolver_copy(r, &name, buf, buf + i, buf + n) != NGX_OK) {
  2208.         goto failed;
  2209.     }

  2211.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver an:%V", &name);

  2213.     if (name.len != (size_t) rn->nlen
  2214.         || ngx_strncmp(name.data, rn->name, name.len) != 0)
  2215.     {
  2216.         if (rn->nlen) {
  2217.             ngx_resolver_free(r, rn->name);
  2218.         }

  2220.         rn->nlen = (u_short) name.len;
  2221.         rn->name = name.data;

  2223.         name.data = ngx_resolver_dup(r, rn->name, name.len);
  2224.         if (name.data == NULL) {
  2225.             goto failed;
  2226.         }
  2227.     }

  2229.     ngx_queue_remove(&rn->queue);

  2231.     rn->valid = ngx_time() + (r->valid ? r->valid : ttl);
  2232.     rn->expire = ngx_time() + r->expire;

  2234.     ngx_queue_insert_head(expire_queue, &rn->queue);

  2236.     next = rn->waiting;
  2237.     rn->waiting = NULL;

  2239.     /* unlock addr mutex */

  2241.     while (next) {
  2242.         ctx = next;
  2243.         ctx->state = NGX_OK;
  2244.         ctx->name = name;
  2245.         next = ctx->next;

  2247.         ctx->handler(ctx);
  2248.     }

  2250.     ngx_resolver_free(r, name.data);

  2252.     return;

  2254. short_response:

  2256.     err = "short DNS response";

  2258. invalid:

  2260.     /* unlock addr mutex */

  2262.     ngx_log_error(r->log_level, r->log, 0, err);

  2264.     return;

  2266. failed:

  2268.     /* unlock addr mutex */

  2270.     return;
  2271. }


  2274. static ngx_resolver_node_t *
  2275. ‌ngx_resolver_lookup_name(ngx_resolver_t *r, ngx_str_t *name, uint32_t hash)
  2276. {
  2277.     ngx_int_t             rc;
  2278.     ngx_rbtree_node_t    *node, *sentinel;
  2279.     ngx_resolver_node_t  *rn;

  2281.     node = r->name_rbtree.root;
  2282.     sentinel = r->name_rbtree.sentinel;

  2284.     while (node != sentinel) {

  2286.         if (hash < node->key) {
  2287.             node = node->left;
  2288.             continue;
  2289.         }

  2291.         if (hash > node->key) {
  2292.             node = node->right;
  2293.             continue;
  2294.         }

  2296.         /* hash == node->key */

  2298.         rn = ngx_resolver_node(node);

  2300.         rc = ngx_memn2cmp(name->data, rn->name, name->len, rn->nlen);

  2302.         if (rc == 0) {
  2303.             return rn;
  2304.         }

  2306.         node = (rc < 0) ? node->left : node->right;
  2307.     }

  2309.     /* not found */

  2311.     return NULL;
  2312. }


  2315. static ngx_resolver_node_t *
  2316. ‌ngx_resolver_lookup_addr(ngx_resolver_t *r, in_addr_t addr)
  2317. {
  2318.     ngx_rbtree_node_t  *node, *sentinel;

  2320.     node = r->addr_rbtree.root;
  2321.     sentinel = r->addr_rbtree.sentinel;

  2323.     while (node != sentinel) {

  2325.         if (addr < node->key) {
  2326.             node = node->left;
  2327.             continue;
  2328.         }

  2330.         if (addr > node->key) {
  2331.             node = node->right;
  2332.             continue;
  2333.         }

  2335.         /* addr == node->key */

  2337.         return ngx_resolver_node(node);
  2338.     }

  2340.     /* not found */

  2342.     return NULL;
  2343. }


  2346. #if (NGX_HAVE_INET6)

  2348. static ngx_resolver_node_t *
  2349. ‌ngx_resolver_lookup_addr6(ngx_resolver_t *r, struct in6_addr *addr,
  2350.     uint32_t hash)
  2351. {
  2352.     ngx_int_t             rc;
  2353.     ngx_rbtree_node_t    *node, *sentinel;
  2354.     ngx_resolver_node_t  *rn;

  2356.     node = r->addr6_rbtree.root;
  2357.     sentinel = r->addr6_rbtree.sentinel;

  2359.     while (node != sentinel) {

  2361.         if (hash < node->key) {
  2362.             node = node->left;
  2363.             continue;
  2364.         }

  2366.         if (hash > node->key) {
  2367.             node = node->right;
  2368.             continue;
  2369.         }

  2371.         /* hash == node->key */

  2373.         rn = ngx_resolver_node(node);

  2375.         rc = ngx_memcmp(addr, &rn->addr6, 16);

  2377.         if (rc == 0) {
  2378.             return rn;
  2379.         }

  2381.         node = (rc < 0) ? node->left : node->right;
  2382.     }

  2384.     /* not found */

  2386.     return NULL;
  2387. }

  2389. #endif


  2392. static void
  2393. ‌ngx_resolver_rbtree_insert_value(ngx_rbtree_node_t *temp,
  2394.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  2395. {
  2396.     ngx_rbtree_node_t    **p;
  2397.     ngx_resolver_node_t   *rn, *rn_temp;

  2399.     for ( ;; ) {

  2401.         if (node->key < temp->key) {

  2403.             p = &temp->left;

  2405.         } else if (node->key > temp->key) {

  2407.             p = &temp->right;

  2409.         } else { /* node->key == temp->key */

  2411.             rn = ngx_resolver_node(node);
  2412.             rn_temp = ngx_resolver_node(temp);

  2414.             p = (ngx_memn2cmp(rn->name, rn_temp->name, rn->nlen, rn_temp->nlen)
  2415.                  < 0) ? &temp->left : &temp->right;
  2416.         }

  2418.         if (*p == sentinel) {
  2419.             break;
  2420.         }

  2422.         temp = *p;
  2423.     }

  2425.     *p = node;
  2426.     node->parent = temp;
  2427.     node->left = sentinel;
  2428.     node->right = sentinel;
  2429.     ngx_rbt_red(node);
  2430. }


  2433. #if (NGX_HAVE_INET6)

  2435. static void
  2436. ‌ngx_resolver_rbtree_insert_addr6_value(ngx_rbtree_node_t *temp,
  2437.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  2438. {
  2439.     ngx_rbtree_node_t    **p;
  2440.     ngx_resolver_node_t   *rn, *rn_temp;

  2442.     for ( ;; ) {

  2444.         if (node->key < temp->key) {

  2446.             p = &temp->left;

  2448.         } else if (node->key > temp->key) {

  2450.             p = &temp->right;

  2452.         } else { /* node->key == temp->key */

  2454.             rn = ngx_resolver_node(node);
  2455.             rn_temp = ngx_resolver_node(temp);

  2457.             p = (ngx_memcmp(&rn->addr6, &rn_temp->addr6, 16)
  2458.                  < 0) ? &temp->left : &temp->right;
  2459.         }

  2461.         if (*p == sentinel) {
  2462.             break;
  2463.         }

  2465.         temp = *p;
  2466.     }

  2468.     *p = node;
  2469.     node->parent = temp;
  2470.     node->left = sentinel;
  2471.     node->right = sentinel;
  2472.     ngx_rbt_red(node);
  2473. }

  2475. #endif


  2478. static ngx_int_t
  2479. ‌ngx_resolver_create_name_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx)
  2480. {
  2481.     u_char              *p, *s;
  2482.     size_t               len, nlen;
  2483.     ngx_uint_t           ident;
  2484. #if (NGX_HAVE_INET6)
  2485.     ngx_resolver_t      *r;
  2486. #endif
  2487.     ngx_resolver_qs_t   *qs;
  2488.     ngx_resolver_hdr_t  *query;

  2490.     nlen = ctx->name.len ? (1 + ctx->name.len + 1) : 1;

  2492.     len = sizeof(ngx_resolver_hdr_t) + nlen + sizeof(ngx_resolver_qs_t);

  2494. #if (NGX_HAVE_INET6)
  2495.     r = ctx->resolver;

  2497.     p = ngx_resolver_alloc(ctx->resolver, r->ipv6 ? len * 2 : len);
  2498. #else
  2499.     p = ngx_resolver_alloc(ctx->resolver, len);
  2500. #endif
  2501.     if (p == NULL) {
  2502.         return NGX_ERROR;
  2503.     }

  2505.     rn->qlen = (u_short) len;
  2506.     rn->query = p;

  2508. #if (NGX_HAVE_INET6)
  2509.     if (r->ipv6) {
  2510.         rn->query6 = p + len;
  2511.     }
  2512. #endif

  2514.     query = (ngx_resolver_hdr_t *) p;

  2516.     ident = ngx_random();

  2518.     ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->resolver->log, 0,
  2519.                    "resolve: \"%V\" A %i", &ctx->name, ident & 0xffff);

  2521.     query->ident_hi = (u_char) ((ident >> 8) & 0xff);
  2522.     query->ident_lo = (u_char) (ident & 0xff);

  2524.     /* recursion query */
  2525.     query->flags_hi = 1; query->flags_lo = 0;

  2527.     /* one question */
  2528.     query->nqs_hi = 0; query->nqs_lo = 1;
  2529.     query->nan_hi = 0; query->nan_lo = 0;
  2530.     query->nns_hi = 0; query->nns_lo = 0;
  2531.     query->nar_hi = 0; query->nar_lo = 0;

  2533.     p += sizeof(ngx_resolver_hdr_t) + nlen;

  2535.     qs = (ngx_resolver_qs_t *) p;

  2537.     /* query type */
  2538.     qs->type_hi = 0; qs->type_lo = NGX_RESOLVE_A;

  2540.     /* IN query class */
  2541.     qs->class_hi = 0; qs->class_lo = 1;

  2543.     /* convert "www.example.com" to "\3www\7example\3com\0" */

  2545.     len = 0;
  2546.     p--;
  2547.     *p-- = '\0';

  2549.     if (ctx->name.len == 0)  {
  2550.         return NGX_DECLINED;
  2551.     }

  2553.     for (s = ctx->name.data + ctx->name.len - 1; s >= ctx->name.data; s--) {
  2554.         if (*s != '.') {
  2555.             *p = *s;
  2556.             len++;

  2558.         } else {
  2559.             if (len == 0 || len > 255) {
  2560.                 return NGX_DECLINED;
  2561.             }

  2563.             *p = (u_char) len;
  2564.             len = 0;
  2565.         }

  2567.         p--;
  2568.     }

  2570.     if (len == 0 || len > 255) {
  2571.         return NGX_DECLINED;
  2572.     }

  2574.     *p = (u_char) len;

  2576. #if (NGX_HAVE_INET6)
  2577.     if (!r->ipv6) {
  2578.         return NGX_OK;
  2579.     }

  2581.     p = rn->query6;

  2583.     ngx_memcpy(p, rn->query, rn->qlen);

  2585.     query = (ngx_resolver_hdr_t *) p;

  2587.     ident = ngx_random();

  2589.     ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->resolver->log, 0,
  2590.                    "resolve: \"%V\" AAAA %i", &ctx->name, ident & 0xffff);

  2592.     query->ident_hi = (u_char) ((ident >> 8) & 0xff);
  2593.     query->ident_lo = (u_char) (ident & 0xff);

  2595.     p += sizeof(ngx_resolver_hdr_t) + nlen;

  2597.     qs = (ngx_resolver_qs_t *) p;

  2599.     qs->type_lo = NGX_RESOLVE_AAAA;
  2600. #endif

  2602.     return NGX_OK;
  2603. }


  2606. static ngx_int_t
  2607. ‌ngx_resolver_create_addr_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx)
  2608. {
  2609.     u_char               *p, *d;
  2610.     size_t                len;
  2611.     in_addr_t             addr;
  2612.     ngx_int_t             n;
  2613.     ngx_uint_t            ident;
  2614.     ngx_resolver_hdr_t   *query;
  2615.     struct sockaddr_in   *sin;
  2616. #if (NGX_HAVE_INET6)
  2617.     struct sockaddr_in6  *sin6;
  2618. #endif

  2620.     switch (ctx->addr.sockaddr->sa_family) {

  2622. #if (NGX_HAVE_INET6)
  2623.     case AF_INET6:
  2624.         len = sizeof(ngx_resolver_hdr_t)
  2625.               + 64 + sizeof(".ip6.arpa.") - 1
  2626.               + sizeof(ngx_resolver_qs_t);

  2628.         break;
  2629. #endif

  2631.     default: /* AF_INET */
  2632.         len = sizeof(ngx_resolver_hdr_t)
  2633.               + sizeof(".255.255.255.255.in-addr.arpa.") - 1
  2634.               + sizeof(ngx_resolver_qs_t);
  2635.     }

  2637.     p = ngx_resolver_alloc(ctx->resolver, len);
  2638.     if (p == NULL) {
  2639.         return NGX_ERROR;
  2640.     }

  2642.     rn->query = p;
  2643.     query = (ngx_resolver_hdr_t *) p;

  2645.     ident = ngx_random();

  2647.     query->ident_hi = (u_char) ((ident >> 8) & 0xff);
  2648.     query->ident_lo = (u_char) (ident & 0xff);

  2650.     /* recursion query */
  2651.     query->flags_hi = 1; query->flags_lo = 0;

  2653.     /* one question */
  2654.     query->nqs_hi = 0; query->nqs_lo = 1;
  2655.     query->nan_hi = 0; query->nan_lo = 0;
  2656.     query->nns_hi = 0; query->nns_lo = 0;
  2657.     query->nar_hi = 0; query->nar_lo = 0;

  2659.     p += sizeof(ngx_resolver_hdr_t);

  2661.     switch (ctx->addr.sockaddr->sa_family) {

  2663. #if (NGX_HAVE_INET6)
  2664.     case AF_INET6:
  2665.         sin6 = (struct sockaddr_in6 *) ctx->addr.sockaddr;

  2667.         for (n = 15; n >= 0; n--) {
  2668.             p = ngx_sprintf(p, "\1%xd\1%xd",
  2669.                             sin6->sin6_addr.s6_addr[n] & 0xf,
  2670.                             (sin6->sin6_addr.s6_addr[n] >> 4) & 0xf);
  2671.         }

  2673.         p = ngx_cpymem(p, "\3ip6\4arpa\0", 10);

  2675.         break;
  2676. #endif

  2678.     default: /* AF_INET */

  2680.         sin = (struct sockaddr_in *) ctx->addr.sockaddr;
  2681.         addr = ntohl(sin->sin_addr.s_addr);

  2683.         for (n = 0; n < 32; n += 8) {
  2684.             d = ngx_sprintf(&p[1], "%ud", (addr >> n) & 0xff);
  2685.             *p = (u_char) (d - &p[1]);
  2686.             p = d;
  2687.         }

  2689.         p = ngx_cpymem(p, "\7in-addr\4arpa\0", 14);
  2690.     }

  2692.     /* query type "PTR", IN query class */
  2693.     p = ngx_cpymem(p, "\0\14\0\1", 4);

  2695.     rn->qlen = (u_short) (p - rn->query);

  2697.     return NGX_OK;
  2698. }


  2701. static ngx_int_t
  2702. ‌ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name, u_char *buf, u_char *src,
  2703.     u_char *last)
  2704. {
  2705.     char        *err;
  2706.     u_char      *p, *dst;
  2707.     ssize_t      len;
  2708.     ngx_uint_t   i, n;

  2710.     p = src;
  2711.     len = -1;

  2713.     /*
  2714.      * compression pointers allow to create endless loop, so we set limit;
  2715.      * 128 pointers should be enough to store 255-byte name
  2716.      */

  2718.     for (i = 0; i < 128; i++) {
  2719.         n = *p++;

  2721.         if (n == 0) {
  2722.             goto done;
  2723.         }

  2725.         if (n & 0xc0) {
  2726.             n = ((n & 0x3f) << 8) + *p;
  2727.             p = &buf[n];

  2729.         } else {
  2730.             len += 1 + n;
  2731.             p = &p[n];
  2732.         }

  2734.         if (p >= last) {
  2735.             err = "name is out of response";
  2736.             goto invalid;
  2737.         }
  2738.     }

  2740.     err = "compression pointers loop";

  2742. invalid:

  2744.     ngx_log_error(r->log_level, r->log, 0, err);

  2746.     return NGX_ERROR;

  2748. done:

  2750.     if (name == NULL) {
  2751.         return NGX_OK;
  2752.     }

  2754.     if (len == -1) {
  2755.         ngx_str_null(name);
  2756.         return NGX_OK;
  2757.     }

  2759.     dst = ngx_resolver_alloc(r, len);
  2760.     if (dst == NULL) {
  2761.         return NGX_ERROR;
  2762.     }

  2764.     name->data = dst;

  2766.     n = *src++;

  2768.     for ( ;; ) {
  2769.         if (n & 0xc0) {
  2770.             n = ((n & 0x3f) << 8) + *src;
  2771.             src = &buf[n];

  2773.             n = *src++;

  2775.         } else {
  2776.             ngx_strlow(dst, src, n);
  2777.             dst += n;
  2778.             src += n;

  2780.             n = *src++;

  2782.             if (n != 0) {
  2783.                 *dst++ = '.';
  2784.             }
  2785.         }

  2787.         if (n == 0) {
  2788.             name->len = dst - name->data;
  2789.             return NGX_OK;
  2790.         }
  2791.     }
  2792. }


  2795. static void
  2796. ‌ngx_resolver_timeout_handler(ngx_event_t *ev)
  2797. {
  2798.     ngx_resolver_ctx_t   *ctx, *next;
  2799.     ngx_resolver_node_t  *rn;

  2801.     rn = ev->data;
  2802.     ctx = rn->waiting;
  2803.     rn->waiting = NULL;

  2805.     do {
  2806.         ctx->state = NGX_RESOLVE_TIMEDOUT;
  2807.         next = ctx->next;

  2809.         ctx->handler(ctx);

  2811.         ctx = next;
  2812.     } while (ctx);
  2813. }


  2816. static void
  2817. ‌ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn)
  2818. {
  2819.     /* lock alloc mutex */

  2821.     if (rn->query) {
  2822.         ngx_resolver_free_locked(r, rn->query);
  2823.     }

  2825.     if (rn->name) {
  2826.         ngx_resolver_free_locked(r, rn->name);
  2827.     }

  2829.     if (rn->cnlen) {
  2830.         ngx_resolver_free_locked(r, rn->u.cname);
  2831.     }

  2833.     if (rn->naddrs > 1 && rn->naddrs != (u_short) -1) {
  2834.         ngx_resolver_free_locked(r, rn->u.addrs);
  2835.     }

  2837. #if (NGX_HAVE_INET6)
  2838.     if (rn->naddrs6 > 1 && rn->naddrs6 != (u_short) -1) {
  2839.         ngx_resolver_free_locked(r, rn->u6.addrs6);
  2840.     }
  2841. #endif

  2843.     ngx_resolver_free_locked(r, rn);

  2845.     /* unlock alloc mutex */
  2846. }


  2849. static void *
  2850. ‌ngx_resolver_alloc(ngx_resolver_t *r, size_t size)
  2851. {
  2852.     u_char  *p;

  2854.     /* lock alloc mutex */

  2856.     p = ngx_alloc(size, r->log);

  2858.     /* unlock alloc mutex */

  2860.     return p;
  2861. }


  2864. static void *
  2865. ‌ngx_resolver_calloc(ngx_resolver_t *r, size_t size)
  2866. {
  2867.     u_char  *p;

  2869.     p = ngx_resolver_alloc(r, size);

  2871.     if (p) {
  2872.         ngx_memzero(p, size);
  2873.     }

  2875.     return p;
  2876. }


  2879. static void
  2880. ‌ngx_resolver_free(ngx_resolver_t *r, void *p)
  2881. {
  2882.     /* lock alloc mutex */

  2884.     ngx_free(p);

  2886.     /* unlock alloc mutex */
  2887. }


  2890. static void
  2891. ‌ngx_resolver_free_locked(ngx_resolver_t *r, void *p)
  2892. {
  2893.     ngx_free(p);
  2894. }


  2897. static void *
  2898. ‌ngx_resolver_dup(ngx_resolver_t *r, void *src, size_t size)
  2899. {
  2900.     void  *dst;

  2902.     dst = ngx_resolver_alloc(r, size);

  2904.     if (dst == NULL) {
  2905.         return dst;
  2906.     }

  2908.     ngx_memcpy(dst, src, size);

  2910.     return dst;
  2911. }


  2914. static ngx_addr_t *
  2915. ‌ngx_resolver_export(ngx_resolver_t *r, ngx_resolver_node_t *rn,
  2916.     ngx_uint_t rotate)
  2917. {
  2918.     ngx_addr_t            *dst;
  2919.     ngx_uint_t             d, i, j, n;
  2920.     u_char               (*sockaddr)[NGX_SOCKADDRLEN];
  2921.     in_addr_t             *addr;
  2922.     struct sockaddr_in    *sin;
  2923. #if (NGX_HAVE_INET6)
  2924.     struct in6_addr       *addr6;
  2925.     struct sockaddr_in6   *sin6;
  2926. #endif

  2928.     n = rn->naddrs;
  2929. #if (NGX_HAVE_INET6)
  2930.     n += rn->naddrs6;
  2931. #endif

  2933.     dst = ngx_resolver_calloc(r, n * sizeof(ngx_addr_t));
  2934.     if (dst == NULL) {
  2935.         return NULL;
  2936.     }

  2938.     sockaddr = ngx_resolver_calloc(r, n * NGX_SOCKADDRLEN);
  2939.     if (sockaddr == NULL) {
  2940.         ngx_resolver_free(r, dst);
  2941.         return NULL;
  2942.     }

  2944.     i = 0;
  2945.     d = rotate ? ngx_random() % n : 0;

  2947.     if (rn->naddrs) {
  2948.         j = rotate ? ngx_random() % rn->naddrs : 0;

  2950.         addr = (rn->naddrs == 1) ? &rn->u.addr : rn->u.addrs;

  2952.         do {
  2953.             sin = (struct sockaddr_in *) sockaddr[d];
  2954.             sin->sin_family = AF_INET;
  2955.             sin->sin_addr.s_addr = addr[j++];
  2956.             dst[d].sockaddr = (struct sockaddr *) sin;
  2957.             dst[d++].socklen = sizeof(struct sockaddr_in);

  2959.             if (d == n) {
  2960.                 d = 0;
  2961.             }

  2963.             if (j == rn->naddrs) {
  2964.                 j = 0;
  2965.             }
  2966.         } while (++i < rn->naddrs);
  2967.     }

  2969. #if (NGX_HAVE_INET6)
  2970.     if (rn->naddrs6) {
  2971.         j = rotate ? ngx_random() % rn->naddrs6 : 0;

  2973.         addr6 = (rn->naddrs6 == 1) ? &rn->u6.addr6 : rn->u6.addrs6;

  2975.         do {
  2976.             sin6 = (struct sockaddr_in6 *) sockaddr[d];
  2977.             sin6->sin6_family = AF_INET6;
  2978.             ngx_memcpy(sin6->sin6_addr.s6_addr, addr6[j++].s6_addr, 16);
  2979.             dst[d].sockaddr = (struct sockaddr *) sin6;
  2980.             dst[d++].socklen = sizeof(struct sockaddr_in6);

  2982.             if (d == n) {
  2983.                 d = 0;
  2984.             }

  2986.             if (j == rn->naddrs6) {
  2987.                 j = 0;
  2988.             }
  2989.         } while (++i < n);
  2990.     }
  2991. #endif

  2993.     return dst;
  2994. }


  2997. char *
  2998. ‌ngx_resolver_strerror(ngx_int_t err)
  2999. {
  3000.     static char *errors[] = {
  3001.         "Format error",     /* FORMERR */
  3002.         "Server failure",   /* SERVFAIL */
  3003.         "Host not found",   /* NXDOMAIN */
  3004.         "Unimplemented",    /* NOTIMP */
  3005.         "Operation refused" /* REFUSED */
  3006.     };

  3008.     if (err > 0 && err < 6) {
  3009.         return errors[err - 1];
  3010.     }

  3012.     if (err == NGX_RESOLVE_TIMEDOUT) {
  3013.         return "Operation timed out";
  3014.     }

  3016.     return "Unknown error";
  3017. }


  3020. static u_char *
  3021. ‌ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len)
  3022. {
  3023.     u_char                *p;
  3024.     ngx_udp_connection_t  *uc;

  3026.     p = buf;

  3028.     if (log->action) {
  3029.         p = ngx_snprintf(buf, len, " while %s", log->action);
  3030.         len -= p - buf;
  3031.     }

  3033.     uc = log->data;

  3035.     if (uc) {
  3036.         p = ngx_snprintf(p, len, ", resolver: %V", &uc->server);
  3037.     }

  3039.     return p;
  3040. }


  3043. ngx_int_t
  3044. ‌ngx_udp_connect(ngx_udp_connection_t *uc)
  3045. {
  3046.     int                rc;
  3047.     ngx_int_t          event;
  3048.     ngx_event_t       *rev, *wev;
  3049.     ngx_socket_t       s;
  3050.     ngx_connection_t  *c;

  3052.     s = ngx_socket(uc->sockaddr->sa_family, SOCK_DGRAM, 0);

  3054.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, &uc->log, 0, "UDP socket %d", s);

  3056.     if (s == (ngx_socket_t) -1) {
  3057.         ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
  3058.                       ngx_socket_n " failed");
  3059.         return NGX_ERROR;
  3060.     }

  3062.     c = ngx_get_connection(s, &uc->log);

  3064.     if (c == NULL) {
  3065.         if (ngx_close_socket(s) == -1) {
  3066.             ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
  3067.                           ngx_close_socket_n "failed");
  3068.         }

  3070.         return NGX_ERROR;
  3071.     }

  3073.     if (ngx_nonblocking(s) == -1) {
  3074.         ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
  3075.                       ngx_nonblocking_n " failed");

  3077.         goto failed;
  3078.     }

  3080.     rev = c->read;
  3081.     wev = c->write;

  3083.     rev->log = &uc->log;
  3084.     wev->log = &uc->log;

  3086.     uc->connection = c;

  3088.     c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);

  3090.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, &uc->log, 0,
  3091.                    "connect to %V, fd:%d #%uA", &uc->server, s, c->number);

  3093.     rc = connect(s, uc->sockaddr, uc->socklen);

  3095.     /* TODO: aio, iocp */

  3097.     if (rc == -1) {
  3098.         ngx_log_error(NGX_LOG_CRIT, &uc->log, ngx_socket_errno,
  3099.                       "connect() failed");

  3101.         goto failed;
  3102.     }

  3104.     /* UDP sockets are always ready to write */
  3105.     wev->ready = 1;

  3107.     if (ngx_add_event) {

  3109.         event = (ngx_event_flags & NGX_USE_CLEAR_EVENT) ?
  3110.                     /* kqueue, epoll */                 NGX_CLEAR_EVENT:
  3111.                     /* select, poll, /dev/poll */       NGX_LEVEL_EVENT;
  3112.                     /* eventport event type has no meaning: oneshot only */

  3114.         if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
  3115.             goto failed;
  3116.         }

  3118.     } else {
  3119.         /* rtsig */

  3121.         if (ngx_add_conn(c) == NGX_ERROR) {
  3122.             goto failed;
  3123.         }
  3124.     }

  3126.     return NGX_OK;

  3128. failed:

  3130.     ngx_close_connection(c);
  3131.     uc->connection = NULL;

  3133.     return NGX_ERROR;
  3134. }

One Level Up Top Level