Mercurial > hg > nginx-vendor-1-0

comparison src/core/ngx_resolver.c @ 350:5a1bb0129dff NGINX_0_6_19

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