Bug Summary

File:core/ngx_resolver.c
Location:line 854, column 20
Description:Use of memory after it is freed

Annotated Source Code

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_SIZE4096 4096
14
15
16typedef 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
32typedef 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
40typedef 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
51ngx_int_t ngx_udp_connect(ngx_udp_connection_t *uc);
52
53
54static void ngx_resolver_cleanup(void *data);
55static void ngx_resolver_cleanup_tree(ngx_resolver_t *r, ngx_rbtree_t *tree);
56static ngx_int_t ngx_resolve_name_locked(ngx_resolver_t *r,
57 ngx_resolver_ctx_t *ctx);
58static void ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree,
59 ngx_queue_t *queue);
60static ngx_int_t ngx_resolver_send_query(ngx_resolver_t *r,
61 ngx_resolver_node_t *rn);
62static ngx_int_t ngx_resolver_create_name_query(ngx_resolver_node_t *rn,
63 ngx_resolver_ctx_t *ctx);
64static ngx_int_t ngx_resolver_create_addr_query(ngx_resolver_node_t *rn,
65 ngx_resolver_ctx_t *ctx);
66static void ngx_resolver_resend_handler(ngx_event_t *ev);
67static time_t ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree,
68 ngx_queue_t *queue);
69static void ngx_resolver_read_response(ngx_event_t *rev);
70static void ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf,
71 size_t n);
72static 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);
74static 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);
76static ngx_resolver_node_t *ngx_resolver_lookup_name(ngx_resolver_t *r,
77 ngx_str_t *name, uint32_t hash);
78static ngx_resolver_node_t *ngx_resolver_lookup_addr(ngx_resolver_t *r,
79 in_addr_t addr);
80static void ngx_resolver_rbtree_insert_value(ngx_rbtree_node_t *temp,
81 ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
82static ngx_int_t ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name,
83 u_char *buf, u_char *src, u_char *last);
84static void ngx_resolver_timeout_handler(ngx_event_t *ev);
85static void ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn);
86static void *ngx_resolver_alloc(ngx_resolver_t *r, size_t size);
87static void *ngx_resolver_calloc(ngx_resolver_t *r, size_t size);
88static void ngx_resolver_free(ngx_resolver_t *r, void *p);
89static void ngx_resolver_free_locked(ngx_resolver_t *r, void *p);
90static void *ngx_resolver_dup(ngx_resolver_t *r, void *src, size_t size);
91static in_addr_t *ngx_resolver_rotate(ngx_resolver_t *r, in_addr_t *src,
92 ngx_uint_t n);
93static u_char *ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len);
94
95
96ngx_resolver_t *
97ngx_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((void*)0)) {
108 return NULL((void*)0);
109 }
110
111 cln->handler = ngx_resolver_cleanup;
112
113 r = ngx_calloc(sizeof(ngx_resolver_t), cf->log);
114 if (r == NULL((void*)0)) {
115 return NULL((void*)0);
116 }
117
118 cln->data = r;
119
120 r->event = ngx_calloc(sizeof(ngx_event_t), cf->log);
121 if (r->event == NULL((void*)0)) {
122 return NULL((void*)0);
123 }
124
125 ngx_rbtree_init(&r->name_rbtree, &r->name_sentinel,((&r->name_sentinel)->color = 0); (&r->name_rbtree
)->root = &r->name_sentinel; (&r->name_rbtree
)->sentinel = &r->name_sentinel; (&r->name_rbtree
)->insert = ngx_resolver_rbtree_insert_value
126 ngx_resolver_rbtree_insert_value)((&r->name_sentinel)->color = 0); (&r->name_rbtree
)->root = &r->name_sentinel; (&r->name_rbtree
)->sentinel = &r->name_sentinel; (&r->name_rbtree
)->insert = ngx_resolver_rbtree_insert_value;
127
128 ngx_rbtree_init(&r->addr_rbtree, &r->addr_sentinel,((&r->addr_sentinel)->color = 0); (&r->addr_rbtree
)->root = &r->addr_sentinel; (&r->addr_rbtree
)->sentinel = &r->addr_sentinel; (&r->addr_rbtree
)->insert = ngx_rbtree_insert_value
129 ngx_rbtree_insert_value)((&r->addr_sentinel)->color = 0); (&r->addr_rbtree
)->root = &r->addr_sentinel; (&r->addr_rbtree
)->sentinel = &r->addr_sentinel; (&r->addr_rbtree
)->insert = ngx_rbtree_insert_value;
130
131 ngx_queue_init(&r->name_resend_queue)(&r->name_resend_queue)->prev = &r->name_resend_queue
; (&r->name_resend_queue)->next = &r->name_resend_queue;
132 ngx_queue_init(&r->addr_resend_queue)(&r->addr_resend_queue)->prev = &r->addr_resend_queue
; (&r->addr_resend_queue)->next = &r->addr_resend_queue;
133
134 ngx_queue_init(&r->name_expire_queue)(&r->name_expire_queue)->prev = &r->name_expire_queue
; (&r->name_expire_queue)->next = &r->name_expire_queue;
135 ngx_queue_init(&r->addr_expire_queue)(&r->addr_expire_queue)->prev = &r->addr_expire_queue
; (&r->addr_expire_queue)->next = &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_ERR4;
148
149 if (n) {
150 if (ngx_array_init(&r->udp_connections, cf->pool, n,
151 sizeof(ngx_udp_connection_t))
152 != NGX_OK0)
153 {
154 return NULL((void*)0);
155 }
156 }
157
158 for (i = 0; i < n; i++) {
159 if (ngx_strncmp(names[i].data, "valid=", 6)strncmp((const char *) names[i].data, (const char *) "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-1) {
166 ngx_conf_log_error(NGX_LOG_EMERG1, cf, 0,
167 "invalid parameter: %V", &names[i]);
168 return NULL((void*)0);
169 }
170
171 continue;
172 }
173
174 ngx_memzero(&u, sizeof(ngx_url_t))(void) ((__builtin_object_size (&u, 0) != (size_t) -1) ? __builtin___memset_chk
(&u, 0, sizeof(ngx_url_t), __builtin_object_size (&u
, 0)) : __inline_memset_chk (&u, 0, 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_OK0) {
180 if (u.err) {
181 ngx_conf_log_error(NGX_LOG_EMERG1, cf, 0,
182 "%s in resolver \"%V\"",
183 u.err, &u.url);
184 }
185
186 return NULL((void*)0);
187 }
188
189 uc = ngx_array_push_n(&r->udp_connections, u.naddrs);
190 if (uc == NULL((void*)0)) {
191 return NULL((void*)0);
192 }
193
194 ngx_memzero(uc, u.naddrs * sizeof(ngx_udp_connection_t))(void) ((__builtin_object_size (uc, 0) != (size_t) -1) ? __builtin___memset_chk
(uc, 0, u.naddrs * sizeof(ngx_udp_connection_t), __builtin_object_size
(uc, 0)) : __inline_memset_chk (uc, 0, 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
207static void
208ngx_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_freefree(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_freefree(r);
237 }
238}
239
240
241static void
242ngx_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)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
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
270ngx_resolver_ctx_t *
271ngx_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_NONE0xffffffff) {
280 temp->resolver = r;
281 temp->state = NGX_OK0;
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(void *) -1;
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
305ngx_int_t
306ngx_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_OK0;
319 }
320
321 /* lock name mutex */
322
323 rc = ngx_resolve_name_locked(r, ctx);
324
325 if (rc == NGX_OK0) {
326 return NGX_OK0;
327 }
328
329 /* unlock name mutex */
330
331 if (rc == NGX_AGAIN-2) {
332 return NGX_OK0;
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-1;
344}
345
346
347void
348ngx_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_timerngx_event_del_timer(ctx->event);
366 }
367
368 /* lock name mutex */
369
370 if (ctx->state == NGX_AGAIN-2 || ctx->state == NGX_RESOLVE_TIMEDOUT60) {
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,if ((r->log)->log_level >= 2) ngx_log_error_core(2, r
->log, 0, "could not cancel %V resolving", &ctx->name
)
393 "could not cancel %V resolving", &ctx->name)if ((r->log)->log_level >= 2) ngx_log_error_core(2, r
->log, 0, "could not cancel %V resolving", &ctx->name
);
394 }
395
396done:
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
416static ngx_int_t
417ngx_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()ngx_cached_time->sec) {
433
434 ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolve cached");
435
436 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
437
438 rn->expire = ngx_time()ngx_cached_time->sec + r->expire;
439
440 ngx_queue_insert_head(&r->name_expire_queue, &rn->queue)(&rn->queue)->next = (&r->name_expire_queue)
->next; (&rn->queue)->next->prev = &rn->
queue; (&rn->queue)->prev = &r->name_expire_queue
; (&r->name_expire_queue)->next = &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((void*)0)) {
452 return NGX_ERROR-1;
453 }
454
455 } else {
456 addr = rn->u.addr;
457 addrs = NULL((void*)0);
458 }
459
460 ctx->next = rn->waiting;
461 rn->waiting = NULL((void*)0);
462
463 /* unlock name mutex */
464
465 do {
466 ctx->state = NGX_OK0;
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_OK0;
482 }
483
484 /* NGX_RESOLVE_CNAME */
485
486 if (ctx->recursion++ < NGX_RESOLVER_MAX_RECURSION50) {
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((void*)0);
496
497 /* unlock name mutex */
498
499 do {
500 ctx->state = NGX_RESOLVE_NXDOMAIN3;
501 next = ctx->next;
502
503 ctx->handler(ctx);
504
505 ctx = next;
506 } while (ctx);
507
508 return NGX_OK0;
509 }
510
511 if (rn->waiting) {
512
513 ctx->next = rn->waiting;
514 rn->waiting = ctx;
515 ctx->state = NGX_AGAIN-2;
516
517 return NGX_AGAIN-2;
518 }
519
520 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
521
522 /* lock alloc mutex */
523
524 if (rn->query) {
525 ngx_resolver_free_locked(r, rn->query);
526 rn->query = NULL((void*)0);
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((void*)0)) {
543 return NGX_ERROR-1;
544 }
545
546 rn->name = ngx_resolver_dup(r, ctx->name.data, ctx->name.len);
547 if (rn->name == NULL((void*)0)) {
548 ngx_resolver_free(r, rn);
549 return NGX_ERROR-1;
550 }
551
552 rn->node.key = hash;
553 rn->nlen = (u_short) ctx->name.len;
554 rn->query = NULL((void*)0);
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-1) {
562 goto failed;
563 }
564
565 if (rc == NGX_DECLINED-5) {
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_NXDOMAIN3;
573 ctx->handler(ctx);
574
575 return NGX_OK0;
576 }
577
578 if (ngx_resolver_send_query(r, rn) != NGX_OK0) {
579 goto failed;
580 }
581
582 if (ctx->event == NULL((void*)0)) {
583 ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
584 if (ctx->event == NULL((void*)0)) {
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_timerngx_event_add_timer(ctx->event, ctx->timeout);
594 }
595
596 if (ngx_queue_empty(&r->name_resend_queue)(&r->name_resend_queue == (&r->name_resend_queue
)->prev)) {
597 ngx_add_timerngx_event_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
598 }
599
600 rn->expire = ngx_time()ngx_cached_time->sec + r->resend_timeout;
601
602 ngx_queue_insert_head(&r->name_resend_queue, &rn->queue)(&rn->queue)->next = (&r->name_resend_queue)
->next; (&rn->queue)->next->prev = &rn->
queue; (&rn->queue)->prev = &r->name_resend_queue
; (&r->name_resend_queue)->next = &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-2;
610
611 return NGX_AGAIN-2;
612
613failed:
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-1;
626}
627
628
629ngx_int_t
630ngx_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)(__builtin_constant_p(ctx->addr) ? ((__uint32_t)((((__uint32_t
)(ctx->addr) & 0xff000000) >> 24) | (((__uint32_t
)(ctx->addr) & 0x00ff0000) >> 8) | (((__uint32_t
)(ctx->addr) & 0x0000ff00) << 8) | (((__uint32_t
)(ctx->addr) & 0x000000ff) << 24))) : _OSSwapInt32
(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()ngx_cached_time->sec) {
647
648 ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolve cached");
649
650 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
651
652 rn->expire = ngx_time()ngx_cached_time->sec + r->expire;
653
654 ngx_queue_insert_head(&r->addr_expire_queue, &rn->queue)(&rn->queue)->next = (&r->addr_expire_queue)
->next; (&rn->queue)->next->prev = &rn->
queue; (&rn->queue)->prev = &r->addr_expire_queue
; (&r->addr_expire_queue)->next = &rn->queue;
655
656 name = ngx_resolver_dup(r, rn->name, rn->nlen);
657 if (name == NULL((void*)0)) {
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_OK0;
667
668 ctx->handler(ctx);
669
670 ngx_resolver_free(r, name);
671
672 return NGX_OK0;
673 }
674
675 if (rn->waiting) {
676
677 ctx->next = rn->waiting;
678 rn->waiting = ctx;
679 ctx->state = NGX_AGAIN-2;
680
681 /* unlock addr mutex */
682
683 return NGX_OK0;
684 }
685
686 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
687
688 ngx_resolver_free(r, rn->query);
689 rn->query = NULL((void*)0);
690
691 } else {
692 rn = ngx_resolver_alloc(r, sizeof(ngx_resolver_node_t));
693 if (rn == NULL((void*)0)) {
694 goto failed;
695 }
696
697 rn->node.key = ctx->addr;
698 rn->query = NULL((void*)0);
699
700 ngx_rbtree_insert(&r->addr_rbtree, &rn->node);
701 }
702
703 if (ngx_resolver_create_addr_query(rn, ctx) != NGX_OK0) {
704 goto failed;
705 }
706
707 if (ngx_resolver_send_query(r, rn) != NGX_OK0) {
708 goto failed;
709 }
710
711 ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
712 if (ctx->event == NULL((void*)0)) {
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_timerngx_event_add_timer(ctx->event, ctx->timeout);
722
723 if (ngx_queue_empty(&r->addr_resend_queue)(&r->addr_resend_queue == (&r->addr_resend_queue
)->prev)) {
724 ngx_add_timerngx_event_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
725 }
726
727 rn->expire = ngx_time()ngx_cached_time->sec + r->resend_timeout;
728
729 ngx_queue_insert_head(&r->addr_resend_queue, &rn->queue)(&rn->queue)->next = (&r->addr_resend_queue)
->next; (&rn->queue)->next->prev = &rn->
queue; (&rn->queue)->prev = &r->addr_resend_queue
; (&r->addr_resend_queue)->next = &rn->queue;
730
731 rn->cnlen = 0;
732 rn->naddrs = 0;
733 rn->name = NULL((void*)0);
734 rn->nlen = 0;
735 rn->valid = 0;
736 rn->waiting = ctx;
737
738 /* unlock addr mutex */
739
740 ctx->state = NGX_AGAIN-2;
741
742 return NGX_OK0;
743
744failed:
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-1;
765}
766
767
768void
769ngx_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_timerngx_event_del_timer(ctx->event);
783 }
784
785 /* lock addr mutex */
786
787 if (ctx->state == NGX_AGAIN-2 || ctx->state == NGX_RESOLVE_TIMEDOUT60) {
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)(__builtin_constant_p(ctx->addr) ? ((__uint32_t)((((__uint32_t
)(ctx->addr) & 0xff000000) >> 24) | (((__uint32_t
)(ctx->addr) & 0x00ff0000) >> 8) | (((__uint32_t
)(ctx->addr) & 0x0000ff00) << 8) | (((__uint32_t
)(ctx->addr) & 0x000000ff) << 24))) : _OSSwapInt32
(ctx->addr));
808
809 ngx_log_error(NGX_LOG_ALERT, r->log, 0,if ((r->log)->log_level >= 2) ngx_log_error_core(2, r
->log, 0, "could not cancel %ud.%ud.%ud.%ud resolving", (addr
>> 24) & 0xff, (addr >> 16) & 0xff, (addr
>> 8) & 0xff, addr & 0xff)
810 "could not cancel %ud.%ud.%ud.%ud resolving",if ((r->log)->log_level >= 2) ngx_log_error_core(2, r
->log, 0, "could not cancel %ud.%ud.%ud.%ud resolving", (addr
>> 24) & 0xff, (addr >> 16) & 0xff, (addr
>> 8) & 0xff, addr & 0xff)
811 (addr >> 24) & 0xff, (addr >> 16) & 0xff,if ((r->log)->log_level >= 2) ngx_log_error_core(2, r
->log, 0, "could not cancel %ud.%ud.%ud.%ud resolving", (addr
>> 24) & 0xff, (addr >> 16) & 0xff, (addr
>> 8) & 0xff, addr & 0xff)
812 (addr >> 8) & 0xff, addr & 0xff)if ((r->log)->log_level >= 2) ngx_log_error_core(2, r
->log, 0, "could not cancel %ud.%ud.%ud.%ud resolving", (addr
>> 24) & 0xff, (addr >> 16) & 0xff, (addr
>> 8) & 0xff, addr & 0xff);
813 }
814
815done:
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
833static void
834ngx_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()ngx_cached_time->sec;
844
845 for (i = 0; i < 2; i++) {
1
Loop condition is true. Entering loop body
→
13
←
Loop condition is true. Entering loop body
→
846 if (ngx_queue_empty(queue)(queue == (queue)->prev)) {
2
←
Taking false branch
→
14
←
Taking false branch
→
847 return;
848 }
849
850 q = ngx_queue_last(queue)(queue)->prev;
851
852 rn = ngx_queue_data(q, ngx_resolver_node_t, queue)(ngx_resolver_node_t *) ((u_char *) q - __builtin_offsetof(ngx_resolver_node_t
, queue));
853
854 if (now <= rn->expire) {
3
←
Taking false branch
→
15
←
Use of memory after it is freed
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)(q)->next->prev = (q)->prev; (q)->prev->next =
(q)->next;
862
863 ngx_rbtree_delete(tree, &rn->node);
864
865 ngx_resolver_free_node(r, rn);
4
←
Calling 'ngx_resolver_free_node'
→
12
←
Returning; memory was released
→
866 }
867}
868
869
870static ngx_int_t
871ngx_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((void*)0)) {
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_OK0) {
891 return NGX_ERROR-1;
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_sendngx_io.send(uc->connection, rn->query, rn->qlen);
900
901 if (n == -1) {
902 return NGX_ERROR-1;
903 }
904
905 if ((size_t) n != (size_t) rn->qlen) {
906 ngx_log_error(NGX_LOG_CRIT, &uc->log, 0, "send() incomplete")if ((&uc->log)->log_level >= 3) ngx_log_error_core
(3, &uc->log, 0, "send() incomplete");
907 return NGX_ERROR-1;
908 }
909
910 return NGX_OK0;
911}
912
913
914static void
915ngx_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_timerngx_event_add_timer(r->event, (ngx_msec_t) (timer * 1000));
949 }
950}
951
952
953static time_t
954ngx_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()ngx_cached_time->sec;
961
962 for ( ;; ) {
963 if (ngx_queue_empty(queue)(queue == (queue)->prev)) {
964 return 0;
965 }
966
967 q = ngx_queue_last(queue)(queue)->prev;
968
969 rn = ngx_queue_data(q, ngx_resolver_node_t, queue)(ngx_resolver_node_t *) ((u_char *) q - __builtin_offsetof(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)(q)->next->prev = (q)->prev; (q)->prev->next =
(q)->next;
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)(q)->next = (queue)->next; (q)->next->prev = q; (
q)->prev = queue; (queue)->next = 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
999static void
1000ngx_resolver_read_response(ngx_event_t *rev)
1001{
1002 ssize_t n;
1003 ngx_connection_t *c;
1004 u_char buf[NGX_RESOLVER_UDP_SIZE4096];
1005
1006 c = rev->data;
1007
1008 do {
1009 n = ngx_udp_recvngx_io.udp_recv(c, buf, NGX_RESOLVER_UDP_SIZE4096);
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
1021static void
1022ngx_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,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "invalid DNS response %ui fl:%04Xui"
, ident, flags)
1052 "invalid DNS response %ui fl:%04Xui", ident, flags)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "invalid DNS response %ui fl:%04Xui"
, ident, flags);
1053 return;
1054 }
1055
1056 code = flags & 0x7f;
1057
1058 if (code == NGX_RESOLVE_FORMERR1) {
1059
1060 times = 0;
1061
1062 for (q = ngx_queue_head(&r->name_resend_queue)(&r->name_resend_queue)->next;
1063 q != ngx_queue_sentinel(&r->name_resend_queue)(&r->name_resend_queue) || times++ < 100;
1064 q = ngx_queue_next(q)(q)->next)
1065 {
1066 rn = ngx_queue_data(q, ngx_resolver_node_t, queue)(ngx_resolver_node_t *) ((u_char *) q - __builtin_offsetof(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,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "DNS error (%ui: %s), query id:%ui, name:\"%*s\""
, code, ngx_resolver_strerror(code), ident, rn->nlen, rn->
name)
1071 "DNS error (%ui: %s), query id:%ui, name:\"%*s\"",if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "DNS error (%ui: %s), query id:%ui, name:\"%*s\""
, code, ngx_resolver_strerror(code), ident, rn->nlen, rn->
name)
1072 code, ngx_resolver_strerror(code), ident,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "DNS error (%ui: %s), query id:%ui, name:\"%*s\""
, code, ngx_resolver_strerror(code), ident, rn->nlen, rn->
name)
1073 rn->nlen, rn->name)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "DNS error (%ui: %s), query id:%ui, name:\"%*s\""
, code, ngx_resolver_strerror(code), ident, rn->nlen, rn->
name);
1074 return;
1075 }
1076 }
1077
1078 goto dns_error;
1079 }
1080
1081 if (code > NGX_RESOLVE_REFUSED5) {
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
1103found:
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,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unknown query class %ui in DNS response"
, qclass)
1126 "unknown query class %ui in DNS response", qclass)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unknown query class %ui in DNS response"
, qclass);
1127 return;
1128 }
1129
1130 switch (qtype) {
1131
1132 case NGX_RESOLVE_A1:
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_PTR12:
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,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unknown query type %ui in DNS response"
, qtype)
1147 "unknown query type %ui in DNS response", qtype)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unknown query type %ui in DNS response"
, qtype);
1148 return;
1149 }
1150
1151 return;
1152
1153short_response:
1154
1155 err = "short dns response";
1156
1157done:
1158
1159 ngx_log_error(r->log_level, r->log, 0, err)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, err);
1160
1161 return;
1162
1163dns_error:
1164
1165 ngx_log_error(r->log_level, r->log, 0,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "DNS error (%ui: %s), query id:%ui"
, code, ngx_resolver_strerror(code), ident)
1166 "DNS error (%ui: %s), query id:%ui",if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "DNS error (%ui: %s), query id:%ui"
, code, ngx_resolver_strerror(code), ident)
1167 code, ngx_resolver_strerror(code), ident)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "DNS error (%ui: %s), query id:%ui"
, code, ngx_resolver_strerror(code), ident);
1168 return;
1169}
1170
1171
1172static void
1173ngx_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_OK0) {
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((void*)0) || rn->query == NULL((void*)0)) {
1201 ngx_log_error(r->log_level, r->log, 0,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unexpected response for %V",
&name)
1202 "unexpected response for %V", &name)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "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,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "wrong ident %ui response for %V, expect %ui"
, ident, &name, qident)
1210 "wrong ident %ui response for %V, expect %ui",if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "wrong ident %ui response for %V, expect %ui"
, ident, &name, qident)
1211 ident, &name, qident)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "wrong ident %ui response for %V, expect %ui"
, 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((void*)0);
1224
1225 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
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((void*)0);
1248 cname = NULL((void*)0);
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_A1) {
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)(__builtin_constant_p((buf[i] << 24) + (buf[i + 1] <<
16) + (buf[i + 2] << 8) + (buf[i + 3])) ? ((__uint32_t
)((((__uint32_t)((buf[i] << 24) + (buf[i + 1] << 16
) + (buf[i + 2] << 8) + (buf[i + 3])) & 0xff000000)
>> 24) | (((__uint32_t)((buf[i] << 24) + (buf[i +
1] << 16) + (buf[i + 2] << 8) + (buf[i + 3])) &
0x00ff0000) >> 8) | (((__uint32_t)((buf[i] << 24
) + (buf[i + 1] << 16) + (buf[i + 2] << 8) + (buf
[i + 3])) & 0x0000ff00) << 8) | (((__uint32_t)((buf
[i] << 24) + (buf[i + 1] << 16) + (buf[i + 2] <<
8) + (buf[i + 3])) & 0x000000ff) << 24))) : _OSSwapInt32
((buf[i] << 24) + (buf[i + 1] << 16) + (buf[i + 2
] << 8) + (buf[i + 3])))
1306 + (buf[i + 2] << 8) + (buf[i + 3]))(__builtin_constant_p((buf[i] << 24) + (buf[i + 1] <<
16) + (buf[i + 2] << 8) + (buf[i + 3])) ? ((__uint32_t
)((((__uint32_t)((buf[i] << 24) + (buf[i + 1] << 16
) + (buf[i + 2] << 8) + (buf[i + 3])) & 0xff000000)
>> 24) | (((__uint32_t)((buf[i] << 24) + (buf[i +
1] << 16) + (buf[i + 2] << 8) + (buf[i + 3])) &
0x00ff0000) >> 8) | (((__uint32_t)((buf[i] << 24
) + (buf[i + 1] << 16) + (buf[i + 2] << 8) + (buf
[i + 3])) & 0x0000ff00) << 8) | (((__uint32_t)((buf
[i] << 24) + (buf[i + 1] << 16) + (buf[i + 2] <<
8) + (buf[i + 3])) & 0x000000ff) << 24))) : _OSSwapInt32
((buf[i] << 24) + (buf[i + 1] << 16) + (buf[i + 2
] << 8) + (buf[i + 3])));
1307
1308 naddrs++;
1309
1310 i += len;
1311
1312 } else if (qtype == NGX_RESOLVE_CNAME5) {
1313 cname = &buf[i] + sizeof(ngx_resolver_an_t);
1314 i += sizeof(ngx_resolver_an_t) + len;
1315
1316 } else if (qtype == NGX_RESOLVE_DNAME39) {
1317 i += sizeof(ngx_resolver_an_t) + len;
1318
1319 } else {
1320 ngx_log_error(r->log_level, r->log, 0,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unexpected qtype %ui", qtype
)
1321 "unexpected qtype %ui", qtype)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "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((void*)0)) {
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_A1) {
1371
1372 addrs[n++] = htonl((buf[i] << 24) + (buf[i + 1] << 16)(__builtin_constant_p((buf[i] << 24) + (buf[i + 1] <<
16) + (buf[i + 2] << 8) + (buf[i + 3])) ? ((__uint32_t
)((((__uint32_t)((buf[i] << 24) + (buf[i + 1] << 16
) + (buf[i + 2] << 8) + (buf[i + 3])) & 0xff000000)
>> 24) | (((__uint32_t)((buf[i] << 24) + (buf[i +
1] << 16) + (buf[i + 2] << 8) + (buf[i + 3])) &
0x00ff0000) >> 8) | (((__uint32_t)((buf[i] << 24
) + (buf[i + 1] << 16) + (buf[i + 2] << 8) + (buf
[i + 3])) & 0x0000ff00) << 8) | (((__uint32_t)((buf
[i] << 24) + (buf[i + 1] << 16) + (buf[i + 2] <<
8) + (buf[i + 3])) & 0x000000ff) << 24))) : _OSSwapInt32
((buf[i] << 24) + (buf[i + 1] << 16) + (buf[i + 2
] << 8) + (buf[i + 3])))
1373 + (buf[i + 2] << 8) + (buf[i + 3]))(__builtin_constant_p((buf[i] << 24) + (buf[i + 1] <<
16) + (buf[i + 2] << 8) + (buf[i + 3])) ? ((__uint32_t
)((((__uint32_t)((buf[i] << 24) + (buf[i + 1] << 16
) + (buf[i + 2] << 8) + (buf[i + 3])) & 0xff000000)
>> 24) | (((__uint32_t)((buf[i] << 24) + (buf[i +
1] << 16) + (buf[i + 2] << 8) + (buf[i + 3])) &
0x00ff0000) >> 8) | (((__uint32_t)((buf[i] << 24
) + (buf[i + 1] << 16) + (buf[i + 2] << 8) + (buf
[i + 3])) & 0x0000ff00) << 8) | (((__uint32_t)((buf
[i] << 24) + (buf[i + 1] << 16) + (buf[i + 2] <<
8) + (buf[i + 3])) & 0x000000ff) << 24))) : _OSSwapInt32
((buf[i] << 24) + (buf[i + 1] << 16) + (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((void*)0)) {
1388 return;
1389 }
1390 }
1391
1392 rn->naddrs = (u_short) naddrs;
1393
1394 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
1395
1396 rn->valid = ngx_time()ngx_cached_time->sec + (r->valid ? r->valid : ttl);
1397 rn->expire = ngx_time()ngx_cached_time->sec + r->expire;
1398
1399 ngx_queue_insert_head(&r->name_expire_queue, &rn->queue)(&rn->queue)->next = (&r->name_expire_queue)
->next; (&rn->queue)->next->prev = &rn->
queue; (&rn->queue)->prev = &r->name_expire_queue
; (&r->name_expire_queue)->next = &rn->queue;
1400
1401 next = rn->waiting;
1402 rn->waiting = NULL((void*)0);
1403
1404 /* unlock name mutex */
1405
1406 while (next) {
1407 ctx = next;
1408 ctx->state = NGX_OK0;
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((void*)0);
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_OK0) {
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)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
1438
1439 rn->cnlen = (u_short) name.len;
1440 rn->u.cname = name.data;
1441
1442 rn->valid = ngx_time()ngx_cached_time->sec + (r->valid ? r->valid : ttl);
1443 rn->expire = ngx_time()ngx_cached_time->sec + r->expire;
1444
1445 ngx_queue_insert_head(&r->name_expire_queue, &rn->queue)(&rn->queue)->next = (&r->name_expire_queue)
->next; (&rn->queue)->next->prev = &rn->
queue; (&rn->queue)->prev = &r->name_expire_queue
; (&r->name_expire_queue)->next = &rn->queue;
1446
1447 ctx = rn->waiting;
1448 rn->waiting = NULL((void*)0);
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((void*)0);
1458
1459 return;
1460 }
1461
1462 ngx_log_error(r->log_level, r->log, 0,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "no A or CNAME types in DNS responses, unknown query type: %ui"
, qtype)
1463 "no A or CNAME types in DNS responses, unknown query type: %ui",if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "no A or CNAME types in DNS responses, unknown query type: %ui"
, qtype)
1464 qtype)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "no A or CNAME types in DNS responses, unknown query type: %ui"
, qtype);
1465 return;
1466
1467short_response:
1468
1469 err = "short dns response";
1470
1471invalid:
1472
1473 /* unlock name mutex */
1474
1475 ngx_log_error(r->log_level, r->log, 0, err)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, err);
1476
1477 return;
1478
1479failed:
1480
1481 /* unlock name mutex */
1482
1483 ngx_resolver_free(r, name.data);
1484
1485 return;
1486}
1487
1488
1489static void
1490ngx_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((void*)0), buf, &buf[12], &buf[n]) != NGX_OK0) {
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-1 || 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")strcmp((const char *) &buf[i], (const char *) "\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((void*)0) || rn->query == NULL((void*)0)) {
1532 ngx_log_error(r->log_level, r->log, 0,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unexpected response for %ud.%ud.%ud.%ud"
, (addr >> 24) & 0xff, (addr >> 16) & 0xff
, (addr >> 8) & 0xff, addr & 0xff)
1533 "unexpected response for %ud.%ud.%ud.%ud",if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unexpected response for %ud.%ud.%ud.%ud"
, (addr >> 24) & 0xff, (addr >> 16) & 0xff
, (addr >> 8) & 0xff, addr & 0xff)
1534 (addr >> 24) & 0xff, (addr >> 16) & 0xff,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unexpected response for %ud.%ud.%ud.%ud"
, (addr >> 24) & 0xff, (addr >> 16) & 0xff
, (addr >> 8) & 0xff, addr & 0xff)
1535 (addr >> 8) & 0xff, addr & 0xff)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "unexpected response for %ud.%ud.%ud.%ud"
, (addr >> 24) & 0xff, (addr >> 16) & 0xff
, (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,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "wrong ident %ui response for %ud.%ud.%ud.%ud, expect %ui"
, ident, (addr >> 24) & 0xff, (addr >> 16) &
0xff, (addr >> 8) & 0xff, addr & 0xff, qident)
1543 "wrong ident %ui response for %ud.%ud.%ud.%ud, expect %ui",if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "wrong ident %ui response for %ud.%ud.%ud.%ud, expect %ui"
, ident, (addr >> 24) & 0xff, (addr >> 16) &
0xff, (addr >> 8) & 0xff, addr & 0xff, qident)
1544 ident, (addr >> 24) & 0xff, (addr >> 16) & 0xff,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "wrong ident %ui response for %ud.%ud.%ud.%ud, expect %ui"
, ident, (addr >> 24) & 0xff, (addr >> 16) &
0xff, (addr >> 8) & 0xff, addr & 0xff, qident)
1545 (addr >> 8) & 0xff, addr & 0xff, qident)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "wrong ident %ui response for %ud.%ud.%ud.%ud, expect %ui"
, ident, (addr >> 24) & 0xff, (addr >> 16) &
0xff, (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((void*)0);
1556
1557 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
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_OK0) {
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)strncmp((const char *) name.data, (const char *) 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((void*)0)) {
1628 goto failed;
1629 }
1630 }
1631
1632 ngx_queue_remove(&rn->queue)(&rn->queue)->next->prev = (&rn->queue)->
prev; (&rn->queue)->prev->next = (&rn->queue
)->next;
1633
1634 rn->valid = ngx_time()ngx_cached_time->sec + (r->valid ? r->valid : ttl);
1635 rn->expire = ngx_time()ngx_cached_time->sec + r->expire;
1636
1637 ngx_queue_insert_head(&r->addr_expire_queue, &rn->queue)(&rn->queue)->next = (&r->addr_expire_queue)
->next; (&rn->queue)->next->prev = &rn->
queue; (&rn->queue)->prev = &r->addr_expire_queue
; (&r->addr_expire_queue)->next = &rn->queue;
1638
1639 next = rn->waiting;
1640 rn->waiting = NULL((void*)0);
1641
1642 /* unlock addr mutex */
1643
1644 while (next) {
1645 ctx = next;
1646 ctx->state = NGX_OK0;
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
1657invalid_in_addr_arpa:
1658
1659 ngx_log_error(r->log_level, r->log, 0,if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "invalid in-addr.arpa name in DNS response"
)
1660 "invalid in-addr.arpa name in DNS response")if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, "invalid in-addr.arpa name in DNS response"
);
1661 return;
1662
1663short_response:
1664
1665 err = "short DNS response";
1666
1667invalid:
1668
1669 /* unlock addr mutex */
1670
1671 ngx_log_error(r->log_level, r->log, 0, err)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, err);
1672
1673 return;
1674
1675failed:
1676
1677 /* unlock addr mutex */
1678
1679 return;
1680}
1681
1682
1683static ngx_resolver_node_t *
1684ngx_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((void*)0);
1721}
1722
1723
1724static ngx_resolver_node_t *
1725ngx_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((void*)0);
1752}
1753
1754
1755static void
1756ngx_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)((node)->color = 1);
1793}
1794
1795
1796static ngx_int_t
1797ngx_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((void*)0)) {
1811 return NGX_ERROR-1;
1812 }
1813
1814 rn->qlen = (u_short) len;
1815 rn->query = p;
1816
1817 query = (ngx_resolver_query_t *) p;
1818
1819 ident = ngx_randomrandom();
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-5;
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-5;
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-5;
1875 }
1876
1877 *p = (u_char) len;
1878
1879 return NGX_OK0;
1880}
1881
1882
1883/* AF_INET only */
1884
1885static ngx_int_t
1886ngx_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((void*)0)) {
1900 return NGX_ERROR-1;
1901 }
1902
1903 rn->query = p;
1904 query = (ngx_resolver_query_t *) p;
1905
1906 ident = ngx_randomrandom();
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)(void) ((__builtin_object_size (p, 0) != (size_t) -1) ? __builtin___memcpy_chk
(p, "\7in-addr\4arpa\0\0\14\0\1", 18, __builtin_object_size (
p, 0)) : __inline_memcpy_chk (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_OK0;
1936}
1937
1938
1939static ngx_int_t
1940ngx_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
1980invalid:
1981
1982 ngx_log_error(r->log_level, r->log, 0, err)if ((r->log)->log_level >= r->log_level) ngx_log_error_core
(r->log_level, r->log, 0, err);
1983
1984 return NGX_ERROR-1;
1985
1986done:
1987
1988 if (name == NULL((void*)0)) {
1989 return NGX_OK0;
1990 }
1991
1992 if (len == -1) {
1993 name->len = 0;
1994 name->data = NULL((void*)0);
1995 return NGX_OK0;
1996 }
1997
1998 dst = ngx_resolver_alloc(r, len);
1999 if (dst == NULL((void*)0)) {
2000 return NGX_ERROR-1;
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)(void) ((__builtin_object_size (dst, 0) != (size_t) -1) ? __builtin___memcpy_chk
(dst, src, n, __builtin_object_size (dst, 0)) : __inline_memcpy_chk
(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_OK0;
2029 }
2030 }
2031}
2032
2033
2034static void
2035ngx_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_TIMEDOUT60;
2042
2043 ctx->handler(ctx);
2044}
2045
2046
2047static void
2048ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn)
2049{
2050 /* lock alloc mutex */
2051
2052 if (rn->query) {
5
←
Taking false branch
→
2053 ngx_resolver_free_locked(r, rn->query);
2054 }
2055
2056 if (rn->name) {
6
←
Taking false branch
→
2057 ngx_resolver_free_locked(r, rn->name);
2058 }
2059
2060 if (rn->cnlen) {
7
←
Taking false branch
→
2061 ngx_resolver_free_locked(r, rn->u.cname);
2062 }
2063
2064 if (rn->naddrs > 1) {
8
←
Taking false branch
→
2065 ngx_resolver_free_locked(r, rn->u.addrs);
2066 }
2067
2068 ngx_resolver_free_locked(r, rn);
9
←
Calling 'ngx_resolver_free_locked'
→
11
←
Returning; memory was released
→
2069
2070 /* unlock alloc mutex */
2071}
2072
2073
2074static void *
2075ngx_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
2089static void *
2090ngx_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)(void) ((__builtin_object_size (p, 0) != (size_t) -1) ? __builtin___memset_chk
(p, 0, size, __builtin_object_size (p, 0)) : __inline_memset_chk
(p, 0, size));
2098 }
2099
2100 return p;
2101}
2102
2103
2104static void
2105ngx_resolver_free(ngx_resolver_t *r, void *p)
2106{
2107 /* lock alloc mutex */
2108
2109 ngx_freefree(p);
2110
2111 /* unlock alloc mutex */
2112}
2113
2114
2115static void
2116ngx_resolver_free_locked(ngx_resolver_t *r, void *p)
2117{
2118 ngx_freefree(p);
10
←
Within the expansion of the macro 'ngx_free':
→
a
Memory is released
2119}
2120
2121
2122static void *
2123ngx_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((void*)0)) {
2130 return dst;
2131 }
2132
2133 ngx_memcpy(dst, src, size)(void) ((__builtin_object_size (dst, 0) != (size_t) -1) ? __builtin___memcpy_chk
(dst, src, size, __builtin_object_size (dst, 0)) : __inline_memcpy_chk
(dst, src, size));
2134
2135 return dst;
2136}
2137
2138
2139static in_addr_t *
2140ngx_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((void*)0)) {
2148 return dst;
2149 }
2150
2151 j = ngx_randomrandom() % n;
2152
2153 if (j == 0) {
2154 ngx_memcpy(dst, src, n * sizeof(in_addr_t))(void) ((__builtin_object_size (dst, 0) != (size_t) -1) ? __builtin___memcpy_chk
(dst, src, n * sizeof(in_addr_t), __builtin_object_size (dst
, 0)) : __inline_memcpy_chk (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))(((u_char *) ((__builtin_object_size (dst, 0) != (size_t) -1)
? __builtin___memcpy_chk (dst, &src[j], (n - j) * sizeof
(in_addr_t), __builtin_object_size (dst, 0)) : __inline_memcpy_chk
(dst, &src[j], (n - j) * sizeof(in_addr_t)))) + ((n - j)
* sizeof(in_addr_t)));
2159 ngx_memcpy(p, src, j * sizeof(in_addr_t))(void) ((__builtin_object_size (p, 0) != (size_t) -1) ? __builtin___memcpy_chk
(p, src, j * sizeof(in_addr_t), __builtin_object_size (p, 0)
) : __inline_memcpy_chk (p, src, j * sizeof(in_addr_t)));
2160
2161 return dst;
2162}
2163
2164
2165char *
2166ngx_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_TIMEDOUT60) {
2181 return "Operation timed out";
2182 }
2183
2184 return "Unknown error";
2185}
2186
2187
2188static u_char *
2189ngx_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
2211ngx_int_t
2212ngx_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_socketsocket(uc->sockaddr->sa_family, SOCK_DGRAM2, 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,if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "socket()" " failed")
2226 ngx_socket_n " failed")if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "socket()" " failed");
2227 return NGX_ERROR-1;
2228 }
2229
2230 c = ngx_get_connection(s, &uc->log);
2231
2232 if (c == NULL((void*)0)) {
2233 if (ngx_close_socketclose(s) == -1) {
2234 ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "close() socket" "failed")
2235 ngx_close_socket_n "failed")if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "close() socket" "failed");
2236 }
2237
2238 return NGX_ERROR-1;
2239 }
2240
2241 if (ngx_nonblocking(s) == -1) {
2242 ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "ioctl(FIONBIO)" " failed"
)
2243 ngx_nonblocking_n " failed")if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "ioctl(FIONBIO)" " failed"
);
2244
2245 ngx_free_connection(c);
2246
2247 if (ngx_close_socketclose(s) == -1) {
2248 ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "close() socket" " failed"
)
2249 ngx_close_socket_n " failed")if ((&uc->log)->log_level >= 2) ngx_log_error_core
(2, &uc->log, (*__error()), "close() socket" " failed"
);
2250 }
2251
2252 return NGX_ERROR-1;
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)(OSAtomicAdd64(1, (int64_t *) 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,if ((&uc->log)->log_level >= 3) ngx_log_error_core
(3, &uc->log, (*__error()), "connect() failed")
2285 "connect() failed")if ((&uc->log)->log_level >= 3) ngx_log_error_core
(3, &uc->log, (*__error()), "connect() failed");
2286
2287 return NGX_ERROR-1;
2288 }
2289
2290 /* UDP sockets are always ready to write */
2291 wev->ready = 1;
2292
2293 if (ngx_add_eventngx_event_actions.add) {
2294
2295 event = (ngx_event_flags & NGX_USE_CLEAR_EVENT0x00000004) ?
2296 /* kqueue, epoll */ NGX_CLEAR_EVENT0x0020:
2297 /* select, poll, /dev/poll */ NGX_LEVEL_EVENT0;
2298 /* eventport event type has no meaning: oneshot only */
2299
2300 if (ngx_add_eventngx_event_actions.add(rev, NGX_READ_EVENT(-1), event) != NGX_OK0) {
2301 return NGX_ERROR-1;
2302 }
2303
2304 } else {
2305 /* rtsig */
2306
2307 if (ngx_add_connngx_event_actions.add_conn(c) == NGX_ERROR-1) {
2308 return NGX_ERROR-1;
2309 }
2310 }
2311
2312 return NGX_OK0;
2313}