Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_resolver.c
Go to the documentation of this file.
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) Nginx, Inc.
5  */
6 
7 
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10 #include <ngx_event.h>
11 
12 
13 #define NGX_RESOLVER_UDP_SIZE 4096
14 
15 
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_query_t;
30 
31 
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;
38 
39 
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;
49 
50 
51 ngx_int_t ngx_udp_connect(ngx_udp_connection_t *uc);
52 
53 
54 static void ngx_resolver_cleanup(void *data);
55 static void ngx_resolver_cleanup_tree(ngx_resolver_t *r, ngx_rbtree_t *tree);
56 static ngx_int_t ngx_resolve_name_locked(ngx_resolver_t *r,
57  ngx_resolver_ctx_t *ctx);
58 static void ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree,
59  ngx_queue_t *queue);
60 static ngx_int_t ngx_resolver_send_query(ngx_resolver_t *r,
61  ngx_resolver_node_t *rn);
62 static ngx_int_t ngx_resolver_create_name_query(ngx_resolver_node_t *rn,
63  ngx_resolver_ctx_t *ctx);
64 static ngx_int_t ngx_resolver_create_addr_query(ngx_resolver_node_t *rn,
65  ngx_resolver_ctx_t *ctx);
66 static void ngx_resolver_resend_handler(ngx_event_t *ev);
67 static time_t ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree,
68  ngx_queue_t *queue);
69 static void ngx_resolver_read_response(ngx_event_t *rev);
70 static void ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf,
71  size_t n);
72 static void ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
73  ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan, ngx_uint_t ans);
74 static void ngx_resolver_process_ptr(ngx_resolver_t *r, u_char *buf, size_t n,
75  ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan);
76 static ngx_resolver_node_t *ngx_resolver_lookup_name(ngx_resolver_t *r,
77  ngx_str_t *name, uint32_t hash);
78 static ngx_resolver_node_t *ngx_resolver_lookup_addr(ngx_resolver_t *r,
79  in_addr_t addr);
80 static void ngx_resolver_rbtree_insert_value(ngx_rbtree_node_t *temp,
81  ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
82 static ngx_int_t ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name,
83  u_char *buf, u_char *src, u_char *last);
84 static void ngx_resolver_timeout_handler(ngx_event_t *ev);
85 static void ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn);
86 static void *ngx_resolver_alloc(ngx_resolver_t *r, size_t size);
87 static void *ngx_resolver_calloc(ngx_resolver_t *r, size_t size);
88 static void ngx_resolver_free(ngx_resolver_t *r, void *p);
89 static void ngx_resolver_free_locked(ngx_resolver_t *r, void *p);
90 static void *ngx_resolver_dup(ngx_resolver_t *r, void *src, size_t size);
91 static in_addr_t *ngx_resolver_rotate(ngx_resolver_t *r, in_addr_t *src,
92  ngx_uint_t n);
93 static u_char *ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len);
94 
95 
96 ngx_resolver_t *
97 ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
98 {
99  ngx_str_t s;
100  ngx_url_t u;
101  ngx_uint_t i, j;
102  ngx_resolver_t *r;
103  ngx_pool_cleanup_t *cln;
104  ngx_udp_connection_t *uc;
105 
106  cln = ngx_pool_cleanup_add(cf->pool, 0);
107  if (cln == NULL) {
108  return NULL;
109  }
110 
111  cln->handler = ngx_resolver_cleanup;
112 
113  r = ngx_calloc(sizeof(ngx_resolver_t), cf->log);
114  if (r == NULL) {
115  return NULL;
116  }
117 
118  cln->data = r;
119 
120  r->event = ngx_calloc(sizeof(ngx_event_t), cf->log);
121  if (r->event == NULL) {
122  return NULL;
123  }
124 
125  ngx_rbtree_init(&r->name_rbtree, &r->name_sentinel,
126  ngx_resolver_rbtree_insert_value);
127 
128  ngx_rbtree_init(&r->addr_rbtree, &r->addr_sentinel,
129  ngx_rbtree_insert_value);
130 
131  ngx_queue_init(&r->name_resend_queue);
132  ngx_queue_init(&r->addr_resend_queue);
133 
134  ngx_queue_init(&r->name_expire_queue);
135  ngx_queue_init(&r->addr_expire_queue);
136 
137  r->event->handler = ngx_resolver_resend_handler;
138  r->event->data = r;
139  r->event->log = &cf->cycle->new_log;
140  r->ident = -1;
141 
142  r->resend_timeout = 5;
143  r->expire = 30;
144  r->valid = 0;
145 
146  r->log = &cf->cycle->new_log;
147  r->log_level = NGX_LOG_ERR;
148 
149  if (n) {
150  if (ngx_array_init(&r->udp_connections, cf->pool, n,
151  sizeof(ngx_udp_connection_t))
152  != NGX_OK)
153  {
154  return NULL;
155  }
156  }
157 
158  for (i = 0; i < n; i++) {
159  if (ngx_strncmp(names[i].data, "valid=", 6) == 0) {
160  s.len = names[i].len - 6;
161  s.data = names[i].data + 6;
162 
163  r->valid = ngx_parse_time(&s, 1);
164 
165  if (r->valid == (time_t) NGX_ERROR) {
166  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
167  "invalid parameter: %V", &names[i]);
168  return NULL;
169  }
170 
171  continue;
172  }
173 
174  ngx_memzero(&u, sizeof(ngx_url_t));
175 
176  u.url = names[i];
177  u.default_port = 53;
178 
179  if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
180  if (u.err) {
181  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
182  "%s in resolver \"%V\"",
183  u.err, &u.url);
184  }
185 
186  return NULL;
187  }
188 
189  uc = ngx_array_push_n(&r->udp_connections, u.naddrs);
190  if (uc == NULL) {
191  return NULL;
192  }
193 
194  ngx_memzero(uc, u.naddrs * sizeof(ngx_udp_connection_t));
195 
196  for (j = 0; j < u.naddrs; j++) {
197  uc[j].sockaddr = u.addrs[j].sockaddr;
198  uc[j].socklen = u.addrs[j].socklen;
199  uc[j].server = u.addrs[j].name;
200  }
201  }
202 
203  return r;
204 }
205 
206 
207 static void
208 ngx_resolver_cleanup(void *data)
209 {
210  ngx_resolver_t *r = data;
211 
212  ngx_uint_t i;
213  ngx_udp_connection_t *uc;
214 
215  if (r) {
216  ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
217  "cleanup resolver");
218 
219  ngx_resolver_cleanup_tree(r, &r->name_rbtree);
220 
221  ngx_resolver_cleanup_tree(r, &r->addr_rbtree);
222 
223  if (r->event) {
224  ngx_free(r->event);
225  }
226 
227 
228  uc = r->udp_connections.elts;
229 
230  for (i = 0; i < r->udp_connections.nelts; i++) {
231  if (uc[i].connection) {
232  ngx_close_connection(uc[i].connection);
233  }
234  }
235 
236  ngx_free(r);
237  }
238 }
239 
240 
241 static void
242 ngx_resolver_cleanup_tree(ngx_resolver_t *r, ngx_rbtree_t *tree)
243 {
244  ngx_resolver_ctx_t *ctx, *next;
245  ngx_resolver_node_t *rn;
246 
247  while (tree->root != tree->sentinel) {
248 
249  rn = (ngx_resolver_node_t *) ngx_rbtree_min(tree->root, tree->sentinel);
250 
251  ngx_queue_remove(&rn->queue);
252 
253  for (ctx = rn->waiting; ctx; ctx = next) {
254  next = ctx->next;
255 
256  if (ctx->event) {
257  ngx_resolver_free(r, ctx->event);
258  }
259 
260  ngx_resolver_free(r, ctx);
261  }
262 
263  ngx_rbtree_delete(tree, &rn->node);
264 
265  ngx_resolver_free_node(r, rn);
266  }
267 }
268 
269 
270 ngx_resolver_ctx_t *
271 ngx_resolve_start(ngx_resolver_t *r, ngx_resolver_ctx_t *temp)
272 {
273  in_addr_t addr;
274  ngx_resolver_ctx_t *ctx;
275 
276  if (temp) {
277  addr = ngx_inet_addr(temp->name.data, temp->name.len);
278 
279  if (addr != INADDR_NONE) {
280  temp->resolver = r;
281  temp->state = NGX_OK;
282  temp->naddrs = 1;
283  temp->addrs = &temp->addr;
284  temp->addr = addr;
285  temp->quick = 1;
286 
287  return temp;
288  }
289  }
290 
291  if (r->udp_connections.nelts == 0) {
292  return NGX_NO_RESOLVER;
293  }
294 
295  ctx = ngx_resolver_calloc(r, sizeof(ngx_resolver_ctx_t));
296 
297  if (ctx) {
298  ctx->resolver = r;
299  }
300 
301  return ctx;
302 }
303 
304 
305 ngx_int_t
306 ngx_resolve_name(ngx_resolver_ctx_t *ctx)
307 {
308  ngx_int_t rc;
309  ngx_resolver_t *r;
310 
311  r = ctx->resolver;
312 
313  ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
314  "resolve: \"%V\"", &ctx->name);
315 
316  if (ctx->quick) {
317  ctx->handler(ctx);
318  return NGX_OK;
319  }
320 
321  /* lock name mutex */
322 
323  rc = ngx_resolve_name_locked(r, ctx);
324 
325  if (rc == NGX_OK) {
326  return NGX_OK;
327  }
328 
329  /* unlock name mutex */
330 
331  if (rc == NGX_AGAIN) {
332  return NGX_OK;
333  }
334 
335  /* NGX_ERROR */
336 
337  if (ctx->event) {
338  ngx_resolver_free(r, ctx->event);
339  }
340 
341  ngx_resolver_free(r, ctx);
342 
343  return NGX_ERROR;
344 }
345 
346 
347 void
348 ngx_resolve_name_done(ngx_resolver_ctx_t *ctx)
349 {
350  uint32_t hash;
351  ngx_resolver_t *r;
352  ngx_resolver_ctx_t *w, **p;
353  ngx_resolver_node_t *rn;
354 
355  r = ctx->resolver;
356 
357  ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
358  "resolve name done: %i", ctx->state);
359 
360  if (ctx->quick) {
361  return;
362  }
363 
364  if (ctx->event && ctx->event->timer_set) {
365  ngx_del_timer(ctx->event);
366  }
367 
368  /* lock name mutex */
369 
370  if (ctx->state == NGX_AGAIN || ctx->state == NGX_RESOLVE_TIMEDOUT) {
371 
372  hash = ngx_crc32_short(ctx->name.data, ctx->name.len);
373 
374  rn = ngx_resolver_lookup_name(r, &ctx->name, hash);
375 
376  if (rn) {
377  p = &rn->waiting;
378  w = rn->waiting;
379 
380  while (w) {
381  if (w == ctx) {
382  *p = w->next;
383 
384  goto done;
385  }
386 
387  p = &w->next;
388  w = w->next;
389  }
390  }
391 
392  ngx_log_error(NGX_LOG_ALERT, r->log, 0,
393  "could not cancel %V resolving", &ctx->name);
394  }
395 
396 done:
397 
398  ngx_resolver_expire(r, &r->name_rbtree, &r->name_expire_queue);
399 
400  /* unlock name mutex */
401 
402  /* lock alloc mutex */
403 
404  if (ctx->event) {
405  ngx_resolver_free_locked(r, ctx->event);
406  }
407 
408  ngx_resolver_free_locked(r, ctx);
409 
410  /* unlock alloc mutex */
411 }
412 
413 
414 /* NGX_RESOLVE_A only */
415 
416 static ngx_int_t
417 ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx)
418 {
419  uint32_t hash;
420  in_addr_t addr, *addrs;
421  ngx_int_t rc;
422  ngx_uint_t naddrs;
423  ngx_resolver_ctx_t *next;
424  ngx_resolver_node_t *rn;
425 
426  hash = ngx_crc32_short(ctx->name.data, ctx->name.len);
427 
428  rn = ngx_resolver_lookup_name(r, &ctx->name, hash);
429 
430  if (rn) {
431 
432  if (rn->valid >= ngx_time()) {
433 
434  ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolve cached");
435 
436  ngx_queue_remove(&rn->queue);
437 
438  rn->expire = ngx_time() + r->expire;
439 
440  ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);
441 
442  naddrs = rn->naddrs;
443 
444  if (naddrs) {
445 
446  /* NGX_RESOLVE_A answer */
447 
448  if (naddrs != 1) {
449  addr = 0;
450  addrs = ngx_resolver_rotate(r, rn->u.addrs, naddrs);
451  if (addrs == NULL) {
452  return NGX_ERROR;
453  }
454 
455  } else {
456  addr = rn->u.addr;
457  addrs = NULL;
458  }
459 
460  ctx->next = rn->waiting;
461  rn->waiting = NULL;
462 
463  /* unlock name mutex */
464 
465  do {
466  ctx->state = NGX_OK;
467  ctx->naddrs = naddrs;
468  ctx->addrs = (naddrs == 1) ? &ctx->addr : addrs;
469  ctx->addr = addr;
470  next = ctx->next;
471 
472  ctx->handler(ctx);
473 
474  ctx = next;
475  } while (ctx);
476 
477  if (addrs) {
478  ngx_resolver_free(r, addrs);
479  }
480 
481  return NGX_OK;
482  }
483 
484  /* NGX_RESOLVE_CNAME */
485 
486  if (ctx->recursion++ < NGX_RESOLVER_MAX_RECURSION) {
487 
488  ctx->name.len = rn->cnlen;
489  ctx->name.data = rn->u.cname;
490 
491  return ngx_resolve_name_locked(r, ctx);
492  }
493 
494  ctx->next = rn->waiting;
495  rn->waiting = NULL;
496 
497  /* unlock name mutex */
498 
499  do {
500  ctx->state = NGX_RESOLVE_NXDOMAIN;
501  next = ctx->next;
502 
503  ctx->handler(ctx);
504 
505  ctx = next;
506  } while (ctx);
507 
508  return NGX_OK;
509  }
510 
511  if (rn->waiting) {
512 
513  ctx->next = rn->waiting;
514  rn->waiting = ctx;
515  ctx->state = NGX_AGAIN;
516 
517  return NGX_AGAIN;
518  }
519 
520  ngx_queue_remove(&rn->queue);
521 
522  /* lock alloc mutex */
523 
524  if (rn->query) {
525  ngx_resolver_free_locked(r, rn->query);
526  rn->query = NULL;
527  }
528 
529  if (rn->cnlen) {
530  ngx_resolver_free_locked(r, rn->u.cname);
531  }
532 
533  if (rn->naddrs > 1) {
534  ngx_resolver_free_locked(r, rn->u.addrs);
535  }
536 
537  /* unlock alloc mutex */
538 
539  } else {
540 
541  rn = ngx_resolver_alloc(r, sizeof(ngx_resolver_node_t));
542  if (rn == NULL) {
543  return NGX_ERROR;
544  }
545 
546  rn->name = ngx_resolver_dup(r, ctx->name.data, ctx->name.len);
547  if (rn->name == NULL) {
548  ngx_resolver_free(r, rn);
549  return NGX_ERROR;
550  }
551 
552  rn->node.key = hash;
553  rn->nlen = (u_short) ctx->name.len;
554  rn->query = NULL;
555 
556  ngx_rbtree_insert(&r->name_rbtree, &rn->node);
557  }
558 
559  rc = ngx_resolver_create_name_query(rn, ctx);
560 
561  if (rc == NGX_ERROR) {
562  goto failed;
563  }
564 
565  if (rc == NGX_DECLINED) {
566  ngx_rbtree_delete(&r->name_rbtree, &rn->node);
567 
568  ngx_resolver_free(r, rn->query);
569  ngx_resolver_free(r, rn->name);
570  ngx_resolver_free(r, rn);
571 
572  ctx->state = NGX_RESOLVE_NXDOMAIN;
573  ctx->handler(ctx);
574 
575  return NGX_OK;
576  }
577 
578  if (ngx_resolver_send_query(r, rn) != NGX_OK) {
579  goto failed;
580  }
581 
582  if (ctx->event == NULL) {
583  ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
584  if (ctx->event == NULL) {
585  goto failed;
586  }
587 
588  ctx->event->handler = ngx_resolver_timeout_handler;
589  ctx->event->data = ctx;
590  ctx->event->log = r->log;
591  ctx->ident = -1;
592 
593  ngx_add_timer(ctx->event, ctx->timeout);
594  }
595 
596  if (ngx_queue_empty(&r->name_resend_queue)) {
597  ngx_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
598  }
599 
600  rn->expire = ngx_time() + r->resend_timeout;
601 
602  ngx_queue_insert_head(&r->name_resend_queue, &rn->queue);
603 
604  rn->cnlen = 0;
605  rn->naddrs = 0;
606  rn->valid = 0;
607  rn->waiting = ctx;
608 
609  ctx->state = NGX_AGAIN;
610 
611  return NGX_AGAIN;
612 
613 failed:
614 
615  ngx_rbtree_delete(&r->name_rbtree, &rn->node);
616 
617  if (rn->query) {
618  ngx_resolver_free(r, rn->query);
619  }
620 
621  ngx_resolver_free(r, rn->name);
622 
623  ngx_resolver_free(r, rn);
624 
625  return NGX_ERROR;
626 }
627 
628 
629 ngx_int_t
630 ngx_resolve_addr(ngx_resolver_ctx_t *ctx)
631 {
632  u_char *name;
633  ngx_resolver_t *r;
634  ngx_resolver_node_t *rn;
635 
636  r = ctx->resolver;
637 
638  ctx->addr = ntohl(ctx->addr);
639 
640  /* lock addr mutex */
641 
642  rn = ngx_resolver_lookup_addr(r, ctx->addr);
643 
644  if (rn) {
645 
646  if (rn->valid >= ngx_time()) {
647 
648  ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolve cached");
649 
650  ngx_queue_remove(&rn->queue);
651 
652  rn->expire = ngx_time() + r->expire;
653 
654  ngx_queue_insert_head(&r->addr_expire_queue, &rn->queue);
655 
656  name = ngx_resolver_dup(r, rn->name, rn->nlen);
657  if (name == NULL) {
658  goto failed;
659  }
660 
661  ctx->name.len = rn->nlen;
662  ctx->name.data = name;
663 
664  /* unlock addr mutex */
665 
666  ctx->state = NGX_OK;
667 
668  ctx->handler(ctx);
669 
670  ngx_resolver_free(r, name);
671 
672  return NGX_OK;
673  }
674 
675  if (rn->waiting) {
676 
677  ctx->next = rn->waiting;
678  rn->waiting = ctx;
679  ctx->state = NGX_AGAIN;
680 
681  /* unlock addr mutex */
682 
683  return NGX_OK;
684  }
685 
686  ngx_queue_remove(&rn->queue);
687 
688  ngx_resolver_free(r, rn->query);
689  rn->query = NULL;
690 
691  } else {
692  rn = ngx_resolver_alloc(r, sizeof(ngx_resolver_node_t));
693  if (rn == NULL) {
694  goto failed;
695  }
696 
697  rn->node.key = ctx->addr;
698  rn->query = NULL;
699 
700  ngx_rbtree_insert(&r->addr_rbtree, &rn->node);
701  }
702 
703  if (ngx_resolver_create_addr_query(rn, ctx) != NGX_OK) {
704  goto failed;
705  }
706 
707  if (ngx_resolver_send_query(r, rn) != NGX_OK) {
708  goto failed;
709  }
710 
711  ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
712  if (ctx->event == NULL) {
713  goto failed;
714  }
715 
716  ctx->event->handler = ngx_resolver_timeout_handler;
717  ctx->event->data = ctx;
718  ctx->event->log = r->log;
719  ctx->ident = -1;
720 
721  ngx_add_timer(ctx->event, ctx->timeout);
722 
723  if (ngx_queue_empty(&r->addr_resend_queue)) {
724  ngx_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
725  }
726 
727  rn->expire = ngx_time() + r->resend_timeout;
728 
729  ngx_queue_insert_head(&r->addr_resend_queue, &rn->queue);
730 
731  rn->cnlen = 0;
732  rn->naddrs = 0;
733  rn->name = NULL;
734  rn->nlen = 0;
735  rn->valid = 0;
736  rn->waiting = ctx;
737 
738  /* unlock addr mutex */
739 
740  ctx->state = NGX_AGAIN;
741 
742  return NGX_OK;
743 
744 failed:
745 
746  if (rn) {
747  ngx_rbtree_delete(&r->addr_rbtree, &rn->node);
748 
749  if (rn->query) {
750  ngx_resolver_free(r, rn->query);
751  }
752 
753  ngx_resolver_free(r, rn);
754  }
755 
756  /* unlock addr mutex */
757 
758  if (ctx->event) {
759  ngx_resolver_free(r, ctx->event);
760  }
761 
762  ngx_resolver_free(r, ctx);
763 
764  return NGX_ERROR;
765 }
766 
767 
768 void
769 ngx_resolve_addr_done(ngx_resolver_ctx_t *ctx)
770 {
771  in_addr_t addr;
772  ngx_resolver_t *r;
773  ngx_resolver_ctx_t *w, **p;
774  ngx_resolver_node_t *rn;
775 
776  r = ctx->resolver;
777 
778  ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
779  "resolve addr done: %i", ctx->state);
780 
781  if (ctx->event && ctx->event->timer_set) {
782  ngx_del_timer(ctx->event);
783  }
784 
785  /* lock addr mutex */
786 
787  if (ctx->state == NGX_AGAIN || ctx->state == NGX_RESOLVE_TIMEDOUT) {
788 
789  rn = ngx_resolver_lookup_addr(r, ctx->addr);
790 
791  if (rn) {
792  p = &rn->waiting;
793  w = rn->waiting;
794 
795  while (w) {
796  if (w == ctx) {
797  *p = w->next;
798 
799  goto done;
800  }
801 
802  p = &w->next;
803  w = w->next;
804  }
805  }
806 
807  addr = ntohl(ctx->addr);
808 
809  ngx_log_error(NGX_LOG_ALERT, r->log, 0,
810  "could not cancel %ud.%ud.%ud.%ud resolving",
811  (addr >> 24) & 0xff, (addr >> 16) & 0xff,
812  (addr >> 8) & 0xff, addr & 0xff);
813  }
814 
815 done:
816 
817  ngx_resolver_expire(r, &r->addr_rbtree, &r->addr_expire_queue);
818 
819  /* unlock addr mutex */
820 
821  /* lock alloc mutex */
822 
823  if (ctx->event) {
824  ngx_resolver_free_locked(r, ctx->event);
825  }
826 
827  ngx_resolver_free_locked(r, ctx);
828 
829  /* unlock alloc mutex */
830 }
831 
832 
833 static void
834 ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree, ngx_queue_t *queue)
835 {
836  time_t now;
837  ngx_uint_t i;
838  ngx_queue_t *q;
839  ngx_resolver_node_t *rn;
840 
841  ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver expire");
842 
843  now = ngx_time();
844 
845  for (i = 0; i < 2; i++) {
846  if (ngx_queue_empty(queue)) {
847  return;
848  }
849 
850  q = ngx_queue_last(queue);
851 
852  rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
853 
854  if (now <= rn->expire) {
855  return;
856  }
857 
858  ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
859  "resolver expire \"%*s\"", (size_t) rn->nlen, rn->name);
860 
861  ngx_queue_remove(q);
862 
863  ngx_rbtree_delete(tree, &rn->node);
864 
865  ngx_resolver_free_node(r, rn);
866  }
867 }
868 
869 
870 static ngx_int_t
871 ngx_resolver_send_query(ngx_resolver_t *r, ngx_resolver_node_t *rn)
872 {
873  ssize_t n;
874  ngx_udp_connection_t *uc;
875 
876  uc = r->udp_connections.elts;
877 
878  uc = &uc[r->last_connection++];
879  if (r->last_connection == r->udp_connections.nelts) {
880  r->last_connection = 0;
881  }
882 
883  if (uc->connection == NULL) {
884 
885  uc->log = *r->log;
886  uc->log.handler = ngx_resolver_log_error;
887  uc->log.data = uc;
888  uc->log.action = "resolving";
889 
890  if (ngx_udp_connect(uc) != NGX_OK) {
891  return NGX_ERROR;
892  }
893 
894  uc->connection->data = r;
895  uc->connection->read->handler = ngx_resolver_read_response;
896  uc->connection->read->resolver = 1;
897  }
898 
899  n = ngx_send(uc->connection, rn->query, rn->qlen);
900 
901  if (n == -1) {
902  return NGX_ERROR;
903  }
904 
905  if ((size_t) n != (size_t) rn->qlen) {
906  ngx_log_error(NGX_LOG_CRIT, &uc->log, 0, "send() incomplete");
907  return NGX_ERROR;
908  }
909 
910  return NGX_OK;
911 }
912 
913 
914 static void
915 ngx_resolver_resend_handler(ngx_event_t *ev)
916 {
917  time_t timer, atimer, ntimer;
918  ngx_resolver_t *r;
919 
920  r = ev->data;
921 
922  ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0,
923  "resolver resend handler");
924 
925  /* lock name mutex */
926 
927  ntimer = ngx_resolver_resend(r, &r->name_rbtree, &r->name_resend_queue);
928 
929  /* unlock name mutex */
930 
931  /* lock addr mutex */
932 
933  atimer = ngx_resolver_resend(r, &r->addr_rbtree, &r->addr_resend_queue);
934 
935  /* unlock addr mutex */
936 
937  if (ntimer == 0) {
938  timer = atimer;
939 
940  } else if (atimer == 0) {
941  timer = ntimer;
942 
943  } else {
944  timer = (atimer < ntimer) ? atimer : ntimer;
945  }
946 
947  if (timer) {
948  ngx_add_timer(r->event, (ngx_msec_t) (timer * 1000));
949  }
950 }
951 
952 
953 static time_t
954 ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree, ngx_queue_t *queue)
955 {
956  time_t now;
957  ngx_queue_t *q;
958  ngx_resolver_node_t *rn;
959 
960  now = ngx_time();
961 
962  for ( ;; ) {
963  if (ngx_queue_empty(queue)) {
964  return 0;
965  }
966 
967  q = ngx_queue_last(queue);
968 
969  rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
970 
971  if (now < rn->expire) {
972  return rn->expire - now;
973  }
974 
975  ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
976  "resolver resend \"%*s\" %p",
977  (size_t) rn->nlen, rn->name, rn->waiting);
978 
979  ngx_queue_remove(q);
980 
981  if (rn->waiting) {
982 
983  (void) ngx_resolver_send_query(r, rn);
984 
985  rn->expire = now + r->resend_timeout;
986 
987  ngx_queue_insert_head(queue, q);
988 
989  continue;
990  }
991 
992  ngx_rbtree_delete(tree, &rn->node);
993 
994  ngx_resolver_free_node(r, rn);
995  }
996 }
997 
998 
999 static void
1000 ngx_resolver_read_response(ngx_event_t *rev)
1001 {
1002  ssize_t n;
1003  ngx_connection_t *c;
1004  u_char buf[NGX_RESOLVER_UDP_SIZE];
1005 
1006  c = rev->data;
1007 
1008  do {
1009  n = ngx_udp_recv(c, buf, NGX_RESOLVER_UDP_SIZE);
1010 
1011  if (n < 0) {
1012  return;
1013  }
1014 
1015  ngx_resolver_process_response(c->data, buf, n);
1016 
1017  } while (rev->ready);
1018 }
1019 
1020 
1021 static void
1022 ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n)
1023 {
1024  char *err;
1025  size_t len;
1026  ngx_uint_t i, times, ident, qident, flags, code, nqs, nan,
1027  qtype, qclass;
1028  ngx_queue_t *q;
1029  ngx_resolver_qs_t *qs;
1030  ngx_resolver_node_t *rn;
1031  ngx_resolver_query_t *query;
1032 
1033  if ((size_t) n < sizeof(ngx_resolver_query_t)) {
1034  goto short_response;
1035  }
1036 
1037  query = (ngx_resolver_query_t *) buf;
1038 
1039  ident = (query->ident_hi << 8) + query->ident_lo;
1040  flags = (query->flags_hi << 8) + query->flags_lo;
1041  nqs = (query->nqs_hi << 8) + query->nqs_lo;
1042  nan = (query->nan_hi << 8) + query->nan_lo;
1043 
1044  ngx_log_debug6(NGX_LOG_DEBUG_CORE, r->log, 0,
1045  "resolver DNS response %ui fl:%04Xui %ui/%ui/%ud/%ud",
1046  ident, flags, nqs, nan,
1047  (query->nns_hi << 8) + query->nns_lo,
1048  (query->nar_hi << 8) + query->nar_lo);
1049 
1050  if (!(flags & 0x8000)) {
1051  ngx_log_error(r->log_level, r->log, 0,
1052  "invalid DNS response %ui fl:%04Xui", ident, flags);
1053  return;
1054  }
1055 
1056  code = flags & 0x7f;
1057 
1058  if (code == NGX_RESOLVE_FORMERR) {
1059 
1060  times = 0;
1061 
1062  for (q = ngx_queue_head(&r->name_resend_queue);
1063  q != ngx_queue_sentinel(&r->name_resend_queue) || times++ < 100;
1064  q = ngx_queue_next(q))
1065  {
1066  rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
1067  qident = (rn->query[0] << 8) + rn->query[1];
1068 
1069  if (qident == ident) {
1070  ngx_log_error(r->log_level, r->log, 0,
1071  "DNS error (%ui: %s), query id:%ui, name:\"%*s\"",
1072  code, ngx_resolver_strerror(code), ident,
1073  rn->nlen, rn->name);
1074  return;
1075  }
1076  }
1077 
1078  goto dns_error;
1079  }
1080 
1081  if (code > NGX_RESOLVE_REFUSED) {
1082  goto dns_error;
1083  }
1084 
1085  if (nqs != 1) {
1086  err = "invalid number of questions in DNS response";
1087  goto done;
1088  }
1089 
1090  i = sizeof(ngx_resolver_query_t);
1091 
1092  while (i < (ngx_uint_t) n) {
1093  if (buf[i] == '\0') {
1094  goto found;
1095  }
1096 
1097  len = buf[i];
1098  i += 1 + len;
1099  }
1100 
1101  goto short_response;
1102 
1103 found:
1104 
1105  if (i++ == 0) {
1106  err = "zero-length domain name in DNS response";
1107  goto done;
1108  }
1109 
1110  if (i + sizeof(ngx_resolver_qs_t) + nan * (2 + sizeof(ngx_resolver_an_t))
1111  > (ngx_uint_t) n)
1112  {
1113  goto short_response;
1114  }
1115 
1116  qs = (ngx_resolver_qs_t *) &buf[i];
1117 
1118  qtype = (qs->type_hi << 8) + qs->type_lo;
1119  qclass = (qs->class_hi << 8) + qs->class_lo;
1120 
1121  ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
1122  "resolver DNS response qt:%ui cl:%ui", qtype, qclass);
1123 
1124  if (qclass != 1) {
1125  ngx_log_error(r->log_level, r->log, 0,
1126  "unknown query class %ui in DNS response", qclass);
1127  return;
1128  }
1129 
1130  switch (qtype) {
1131 
1132  case NGX_RESOLVE_A:
1133 
1134  ngx_resolver_process_a(r, buf, n, ident, code, nan,
1135  i + sizeof(ngx_resolver_qs_t));
1136 
1137  break;
1138 
1139  case NGX_RESOLVE_PTR:
1140 
1141  ngx_resolver_process_ptr(r, buf, n, ident, code, nan);
1142 
1143  break;
1144 
1145  default:
1146  ngx_log_error(r->log_level, r->log, 0,
1147  "unknown query type %ui in DNS response", qtype);
1148  return;
1149  }
1150 
1151  return;
1152 
1153 short_response:
1154 
1155  err = "short dns response";
1156 
1157 done:
1158 
1159  ngx_log_error(r->log_level, r->log, 0, err);
1160 
1161  return;
1162 
1163 dns_error:
1164 
1165  ngx_log_error(r->log_level, r->log, 0,
1166  "DNS error (%ui: %s), query id:%ui",
1167  code, ngx_resolver_strerror(code), ident);
1168  return;
1169 }
1170 
1171 
1172 static void
1173 ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
1174  ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan, ngx_uint_t ans)
1175 {
1176  char *err;
1177  u_char *cname;
1178  size_t len;
1179  int32_t ttl;
1180  uint32_t hash;
1181  in_addr_t addr, *addrs;
1182  ngx_str_t name;
1183  ngx_uint_t qtype, qident, naddrs, a, i, n, start;
1184  ngx_resolver_an_t *an;
1185  ngx_resolver_ctx_t *ctx, *next;
1186  ngx_resolver_node_t *rn;
1187 
1188  if (ngx_resolver_copy(r, &name, buf, &buf[12], &buf[last]) != NGX_OK) {
1189  return;
1190  }
1191 
1192  ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver qs:%V", &name);
1193 
1194  hash = ngx_crc32_short(name.data, name.len);
1195 
1196  /* lock name mutex */
1197 
1198  rn = ngx_resolver_lookup_name(r, &name, hash);
1199 
1200  if (rn == NULL || rn->query == NULL) {
1201  ngx_log_error(r->log_level, r->log, 0,
1202  "unexpected response for %V", &name);
1203  goto failed;
1204  }
1205 
1206  qident = (rn->query[0] << 8) + rn->query[1];
1207 
1208  if (ident != qident) {
1209  ngx_log_error(r->log_level, r->log, 0,
1210  "wrong ident %ui response for %V, expect %ui",
1211  ident, &name, qident);
1212  goto failed;
1213  }
1214 
1215  ngx_resolver_free(r, name.data);
1216 
1217  if (code == 0 && nan == 0) {
1218  code = 3; /* NXDOMAIN */
1219  }
1220 
1221  if (code) {
1222  next = rn->waiting;
1223  rn->waiting = NULL;
1224 
1225  ngx_queue_remove(&rn->queue);
1226 
1227  ngx_rbtree_delete(&r->name_rbtree, &rn->node);
1228 
1229  ngx_resolver_free_node(r, rn);
1230 
1231  /* unlock name mutex */
1232 
1233  while (next) {
1234  ctx = next;
1235  ctx->state = code;
1236  next = ctx->next;
1237 
1238  ctx->handler(ctx);
1239  }
1240 
1241  return;
1242  }
1243 
1244  i = ans;
1245  naddrs = 0;
1246  addr = 0;
1247  addrs = NULL;
1248  cname = NULL;
1249  qtype = 0;
1250  ttl = 0;
1251 
1252  for (a = 0; a < nan; a++) {
1253 
1254  start = i;
1255 
1256  while (i < last) {
1257 
1258  if (buf[i] & 0xc0) {
1259  i += 2;
1260  goto found;
1261  }
1262 
1263  if (buf[i] == 0) {
1264  i++;
1265  goto test_length;
1266  }
1267 
1268  i += 1 + buf[i];
1269  }
1270 
1271  goto short_response;
1272 
1273  test_length:
1274 
1275  if (i - start < 2) {
1276  err = "invalid name in dns response";
1277  goto invalid;
1278  }
1279 
1280  found:
1281 
1282  if (i + sizeof(ngx_resolver_an_t) >= last) {
1283  goto short_response;
1284  }
1285 
1286  an = (ngx_resolver_an_t *) &buf[i];
1287 
1288  qtype = (an->type_hi << 8) + an->type_lo;
1289  len = (an->len_hi << 8) + an->len_lo;
1290  ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16)
1291  + (an->ttl[2] << 8) + (an->ttl[3]);
1292 
1293  if (ttl < 0) {
1294  ttl = 0;
1295  }
1296 
1297  if (qtype == NGX_RESOLVE_A) {
1298 
1299  i += sizeof(ngx_resolver_an_t);
1300 
1301  if (i + len > last) {
1302  goto short_response;
1303  }
1304 
1305  addr = htonl((buf[i] << 24) + (buf[i + 1] << 16)
1306  + (buf[i + 2] << 8) + (buf[i + 3]));
1307 
1308  naddrs++;
1309 
1310  i += len;
1311 
1312  } else if (qtype == NGX_RESOLVE_CNAME) {
1313  cname = &buf[i] + sizeof(ngx_resolver_an_t);
1314  i += sizeof(ngx_resolver_an_t) + len;
1315 
1316  } else if (qtype == NGX_RESOLVE_DNAME) {
1317  i += sizeof(ngx_resolver_an_t) + len;
1318 
1319  } else {
1320  ngx_log_error(r->log_level, r->log, 0,
1321  "unexpected qtype %ui", qtype);
1322  }
1323  }
1324 
1325  ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
1326  "resolver naddrs:%ui cname:%p ttl:%d",
1327  naddrs, cname, ttl);
1328 
1329  if (naddrs) {
1330 
1331  if (naddrs == 1) {
1332  rn->u.addr = addr;
1333 
1334  } else {
1335 
1336  addrs = ngx_resolver_alloc(r, naddrs * sizeof(in_addr_t));
1337  if (addrs == NULL) {
1338  return;
1339  }
1340 
1341  n = 0;
1342  i = ans;
1343 
1344  for (a = 0; a < nan; a++) {
1345 
1346  for ( ;; ) {
1347 
1348  if (buf[i] & 0xc0) {
1349  i += 2;
1350  goto ok;
1351  }
1352 
1353  if (buf[i] == 0) {
1354  i++;
1355  goto ok;
1356  }
1357 
1358  i += 1 + buf[i];
1359  }
1360 
1361  ok:
1362 
1363  an = (ngx_resolver_an_t *) &buf[i];
1364 
1365  qtype = (an->type_hi << 8) + an->type_lo;
1366  len = (an->len_hi << 8) + an->len_lo;
1367 
1368  i += sizeof(ngx_resolver_an_t);
1369 
1370  if (qtype == NGX_RESOLVE_A) {
1371 
1372  addrs[n++] = htonl((buf[i] << 24) + (buf[i + 1] << 16)
1373  + (buf[i + 2] << 8) + (buf[i + 3]));
1374 
1375  if (n == naddrs) {
1376  break;
1377  }
1378  }
1379 
1380  i += len;
1381  }
1382 
1383  rn->u.addrs = addrs;
1384 
1385  addrs = ngx_resolver_dup(r, rn->u.addrs,
1386  naddrs * sizeof(in_addr_t));
1387  if (addrs == NULL) {
1388  return;
1389  }
1390  }
1391 
1392  rn->naddrs = (u_short) naddrs;
1393 
1394  ngx_queue_remove(&rn->queue);
1395 
1396  rn->valid = ngx_time() + (r->valid ? r->valid : ttl);
1397  rn->expire = ngx_time() + r->expire;
1398 
1399  ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);
1400 
1401  next = rn->waiting;
1402  rn->waiting = NULL;
1403 
1404  /* unlock name mutex */
1405 
1406  while (next) {
1407  ctx = next;
1408  ctx->state = NGX_OK;
1409  ctx->naddrs = naddrs;
1410  ctx->addrs = (naddrs == 1) ? &ctx->addr : addrs;
1411  ctx->addr = addr;
1412  next = ctx->next;
1413 
1414  ctx->handler(ctx);
1415  }
1416 
1417  if (naddrs > 1) {
1418  ngx_resolver_free(r, addrs);
1419  }
1420 
1421  ngx_resolver_free(r, rn->query);
1422  rn->query = NULL;
1423 
1424  return;
1425 
1426  } else if (cname) {
1427 
1428  /* CNAME only */
1429 
1430  if (ngx_resolver_copy(r, &name, buf, cname, &buf[last]) != NGX_OK) {
1431  return;
1432  }
1433 
1434  ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
1435  "resolver cname:\"%V\"", &name);
1436 
1437  ngx_queue_remove(&rn->queue);
1438 
1439  rn->cnlen = (u_short) name.len;
1440  rn->u.cname = name.data;
1441 
1442  rn->valid = ngx_time() + (r->valid ? r->valid : ttl);
1443  rn->expire = ngx_time() + r->expire;
1444 
1445  ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);
1446 
1447  ctx = rn->waiting;
1448  rn->waiting = NULL;
1449 
1450  if (ctx) {
1451  ctx->name = name;
1452 
1453  (void) ngx_resolve_name_locked(r, ctx);
1454  }
1455 
1456  ngx_resolver_free(r, rn->query);
1457  rn->query = NULL;
1458 
1459  return;
1460  }
1461 
1462  ngx_log_error(r->log_level, r->log, 0,
1463  "no A or CNAME types in DNS responses, unknown query type: %ui",
1464  qtype);
1465  return;
1466 
1467 short_response:
1468 
1469  err = "short dns response";
1470 
1471 invalid:
1472 
1473  /* unlock name mutex */
1474 
1475  ngx_log_error(r->log_level, r->log, 0, err);
1476 
1477  return;
1478 
1479 failed:
1480 
1481  /* unlock name mutex */
1482 
1483  ngx_resolver_free(r, name.data);
1484 
1485  return;
1486 }
1487 
1488 
1489 static void
1490 ngx_resolver_process_ptr(ngx_resolver_t *r, u_char *buf, size_t n,
1491  ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan)
1492 {
1493  char *err;
1494  size_t len;
1495  in_addr_t addr;
1496  int32_t ttl;
1497  ngx_int_t digit;
1498  ngx_str_t name;
1499  ngx_uint_t i, mask, qident;
1500  ngx_resolver_an_t *an;
1501  ngx_resolver_ctx_t *ctx, *next;
1502  ngx_resolver_node_t *rn;
1503 
1504  if (ngx_resolver_copy(r, NULL, buf, &buf[12], &buf[n]) != NGX_OK) {
1505  goto invalid_in_addr_arpa;
1506  }
1507 
1508  addr = 0;
1509  i = 12;
1510 
1511  for (mask = 0; mask < 32; mask += 8) {
1512  len = buf[i++];
1513 
1514  digit = ngx_atoi(&buf[i], len);
1515  if (digit == NGX_ERROR || digit > 255) {
1516  goto invalid_in_addr_arpa;
1517  }
1518 
1519  addr += digit << mask;
1520  i += len;
1521  }
1522 
1523  if (ngx_strcmp(&buf[i], "\7in-addr\4arpa") != 0) {
1524  goto invalid_in_addr_arpa;
1525  }
1526 
1527  /* lock addr mutex */
1528 
1529  rn = ngx_resolver_lookup_addr(r, addr);
1530 
1531  if (rn == NULL || rn->query == NULL) {
1532  ngx_log_error(r->log_level, r->log, 0,
1533  "unexpected response for %ud.%ud.%ud.%ud",
1534  (addr >> 24) & 0xff, (addr >> 16) & 0xff,
1535  (addr >> 8) & 0xff, addr & 0xff);
1536  goto failed;
1537  }
1538 
1539  qident = (rn->query[0] << 8) + rn->query[1];
1540 
1541  if (ident != qident) {
1542  ngx_log_error(r->log_level, r->log, 0,
1543  "wrong ident %ui response for %ud.%ud.%ud.%ud, expect %ui",
1544  ident, (addr >> 24) & 0xff, (addr >> 16) & 0xff,
1545  (addr >> 8) & 0xff, addr & 0xff, qident);
1546  goto failed;
1547  }
1548 
1549  if (code == 0 && nan == 0) {
1550  code = 3; /* NXDOMAIN */
1551  }
1552 
1553  if (code) {
1554  next = rn->waiting;
1555  rn->waiting = NULL;
1556 
1557  ngx_queue_remove(&rn->queue);
1558 
1559  ngx_rbtree_delete(&r->addr_rbtree, &rn->node);
1560 
1561  ngx_resolver_free_node(r, rn);
1562 
1563  /* unlock addr mutex */
1564 
1565  while (next) {
1566  ctx = next;
1567  ctx->state = code;
1568  next = ctx->next;
1569 
1570  ctx->handler(ctx);
1571  }
1572 
1573  return;
1574  }
1575 
1576  i += sizeof("\7in-addr\4arpa") + sizeof(ngx_resolver_qs_t);
1577 
1578  if (i + 2 + sizeof(ngx_resolver_an_t) > (ngx_uint_t) n) {
1579  goto short_response;
1580  }
1581 
1582  /* compression pointer to "XX.XX.XX.XX.in-addr.arpa */
1583 
1584  if (buf[i] != 0xc0 || buf[i + 1] != 0x0c) {
1585  err = "invalid in-addr.arpa name in DNS response";
1586  goto invalid;
1587  }
1588 
1589  an = (ngx_resolver_an_t *) &buf[i + 2];
1590 
1591  len = (an->len_hi << 8) + an->len_lo;
1592  ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16)
1593  + (an->ttl[2] << 8) + (an->ttl[3]);
1594 
1595  if (ttl < 0) {
1596  ttl = 0;
1597  }
1598 
1599  ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
1600  "resolver qt:%ui cl:%ui len:%uz",
1601  (an->type_hi << 8) + an->type_lo,
1602  (an->class_hi << 8) + an->class_lo, len);
1603 
1604  i += 2 + sizeof(ngx_resolver_an_t);
1605 
1606  if (i + len > (ngx_uint_t) n) {
1607  goto short_response;
1608  }
1609 
1610  if (ngx_resolver_copy(r, &name, buf, &buf[i], &buf[n]) != NGX_OK) {
1611  return;
1612  }
1613 
1614  ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver an:%V", &name);
1615 
1616  if (name.len != (size_t) rn->nlen
1617  || ngx_strncmp(name.data, rn->name, name.len) != 0)
1618  {
1619  if (rn->nlen) {
1620  ngx_resolver_free(r, rn->name);
1621  }
1622 
1623  rn->nlen = (u_short) name.len;
1624  rn->name = name.data;
1625 
1626  name.data = ngx_resolver_dup(r, rn->name, name.len);
1627  if (name.data == NULL) {
1628  goto failed;
1629  }
1630  }
1631 
1632  ngx_queue_remove(&rn->queue);
1633 
1634  rn->valid = ngx_time() + (r->valid ? r->valid : ttl);
1635  rn->expire = ngx_time() + r->expire;
1636 
1637  ngx_queue_insert_head(&r->addr_expire_queue, &rn->queue);
1638 
1639  next = rn->waiting;
1640  rn->waiting = NULL;
1641 
1642  /* unlock addr mutex */
1643 
1644  while (next) {
1645  ctx = next;
1646  ctx->state = NGX_OK;
1647  ctx->name = name;
1648  next = ctx->next;
1649 
1650  ctx->handler(ctx);
1651  }
1652 
1653  ngx_resolver_free(r, name.data);
1654 
1655  return;
1656 
1657 invalid_in_addr_arpa:
1658 
1659  ngx_log_error(r->log_level, r->log, 0,
1660  "invalid in-addr.arpa name in DNS response");
1661  return;
1662 
1663 short_response:
1664 
1665  err = "short DNS response";
1666 
1667 invalid:
1668 
1669  /* unlock addr mutex */
1670 
1671  ngx_log_error(r->log_level, r->log, 0, err);
1672 
1673  return;
1674 
1675 failed:
1676 
1677  /* unlock addr mutex */
1678 
1679  return;
1680 }
1681 
1682 
1683 static ngx_resolver_node_t *
1684 ngx_resolver_lookup_name(ngx_resolver_t *r, ngx_str_t *name, uint32_t hash)
1685 {
1686  ngx_int_t rc;
1687  ngx_rbtree_node_t *node, *sentinel;
1688  ngx_resolver_node_t *rn;
1689 
1690  node = r->name_rbtree.root;
1691  sentinel = r->name_rbtree.sentinel;
1692 
1693  while (node != sentinel) {
1694 
1695  if (hash < node->key) {
1696  node = node->left;
1697  continue;
1698  }
1699 
1700  if (hash > node->key) {
1701  node = node->right;
1702  continue;
1703  }
1704 
1705  /* hash == node->key */
1706 
1707  rn = (ngx_resolver_node_t *) node;
1708 
1709  rc = ngx_memn2cmp(name->data, rn->name, name->len, rn->nlen);
1710 
1711  if (rc == 0) {
1712  return rn;
1713  }
1714 
1715  node = (rc < 0) ? node->left : node->right;
1716  }
1717 
1718  /* not found */
1719 
1720  return NULL;
1721 }
1722 
1723 
1724 static ngx_resolver_node_t *
1725 ngx_resolver_lookup_addr(ngx_resolver_t *r, in_addr_t addr)
1726 {
1727  ngx_rbtree_node_t *node, *sentinel;
1728 
1729  node = r->addr_rbtree.root;
1730  sentinel = r->addr_rbtree.sentinel;
1731 
1732  while (node != sentinel) {
1733 
1734  if (addr < node->key) {
1735  node = node->left;
1736  continue;
1737  }
1738 
1739  if (addr > node->key) {
1740  node = node->right;
1741  continue;
1742  }
1743 
1744  /* addr == node->key */
1745 
1746  return (ngx_resolver_node_t *) node;
1747  }
1748 
1749  /* not found */
1750 
1751  return NULL;
1752 }
1753 
1754 
1755 static void
1756 ngx_resolver_rbtree_insert_value(ngx_rbtree_node_t *temp,
1757  ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
1758 {
1759  ngx_rbtree_node_t **p;
1760  ngx_resolver_node_t *rn, *rn_temp;
1761 
1762  for ( ;; ) {
1763 
1764  if (node->key < temp->key) {
1765 
1766  p = &temp->left;
1767 
1768  } else if (node->key > temp->key) {
1769 
1770  p = &temp->right;
1771 
1772  } else { /* node->key == temp->key */
1773 
1774  rn = (ngx_resolver_node_t *) node;
1775  rn_temp = (ngx_resolver_node_t *) temp;
1776 
1777  p = (ngx_memn2cmp(rn->name, rn_temp->name, rn->nlen, rn_temp->nlen)
1778  < 0) ? &temp->left : &temp->right;
1779  }
1780 
1781  if (*p == sentinel) {
1782  break;
1783  }
1784 
1785  temp = *p;
1786  }
1787 
1788  *p = node;
1789  node->parent = temp;
1790  node->left = sentinel;
1791  node->right = sentinel;
1792  ngx_rbt_red(node);
1793 }
1794 
1795 
1796 static ngx_int_t
1797 ngx_resolver_create_name_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx)
1798 {
1799  u_char *p, *s;
1800  size_t len, nlen;
1801  ngx_uint_t ident;
1802  ngx_resolver_qs_t *qs;
1803  ngx_resolver_query_t *query;
1804 
1805  nlen = ctx->name.len ? (1 + ctx->name.len + 1) : 1;
1806 
1807  len = sizeof(ngx_resolver_query_t) + nlen + sizeof(ngx_resolver_qs_t);
1808 
1809  p = ngx_resolver_alloc(ctx->resolver, len);
1810  if (p == NULL) {
1811  return NGX_ERROR;
1812  }
1813 
1814  rn->qlen = (u_short) len;
1815  rn->query = p;
1816 
1817  query = (ngx_resolver_query_t *) p;
1818 
1819  ident = ngx_random();
1820 
1821  ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->resolver->log, 0,
1822  "resolve: \"%V\" %i", &ctx->name, ident & 0xffff);
1823 
1824  query->ident_hi = (u_char) ((ident >> 8) & 0xff);
1825  query->ident_lo = (u_char) (ident & 0xff);
1826 
1827  /* recursion query */
1828  query->flags_hi = 1; query->flags_lo = 0;
1829 
1830  /* one question */
1831  query->nqs_hi = 0; query->nqs_lo = 1;
1832  query->nan_hi = 0; query->nan_lo = 0;
1833  query->nns_hi = 0; query->nns_lo = 0;
1834  query->nar_hi = 0; query->nar_lo = 0;
1835 
1836  p += sizeof(ngx_resolver_query_t) + nlen;
1837 
1838  qs = (ngx_resolver_qs_t *) p;
1839 
1840  /* query type */
1841  qs->type_hi = 0; qs->type_lo = (u_char) ctx->type;
1842 
1843  /* IP query class */
1844  qs->class_hi = 0; qs->class_lo = 1;
1845 
1846  /* convert "www.example.com" to "\3www\7example\3com\0" */
1847 
1848  len = 0;
1849  p--;
1850  *p-- = '\0';
1851 
1852  if (ctx->name.len == 0) {
1853  return NGX_DECLINED;
1854  }
1855 
1856  for (s = ctx->name.data + ctx->name.len - 1; s >= ctx->name.data; s--) {
1857  if (*s != '.') {
1858  *p = *s;
1859  len++;
1860 
1861  } else {
1862  if (len == 0 || len > 255) {
1863  return NGX_DECLINED;
1864  }
1865 
1866  *p = (u_char) len;
1867  len = 0;
1868  }
1869 
1870  p--;
1871  }
1872 
1873  if (len == 0 || len > 255) {
1874  return NGX_DECLINED;
1875  }
1876 
1877  *p = (u_char) len;
1878 
1879  return NGX_OK;
1880 }
1881 
1882 
1883 /* AF_INET only */
1884 
1885 static ngx_int_t
1886 ngx_resolver_create_addr_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx)
1887 {
1888  u_char *p, *d;
1889  size_t len;
1890  ngx_int_t n;
1891  ngx_uint_t ident;
1892  ngx_resolver_query_t *query;
1893 
1894  len = sizeof(ngx_resolver_query_t)
1895  + sizeof(".255.255.255.255.in-addr.arpa.") - 1
1896  + sizeof(ngx_resolver_qs_t);
1897 
1898  p = ngx_resolver_alloc(ctx->resolver, len);
1899  if (p == NULL) {
1900  return NGX_ERROR;
1901  }
1902 
1903  rn->query = p;
1904  query = (ngx_resolver_query_t *) p;
1905 
1906  ident = ngx_random();
1907 
1908  query->ident_hi = (u_char) ((ident >> 8) & 0xff);
1909  query->ident_lo = (u_char) (ident & 0xff);
1910 
1911  /* recursion query */
1912  query->flags_hi = 1; query->flags_lo = 0;
1913 
1914  /* one question */
1915  query->nqs_hi = 0; query->nqs_lo = 1;
1916  query->nan_hi = 0; query->nan_lo = 0;
1917  query->nns_hi = 0; query->nns_lo = 0;
1918  query->nar_hi = 0; query->nar_lo = 0;
1919 
1920  p += sizeof(ngx_resolver_query_t);
1921 
1922  for (n = 0; n < 32; n += 8) {
1923  d = ngx_sprintf(&p[1], "%ud", (ctx->addr >> n) & 0xff);
1924  *p = (u_char) (d - &p[1]);
1925  p = d;
1926  }
1927 
1928  /* query type "PTR", IP query class */
1929  ngx_memcpy(p, "\7in-addr\4arpa\0\0\14\0\1", 18);
1930 
1931  rn->qlen = (u_short)
1932  (p + sizeof("\7in-addr\4arpa") + sizeof(ngx_resolver_qs_t)
1933  - rn->query);
1934 
1935  return NGX_OK;
1936 }
1937 
1938 
1939 static ngx_int_t
1940 ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name, u_char *buf, u_char *src,
1941  u_char *last)
1942 {
1943  char *err;
1944  u_char *p, *dst;
1945  ssize_t len;
1946  ngx_uint_t i, n;
1947 
1948  p = src;
1949  len = -1;
1950 
1951  /*
1952  * compression pointers allow to create endless loop, so we set limit;
1953  * 128 pointers should be enough to store 255-byte name
1954  */
1955 
1956  for (i = 0; i < 128; i++) {
1957  n = *p++;
1958 
1959  if (n == 0) {
1960  goto done;
1961  }
1962 
1963  if (n & 0xc0) {
1964  n = ((n & 0x3f) << 8) + *p;
1965  p = &buf[n];
1966 
1967  } else {
1968  len += 1 + n;
1969  p = &p[n];
1970  }
1971 
1972  if (p >= last) {
1973  err = "name is out of response";
1974  goto invalid;
1975  }
1976  }
1977 
1978  err = "compression pointers loop";
1979 
1980 invalid:
1981 
1982  ngx_log_error(r->log_level, r->log, 0, err);
1983 
1984  return NGX_ERROR;
1985 
1986 done:
1987 
1988  if (name == NULL) {
1989  return NGX_OK;
1990  }
1991 
1992  if (len == -1) {
1993  name->len = 0;
1994  name->data = NULL;
1995  return NGX_OK;
1996  }
1997 
1998  dst = ngx_resolver_alloc(r, len);
1999  if (dst == NULL) {
2000  return NGX_ERROR;
2001  }
2002 
2003  name->data = dst;
2004 
2005  n = *src++;
2006 
2007  for ( ;; ) {
2008  if (n & 0xc0) {
2009  n = ((n & 0x3f) << 8) + *src;
2010  src = &buf[n];
2011 
2012  n = *src++;
2013 
2014  } else {
2015  ngx_memcpy(dst, src, n);
2016  dst += n;
2017  src += n;
2018 
2019  n = *src++;
2020 
2021  if (n != 0) {
2022  *dst++ = '.';
2023  }
2024  }
2025 
2026  if (n == 0) {
2027  name->len = dst - name->data;
2028  return NGX_OK;
2029  }
2030  }
2031 }
2032 
2033 
2034 static void
2035 ngx_resolver_timeout_handler(ngx_event_t *ev)
2036 {
2037  ngx_resolver_ctx_t *ctx;
2038 
2039  ctx = ev->data;
2040 
2041  ctx->state = NGX_RESOLVE_TIMEDOUT;
2042 
2043  ctx->handler(ctx);
2044 }
2045 
2046 
2047 static void
2048 ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn)
2049 {
2050  /* lock alloc mutex */
2051 
2052  if (rn->query) {
2053  ngx_resolver_free_locked(r, rn->query);
2054  }
2055 
2056  if (rn->name) {
2057  ngx_resolver_free_locked(r, rn->name);
2058  }
2059 
2060  if (rn->cnlen) {
2061  ngx_resolver_free_locked(r, rn->u.cname);
2062  }
2063 
2064  if (rn->naddrs > 1) {
2065  ngx_resolver_free_locked(r, rn->u.addrs);
2066  }
2067 
2068  ngx_resolver_free_locked(r, rn);
2069 
2070  /* unlock alloc mutex */
2071 }
2072 
2073 
2074 static void *
2075 ngx_resolver_alloc(ngx_resolver_t *r, size_t size)
2076 {
2077  u_char *p;
2078 
2079  /* lock alloc mutex */
2080 
2081  p = ngx_alloc(size, r->log);
2082 
2083  /* unlock alloc mutex */
2084 
2085  return p;
2086 }
2087 
2088 
2089 static void *
2090 ngx_resolver_calloc(ngx_resolver_t *r, size_t size)
2091 {
2092  u_char *p;
2093 
2094  p = ngx_resolver_alloc(r, size);
2095 
2096  if (p) {
2097  ngx_memzero(p, size);
2098  }
2099 
2100  return p;
2101 }
2102 
2103 
2104 static void
2105 ngx_resolver_free(ngx_resolver_t *r, void *p)
2106 {
2107  /* lock alloc mutex */
2108 
2109  ngx_free(p);
2110 
2111  /* unlock alloc mutex */
2112 }
2113 
2114 
2115 static void
2116 ngx_resolver_free_locked(ngx_resolver_t *r, void *p)
2117 {
2118  ngx_free(p);
2119 }
2120 
2121 
2122 static void *
2123 ngx_resolver_dup(ngx_resolver_t *r, void *src, size_t size)
2124 {
2125  void *dst;
2126 
2127  dst = ngx_resolver_alloc(r, size);
2128 
2129  if (dst == NULL) {
2130  return dst;
2131  }
2132 
2133  ngx_memcpy(dst, src, size);
2134 
2135  return dst;
2136 }
2137 
2138 
2139 static in_addr_t *
2140 ngx_resolver_rotate(ngx_resolver_t *r, in_addr_t *src, ngx_uint_t n)
2141 {
2142  void *dst, *p;
2143  ngx_uint_t j;
2144 
2145  dst = ngx_resolver_alloc(r, n * sizeof(in_addr_t));
2146 
2147  if (dst == NULL) {
2148  return dst;
2149  }
2150 
2151  j = ngx_random() % n;
2152 
2153  if (j == 0) {
2154  ngx_memcpy(dst, src, n * sizeof(in_addr_t));
2155  return dst;
2156  }
2157 
2158  p = ngx_cpymem(dst, &src[j], (n - j) * sizeof(in_addr_t));
2159  ngx_memcpy(p, src, j * sizeof(in_addr_t));
2160 
2161  return dst;
2162 }
2163 
2164 
2165 char *
2166 ngx_resolver_strerror(ngx_int_t err)
2167 {
2168  static char *errors[] = {
2169  "Format error", /* FORMERR */
2170  "Server failure", /* SERVFAIL */
2171  "Host not found", /* NXDOMAIN */
2172  "Unimplemented", /* NOTIMP */
2173  "Operation refused" /* REFUSED */
2174  };
2175 
2176  if (err > 0 && err < 6) {
2177  return errors[err - 1];
2178  }
2179 
2180  if (err == NGX_RESOLVE_TIMEDOUT) {
2181  return "Operation timed out";
2182  }
2183 
2184  return "Unknown error";
2185 }
2186 
2187 
2188 static u_char *
2189 ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len)
2190 {
2191  u_char *p;
2192  ngx_udp_connection_t *uc;
2193 
2194  p = buf;
2195 
2196  if (log->action) {
2197  p = ngx_snprintf(buf, len, " while %s", log->action);
2198  len -= p - buf;
2199  }
2200 
2201  uc = log->data;
2202 
2203  if (uc) {
2204  p = ngx_snprintf(p, len, ", resolver: %V", &uc->server);
2205  }
2206 
2207  return p;
2208 }
2209 
2210 
2211 ngx_int_t
2212 ngx_udp_connect(ngx_udp_connection_t *uc)
2213 {
2214  int rc;
2215  ngx_int_t event;
2216  ngx_event_t *rev, *wev;
2217  ngx_socket_t s;
2218  ngx_connection_t *c;
2219 
2220  s = ngx_socket(uc->sockaddr->sa_family, SOCK_DGRAM, 0);
2221 
2222  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, &uc->log, 0, "UDP socket %d", s);
2223 
2224  if (s == -1) {
2225  ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
2226  ngx_socket_n " failed");
2227  return NGX_ERROR;
2228  }
2229 
2230  c = ngx_get_connection(s, &uc->log);
2231 
2232  if (c == NULL) {
2233  if (ngx_close_socket(s) == -1) {
2234  ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
2235  ngx_close_socket_n "failed");
2236  }
2237 
2238  return NGX_ERROR;
2239  }
2240 
2241  if (ngx_nonblocking(s) == -1) {
2242  ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
2243  ngx_nonblocking_n " failed");
2244 
2245  ngx_free_connection(c);
2246 
2247  if (ngx_close_socket(s) == -1) {
2248  ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
2249  ngx_close_socket_n " failed");
2250  }
2251 
2252  return NGX_ERROR;
2253  }
2254 
2255  rev = c->read;
2256  wev = c->write;
2257 
2258  rev->log = &uc->log;
2259  wev->log = &uc->log;
2260 
2261  uc->connection = c;
2262 
2263  c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
2264 
2265 #if (NGX_THREADS)
2266 
2267  /* TODO: lock event when call completion handler */
2268 
2269  rev->lock = &c->lock;
2270  wev->lock = &c->lock;
2271  rev->own_lock = &c->lock;
2272  wev->own_lock = &c->lock;
2273 
2274 #endif
2275 
2276  ngx_log_debug3(NGX_LOG_DEBUG_EVENT, &uc->log, 0,
2277  "connect to %V, fd:%d #%d", &uc->server, s, c->number);
2278 
2279  rc = connect(s, uc->sockaddr, uc->socklen);
2280 
2281  /* TODO: aio, iocp */
2282 
2283  if (rc == -1) {
2284  ngx_log_error(NGX_LOG_CRIT, &uc->log, ngx_socket_errno,
2285  "connect() failed");
2286 
2287  return NGX_ERROR;
2288  }
2289 
2290  /* UDP sockets are always ready to write */
2291  wev->ready = 1;
2292 
2293  if (ngx_add_event) {
2294 
2295  event = (ngx_event_flags & NGX_USE_CLEAR_EVENT) ?
2296  /* kqueue, epoll */ NGX_CLEAR_EVENT:
2297  /* select, poll, /dev/poll */ NGX_LEVEL_EVENT;
2298  /* eventport event type has no meaning: oneshot only */
2299 
2300  if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
2301  return NGX_ERROR;
2302  }
2303 
2304  } else {
2305  /* rtsig */
2306 
2307  if (ngx_add_conn(c) == NGX_ERROR) {
2308  return NGX_ERROR;
2309  }
2310  }
2311 
2312  return NGX_OK;
2313 }
Generated on Sun Nov 10 2013 09:49:07 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2