nginxtra 1.8.1.12 → 1.10.1.12

data/vendor/nginx/src/{http/ngx_http_parse_time.c → core/ngx_parse_time.c}

@@ -7,13 +7,12 @@
 
 #include <ngx_config.h>
 #include <ngx_core.h>
-#include <ngx_http.h>
 
 
 static ngx_uint_t  mday[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
 time_t
-ngx_http_parse_time(u_char *value, size_t len)
+ngx_parse_http_time(u_char *value, size_t len)
 {
     u_char      *p, *end;
     ngx_int_t    month;
@@ -221,7 +220,7 @@ ngx_http_parse_time(u_char *value, size_t len)
     }
 
     if (hour > 23 || min > 59 || sec > 59) {
-         return NGX_ERROR;
+        return NGX_ERROR;
     }
 
     if (day == 29 && month == 1) {

data/vendor/nginx/src/core/ngx_parse_time.h

@@ -0,0 +1,22 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#ifndef _NGX_PARSE_TIME_H_INCLUDED_
+#define _NGX_PARSE_TIME_H_INCLUDED_
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+time_t ngx_parse_http_time(u_char *value, size_t len);
+
+/* compatibility */
+#define ngx_http_parse_time(value, len)  ngx_parse_http_time(value, len)
+
+
+#endif /* _NGX_PARSE_TIME_H_INCLUDED_ */

data/vendor/nginx/src/core/ngx_proxy_protocol.c

@@ -10,7 +10,7 @@
 
 
 u_char *
-ngx_proxy_protocol_parse(ngx_connection_t *c, u_char *buf, u_char *last)
+ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf, u_char *last)
 {
     size_t  len;
     u_char  ch, *p, *addr;
@@ -89,3 +89,52 @@ invalid:
 
     return NULL;
 }
+
+
+u_char *
+ngx_proxy_protocol_write(ngx_connection_t *c, u_char *buf, u_char *last)
+{
+    ngx_uint_t  port, lport;
+
+    if (last - buf < NGX_PROXY_PROTOCOL_MAX_HEADER) {
+        return NULL;
+    }
+
+    if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
+        return NULL;
+    }
+
+    switch (c->sockaddr->sa_family) {
+
+    case AF_INET:
+        buf = ngx_cpymem(buf, "PROXY TCP4 ", sizeof("PROXY TCP4 ") - 1);
+
+        port = ntohs(((struct sockaddr_in *) c->sockaddr)->sin_port);
+        lport = ntohs(((struct sockaddr_in *) c->local_sockaddr)->sin_port);
+
+        break;
+
+#if (NGX_HAVE_INET6)
+    case AF_INET6:
+        buf = ngx_cpymem(buf, "PROXY TCP6 ", sizeof("PROXY TCP6 ") - 1);
+
+        port = ntohs(((struct sockaddr_in6 *) c->sockaddr)->sin6_port);
+        lport = ntohs(((struct sockaddr_in6 *) c->local_sockaddr)->sin6_port);
+
+        break;
+#endif
+
+    default:
+        return ngx_cpymem(buf, "PROXY UNKNOWN" CRLF,
+                          sizeof("PROXY UNKNOWN" CRLF) - 1);
+    }
+
+    buf += ngx_sock_ntop(c->sockaddr, c->socklen, buf, last - buf, 0);
+
+    *buf++ = ' ';
+
+    buf += ngx_sock_ntop(c->local_sockaddr, c->local_socklen, buf, last - buf,
+                         0);
+
+    return ngx_slprintf(buf, last, " %ui %ui" CRLF, port, lport);
+}

data/vendor/nginx/src/core/ngx_proxy_protocol.h

@@ -16,7 +16,9 @@
 #define NGX_PROXY_PROTOCOL_MAX_HEADER  107
 
 
-u_char *ngx_proxy_protocol_parse(ngx_connection_t *c, u_char *buf,
+u_char *ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf,
+    u_char *last);
+u_char *ngx_proxy_protocol_write(ngx_connection_t *c, u_char *buf,
     u_char *last);
 
 

data/vendor/nginx/src/core/ngx_regex.c

@@ -32,7 +32,7 @@ static ngx_conf_post_t  ngx_regex_pcre_jit_post = { ngx_regex_pcre_jit };
 static ngx_command_t  ngx_regex_commands[] = {
 
     { ngx_string("pcre_jit"),
-      NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
+      NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
       ngx_conf_set_flag_slot,
       0,
       offsetof(ngx_regex_conf_t, pcre_jit),
@@ -80,17 +80,6 @@ ngx_regex_init(void)
 static ngx_inline void
 ngx_regex_malloc_init(ngx_pool_t *pool)
 {
-#if (NGX_OLD_THREADS)
-    ngx_core_tls_t  *tls;
-
-    if (ngx_threaded) {
-        tls = ngx_thread_get_tls(ngx_core_tls_key);
-        tls->pool = pool;
-        return;
-    }
-
-#endif
-
     ngx_pcre_pool = pool;
 }
 
@@ -98,17 +87,6 @@ ngx_regex_malloc_init(ngx_pool_t *pool)
 static ngx_inline void
 ngx_regex_malloc_done(void)
 {
-#if (NGX_OLD_THREADS)
-    ngx_core_tls_t  *tls;
-
-    if (ngx_threaded) {
-        tls = ngx_thread_get_tls(ngx_core_tls_key);
-        tls->pool = NULL;
-        return;
-    }
-
-#endif
-
     ngx_pcre_pool = NULL;
 }
 
@@ -253,23 +231,8 @@ static void * ngx_libc_cdecl
 ngx_regex_malloc(size_t size)
 {
     ngx_pool_t      *pool;
-#if (NGX_OLD_THREADS)
-    ngx_core_tls_t  *tls;
-
-    if (ngx_threaded) {
-        tls = ngx_thread_get_tls(ngx_core_tls_key);
-        pool = tls->pool;
-
-    } else {
-        pool = ngx_pcre_pool;
-    }
-
-#else
-
     pool = ngx_pcre_pool;
 
-#endif
-
     if (pool) {
         return ngx_palloc(pool, size);
     }

data/vendor/nginx/src/core/ngx_resolver.c

@@ -12,6 +12,9 @@
 
 #define NGX_RESOLVER_UDP_SIZE   4096
 
+#define NGX_RESOLVER_TCP_RSIZE  (2 + 65535)
+#define NGX_RESOLVER_TCP_WSIZE  8192
+
 
 typedef struct {
     u_char  ident_hi;
@@ -53,7 +56,8 @@ typedef struct {
         ((u_char *) (n) - offsetof(ngx_resolver_node_t, node))
 
 
-ngx_int_t ngx_udp_connect(ngx_udp_connection_t *uc);
+ngx_int_t ngx_udp_connect(ngx_resolver_connection_t *rec);
+ngx_int_t ngx_tcp_connect(ngx_resolver_connection_t *rec);
 
 
 static void ngx_resolver_cleanup(void *data);
@@ -64,23 +68,37 @@ static void ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree,
     ngx_queue_t *queue);
 static ngx_int_t ngx_resolver_send_query(ngx_resolver_t *r,
     ngx_resolver_node_t *rn);
+static ngx_int_t ngx_resolver_send_udp_query(ngx_resolver_t *r,
+    ngx_resolver_connection_t *rec, u_char *query, u_short qlen);
+static ngx_int_t ngx_resolver_send_tcp_query(ngx_resolver_t *r,
+    ngx_resolver_connection_t *rec, u_char *query, u_short qlen);
 static ngx_int_t ngx_resolver_create_name_query(ngx_resolver_t *r,
     ngx_resolver_node_t *rn, ngx_str_t *name);
+static ngx_int_t ngx_resolver_create_srv_query(ngx_resolver_t *r,
+    ngx_resolver_node_t *rn, ngx_str_t *name);
 static ngx_int_t ngx_resolver_create_addr_query(ngx_resolver_t *r,
-    ngx_resolver_node_t *rn, ngx_addr_t *addr);
+    ngx_resolver_node_t *rn, ngx_resolver_addr_t *addr);
 static void ngx_resolver_resend_handler(ngx_event_t *ev);
 static time_t ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree,
     ngx_queue_t *queue);
-static void ngx_resolver_read_response(ngx_event_t *rev);
+static ngx_uint_t ngx_resolver_resend_empty(ngx_resolver_t *r);
+static void ngx_resolver_udp_read(ngx_event_t *rev);
+static void ngx_resolver_tcp_write(ngx_event_t *wev);
+static void ngx_resolver_tcp_read(ngx_event_t *rev);
 static void ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf,
-    size_t n);
+    size_t n, ngx_uint_t tcp);
 static void ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
     ngx_uint_t ident, ngx_uint_t code, ngx_uint_t qtype,
-    ngx_uint_t nan, ngx_uint_t ans);
+    ngx_uint_t nan, ngx_uint_t trunc, ngx_uint_t ans);
+static void ngx_resolver_process_srv(ngx_resolver_t *r, u_char *buf, size_t n,
+    ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan,
+    ngx_uint_t trunc, ngx_uint_t ans);
 static void ngx_resolver_process_ptr(ngx_resolver_t *r, u_char *buf, size_t n,
     ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan);
 static ngx_resolver_node_t *ngx_resolver_lookup_name(ngx_resolver_t *r,
     ngx_str_t *name, uint32_t hash);
+static ngx_resolver_node_t *ngx_resolver_lookup_srv(ngx_resolver_t *r,
+    ngx_str_t *name, uint32_t hash);
 static ngx_resolver_node_t *ngx_resolver_lookup_addr(ngx_resolver_t *r,
     in_addr_t addr);
 static void ngx_resolver_rbtree_insert_value(ngx_rbtree_node_t *temp,
@@ -94,9 +112,14 @@ static void *ngx_resolver_calloc(ngx_resolver_t *r, size_t size);
 static void ngx_resolver_free(ngx_resolver_t *r, void *p);
 static void ngx_resolver_free_locked(ngx_resolver_t *r, void *p);
 static void *ngx_resolver_dup(ngx_resolver_t *r, void *src, size_t size);
-static ngx_addr_t *ngx_resolver_export(ngx_resolver_t *r,
+static ngx_resolver_addr_t *ngx_resolver_export(ngx_resolver_t *r,
     ngx_resolver_node_t *rn, ngx_uint_t rotate);
+static void ngx_resolver_report_srv(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx);
 static u_char *ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len);
+static void ngx_resolver_resolve_srv_names(ngx_resolver_ctx_t *ctx,
+    ngx_resolver_node_t *rn);
+static void ngx_resolver_srv_names_handler(ngx_resolver_ctx_t *ctx);
+static ngx_int_t ngx_resolver_cmp_srvs(const void *one, const void *two);
 
 #if (NGX_HAVE_INET6)
 static void ngx_resolver_rbtree_insert_addr6_value(ngx_rbtree_node_t *temp,
@@ -109,12 +132,12 @@ static ngx_resolver_node_t *ngx_resolver_lookup_addr6(ngx_resolver_t *r,
 ngx_resolver_t *
 ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
 {
-    ngx_str_t              s;
-    ngx_url_t              u;
-    ngx_uint_t             i, j;
-    ngx_resolver_t        *r;
-    ngx_pool_cleanup_t    *cln;
-    ngx_udp_connection_t  *uc;
+    ngx_str_t                   s;
+    ngx_url_t                   u;
+    ngx_uint_t                  i, j;
+    ngx_resolver_t             *r;
+    ngx_pool_cleanup_t         *cln;
+    ngx_resolver_connection_t  *rec;
 
     cln = ngx_pool_cleanup_add(cf->pool, 0);
     if (cln == NULL) {
@@ -138,13 +161,18 @@ ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
     ngx_rbtree_init(&r->name_rbtree, &r->name_sentinel,
                     ngx_resolver_rbtree_insert_value);
 
+    ngx_rbtree_init(&r->srv_rbtree, &r->srv_sentinel,
+                    ngx_resolver_rbtree_insert_value);
+
     ngx_rbtree_init(&r->addr_rbtree, &r->addr_sentinel,
                     ngx_rbtree_insert_value);
 
     ngx_queue_init(&r->name_resend_queue);
+    ngx_queue_init(&r->srv_resend_queue);
     ngx_queue_init(&r->addr_resend_queue);
 
     ngx_queue_init(&r->name_expire_queue);
+    ngx_queue_init(&r->srv_expire_queue);
     ngx_queue_init(&r->addr_expire_queue);
 
 #if (NGX_HAVE_INET6)
@@ -164,6 +192,7 @@ ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
     r->ident = -1;
 
     r->resend_timeout = 5;
+    r->tcp_timeout = 5;
     r->expire = 30;
     r->valid = 0;
 
@@ -171,8 +200,8 @@ ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
     r->log_level = NGX_LOG_ERR;
 
     if (n) {
-        if (ngx_array_init(&r->udp_connections, cf->pool, n,
-                           sizeof(ngx_udp_connection_t))
+        if (ngx_array_init(&r->connections, cf->pool, n,
+                           sizeof(ngx_resolver_connection_t))
             != NGX_OK)
         {
             return NULL;
@@ -229,17 +258,18 @@ ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
             return NULL;
         }
 
-        uc = ngx_array_push_n(&r->udp_connections, u.naddrs);
-        if (uc == NULL) {
+        rec = ngx_array_push_n(&r->connections, u.naddrs);
+        if (rec == NULL) {
             return NULL;
         }
 
-        ngx_memzero(uc, u.naddrs * sizeof(ngx_udp_connection_t));
+        ngx_memzero(rec, u.naddrs * sizeof(ngx_resolver_connection_t));
 
         for (j = 0; j < u.naddrs; j++) {
-            uc[j].sockaddr = u.addrs[j].sockaddr;
-            uc[j].socklen = u.addrs[j].socklen;
-            uc[j].server = u.addrs[j].name;
+            rec[j].sockaddr = u.addrs[j].sockaddr;
+            rec[j].socklen = u.addrs[j].socklen;
+            rec[j].server = u.addrs[j].name;
+            rec[j].resolver = r;
         }
     }
 
@@ -252,8 +282,8 @@ ngx_resolver_cleanup(void *data)
 {
     ngx_resolver_t  *r = data;
 
-    ngx_uint_t             i;
-    ngx_udp_connection_t  *uc;
+    ngx_uint_t                  i;
+    ngx_resolver_connection_t  *rec;
 
     if (r) {
         ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
@@ -261,6 +291,8 @@ ngx_resolver_cleanup(void *data)
 
         ngx_resolver_cleanup_tree(r, &r->name_rbtree);
 
+        ngx_resolver_cleanup_tree(r, &r->srv_rbtree);
+
         ngx_resolver_cleanup_tree(r, &r->addr_rbtree);
 
 #if (NGX_HAVE_INET6)
@@ -272,11 +304,25 @@ ngx_resolver_cleanup(void *data)
         }
 
 
-        uc = r->udp_connections.elts;
+        rec = r->connections.elts;
+
+        for (i = 0; i < r->connections.nelts; i++) {
+            if (rec[i].udp) {
+                ngx_close_connection(rec[i].udp);
+            }
+
+            if (rec[i].tcp) {
+                ngx_close_connection(rec[i].tcp);
+            }
+
+            if (rec[i].read_buf) {
+                ngx_resolver_free(r, rec[i].read_buf->start);
+                ngx_resolver_free(r, rec[i].read_buf);
+            }
 
-        for (i = 0; i < r->udp_connections.nelts; i++) {
-            if (uc[i].connection) {
-                ngx_close_connection(uc[i].connection);
+            if (rec[i].write_buf) {
+                ngx_resolver_free(r, rec[i].write_buf->start);
+                ngx_resolver_free(r, rec[i].write_buf);
             }
         }
 
@@ -339,7 +385,7 @@ ngx_resolve_start(ngx_resolver_t *r, ngx_resolver_ctx_t *temp)
         }
     }
 
-    if (r->udp_connections.nelts == 0) {
+    if (r->connections.nelts == 0) {
         return NGX_NO_RESOLVER;
     }
 
@@ -356,7 +402,9 @@ ngx_resolve_start(ngx_resolver_t *r, ngx_resolver_ctx_t *temp)
 ngx_int_t
 ngx_resolve_name(ngx_resolver_ctx_t *ctx)
 {
+    size_t           slen;
     ngx_int_t        rc;
+    ngx_str_t        name;
     ngx_resolver_t  *r;
 
     r = ctx->resolver;
@@ -373,9 +421,41 @@ ngx_resolve_name(ngx_resolver_ctx_t *ctx)
         return NGX_OK;
     }
 
-    /* lock name mutex */
+    if (ctx->service.len) {
+        slen = ctx->service.len;
+
+        if (ngx_strlchr(ctx->service.data,
+                        ctx->service.data + ctx->service.len, '.')
+            == NULL)
+        {
+            slen += sizeof("_._tcp") - 1;
+        }
+
+        name.len = slen + 1 + ctx->name.len;
+
+        name.data = ngx_resolver_alloc(r, name.len);
+        if (name.data == NULL) {
+            return NGX_ERROR;
+        }
+
+        if (slen == ctx->service.len) {
+            ngx_sprintf(name.data, "%V.%V", &ctx->service, &ctx->name);
+
+        } else {
+            ngx_sprintf(name.data, "_%V._tcp.%V", &ctx->service, &ctx->name);
+        }
+
+        /* lock name mutex */
+
+        rc = ngx_resolve_name_locked(r, ctx, &name);
+
+        ngx_resolver_free(r, name.data);
+
+    } else {
+        /* lock name mutex */
 
-    rc = ngx_resolve_name_locked(r, ctx, &ctx->name);
+        rc = ngx_resolve_name_locked(r, ctx, &ctx->name);
+    }
 
     if (rc == NGX_OK) {
         return NGX_OK;
@@ -402,6 +482,7 @@ ngx_resolve_name(ngx_resolver_ctx_t *ctx)
 void
 ngx_resolve_name_done(ngx_resolver_ctx_t *ctx)
 {
+    ngx_uint_t            i;
     ngx_resolver_t       *r;
     ngx_resolver_ctx_t   *w, **p;
     ngx_resolver_node_t  *rn;
@@ -421,6 +502,23 @@ ngx_resolve_name_done(ngx_resolver_ctx_t *ctx)
 
     /* lock name mutex */
 
+    if (ctx->nsrvs) {
+        for (i = 0; i < ctx->nsrvs; i++) {
+            if (ctx->srvs[i].ctx) {
+                ngx_resolve_name_done(ctx->srvs[i].ctx);
+            }
+
+            if (ctx->srvs[i].addrs) {
+                ngx_resolver_free(r, ctx->srvs[i].addrs->sockaddr);
+                ngx_resolver_free(r, ctx->srvs[i].addrs);
+            }
+
+            ngx_resolver_free(r, ctx->srvs[i].name.data);
+        }
+
+        ngx_resolver_free(r, ctx->srvs);
+    }
+
     if (ctx->state == NGX_AGAIN || ctx->state == NGX_RESOLVE_TIMEDOUT) {
 
         rn = ctx->node;
@@ -439,15 +537,20 @@ ngx_resolve_name_done(ngx_resolver_ctx_t *ctx)
                 p = &w->next;
                 w = w->next;
             }
-        }
 
-        ngx_log_error(NGX_LOG_ALERT, r->log, 0,
-                      "could not cancel %V resolving", &ctx->name);
+            ngx_log_error(NGX_LOG_ALERT, r->log, 0,
+                          "could not cancel %V resolving", &ctx->name);
+        }
     }
 
 done:
 
-    ngx_resolver_expire(r, &r->name_rbtree, &r->name_expire_queue);
+    if (ctx->service.len) {
+        ngx_resolver_expire(r, &r->srv_rbtree, &r->srv_expire_queue);
+
+    } else {
+        ngx_resolver_expire(r, &r->name_rbtree, &r->name_expire_queue);
+    }
 
     /* unlock name mutex */
 
@@ -460,6 +563,10 @@ done:
     ngx_resolver_free_locked(r, ctx);
 
     /* unlock alloc mutex */
+
+    if (r->event->timer_set && ngx_resolver_resend_empty(r)) {
+        ngx_del_timer(r->event);
+    }
 }
 
 
@@ -470,16 +577,31 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
     uint32_t              hash;
     ngx_int_t             rc;
     ngx_str_t             cname;
-    ngx_uint_t            naddrs;
-    ngx_addr_t           *addrs;
+    ngx_uint_t            i, naddrs;
+    ngx_queue_t          *resend_queue, *expire_queue;
+    ngx_rbtree_t         *tree;
     ngx_resolver_ctx_t   *next, *last;
+    ngx_resolver_addr_t  *addrs;
     ngx_resolver_node_t  *rn;
 
     ngx_strlow(name->data, name->data, name->len);
 
     hash = ngx_crc32_short(name->data, name->len);
 
-    rn = ngx_resolver_lookup_name(r, name, hash);
+    if (ctx->service.len) {
+        rn = ngx_resolver_lookup_srv(r, name, hash);
+
+        tree = &r->srv_rbtree;
+        resend_queue = &r->srv_resend_queue;
+        expire_queue = &r->srv_expire_queue;
+
+    } else {
+        rn = ngx_resolver_lookup_name(r, name, hash);
+
+        tree = &r->name_rbtree;
+        resend_queue = &r->name_resend_queue;
+        expire_queue = &r->name_expire_queue;
+    }
 
     if (rn) {
 
@@ -494,7 +616,7 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
 
             rn->expire = ngx_time() + r->expire;
 
-            ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);
+            ngx_queue_insert_head(expire_queue, &rn->queue);
 
             naddrs = (rn->naddrs == (u_short) -1) ? 0 : rn->naddrs;
 #if (NGX_HAVE_INET6)
@@ -520,6 +642,7 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
 
                 do {
                     ctx->state = NGX_OK;
+                    ctx->valid = rn->valid;
                     ctx->naddrs = naddrs;
 
                     if (addrs == NULL) {
@@ -549,6 +672,23 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
                 return NGX_OK;
             }
 
+            if (rn->nsrvs) {
+                last->next = rn->waiting;
+                rn->waiting = NULL;
+
+                /* unlock name mutex */
+
+                do {
+                    next = ctx->next;
+
+                    ngx_resolver_resolve_srv_names(ctx, rn);
+
+                    ctx = next;
+                } while (ctx);
+
+                return NGX_OK;
+            }
+
             /* NGX_RESOLVE_CNAME */
 
             if (ctx->recursion++ < NGX_RESOLVER_MAX_RECURSION) {
@@ -566,6 +706,7 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
 
             do {
                 ctx->state = NGX_RESOLVE_NXDOMAIN;
+                ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
                 next = ctx->next;
 
                 ctx->handler(ctx);
@@ -578,7 +719,7 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
 
         if (rn->waiting) {
 
-            if (ctx->event == NULL) {
+            if (ctx->event == NULL && ctx->timeout) {
                 ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
                 if (ctx->event == NULL) {
                     return NGX_ERROR;
@@ -630,6 +771,16 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
         }
 #endif
 
+        if (rn->nsrvs) {
+            for (i = 0; i < rn->nsrvs; i++) {
+                if (rn->u.srvs[i].name.data) {
+                    ngx_resolver_free_locked(r, rn->u.srvs[i].name.data);
+                }
+            }
+
+            ngx_resolver_free_locked(r, rn->u.srvs);
+        }
+
         /* unlock alloc mutex */
 
     } else {
@@ -652,17 +803,22 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
         rn->query6 = NULL;
 #endif
 
-        ngx_rbtree_insert(&r->name_rbtree, &rn->node);
+        ngx_rbtree_insert(tree, &rn->node);
     }
 
-    rc = ngx_resolver_create_name_query(r, rn, name);
+    if (ctx->service.len) {
+        rc = ngx_resolver_create_srv_query(r, rn, name);
+
+    } else {
+        rc = ngx_resolver_create_name_query(r, rn, name);
+    }
 
     if (rc == NGX_ERROR) {
         goto failed;
     }
 
     if (rc == NGX_DECLINED) {
-        ngx_rbtree_delete(&r->name_rbtree, &rn->node);
+        ngx_rbtree_delete(tree, &rn->node);
 
         ngx_resolver_free(r, rn->query);
         ngx_resolver_free(r, rn->name);
@@ -680,16 +836,24 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
         return NGX_OK;
     }
 
+    rn->last_connection = r->last_connection++;
+    if (r->last_connection == r->connections.nelts) {
+        r->last_connection = 0;
+    }
+
     rn->naddrs = (u_short) -1;
+    rn->tcp = 0;
 #if (NGX_HAVE_INET6)
     rn->naddrs6 = r->ipv6 ? (u_short) -1 : 0;
+    rn->tcp6 = 0;
 #endif
+    rn->nsrvs = 0;
 
     if (ngx_resolver_send_query(r, rn) != NGX_OK) {
         goto failed;
     }
 
-    if (ctx->event == NULL) {
+    if (ctx->event == NULL && ctx->timeout) {
         ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
         if (ctx->event == NULL) {
             goto failed;
@@ -703,13 +867,13 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
         ngx_add_timer(ctx->event, ctx->timeout);
     }
 
-    if (ngx_queue_empty(&r->name_resend_queue)) {
+    if (ngx_queue_empty(resend_queue)) {
         ngx_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
     }
 
     rn->expire = ngx_time() + r->resend_timeout;
 
-    ngx_queue_insert_head(&r->name_resend_queue, &rn->queue);
+    ngx_queue_insert_head(resend_queue, &rn->queue);
 
     rn->code = 0;
     rn->cnlen = 0;
@@ -728,7 +892,7 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
 
 failed:
 
-    ngx_rbtree_delete(&r->name_rbtree, &rn->node);
+    ngx_rbtree_delete(tree, &rn->node);
 
     if (rn->query) {
         ngx_resolver_free(r, rn->query);
@@ -821,6 +985,7 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx)
             /* unlock addr mutex */
 
             ctx->state = NGX_OK;
+            ctx->valid = rn->valid;
 
             ctx->handler(ctx);
 
@@ -831,17 +996,19 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx)
 
         if (rn->waiting) {
 
-            ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
-            if (ctx->event == NULL) {
-                return NGX_ERROR;
-            }
+            if (ctx->event == NULL && ctx->timeout) {
+                ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
+                if (ctx->event == NULL) {
+                    return NGX_ERROR;
+                }
 
-            ctx->event->handler = ngx_resolver_timeout_handler;
-            ctx->event->data = ctx;
-            ctx->event->log = r->log;
-            ctx->ident = -1;
+                ctx->event->handler = ngx_resolver_timeout_handler;
+                ctx->event->data = ctx;
+                ctx->event->log = r->log;
+                ctx->ident = -1;
 
-            ngx_add_timer(ctx->event, ctx->timeout);
+                ngx_add_timer(ctx->event, ctx->timeout);
+            }
 
             ctx->next = rn->waiting;
             rn->waiting = ctx;
@@ -892,26 +1059,36 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx)
         goto failed;
     }
 
+    rn->last_connection = r->last_connection++;
+    if (r->last_connection == r->connections.nelts) {
+        r->last_connection = 0;
+    }
+
     rn->naddrs = (u_short) -1;
+    rn->tcp = 0;
 #if (NGX_HAVE_INET6)
     rn->naddrs6 = (u_short) -1;
+    rn->tcp6 = 0;
 #endif
+    rn->nsrvs = 0;
 
     if (ngx_resolver_send_query(r, rn) != NGX_OK) {
         goto failed;
     }
 
-    ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
-    if (ctx->event == NULL) {
-        goto failed;
-    }
+    if (ctx->event == NULL && ctx->timeout) {
+        ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
+        if (ctx->event == NULL) {
+            goto failed;
+        }
 
-    ctx->event->handler = ngx_resolver_timeout_handler;
-    ctx->event->data = ctx;
-    ctx->event->log = r->log;
-    ctx->ident = -1;
+        ctx->event->handler = ngx_resolver_timeout_handler;
+        ctx->event->data = ctx;
+        ctx->event->log = r->log;
+        ctx->ident = -1;
 
-    ngx_add_timer(ctx->event, ctx->timeout);
+        ngx_add_timer(ctx->event, ctx->timeout);
+    }
 
     if (ngx_queue_empty(resend_queue)) {
         ngx_add_timer(r->event, (ngx_msec_t) (r->resend_timeout * 1000));
@@ -1042,6 +1219,10 @@ done:
     ngx_resolver_free_locked(r, ctx);
 
     /* unlock alloc mutex */
+
+    if (r->event->timer_set && ngx_resolver_resend_empty(r)) {
+        ngx_del_timer(r->event);
+    }
 }
 
 
@@ -1085,59 +1266,158 @@ ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree, ngx_queue_t *queue)
 static ngx_int_t
 ngx_resolver_send_query(ngx_resolver_t *r, ngx_resolver_node_t *rn)
 {
-    ssize_t                n;
-    ngx_udp_connection_t  *uc;
+    ngx_int_t                   rc;
+    ngx_resolver_connection_t  *rec;
 
-    uc = r->udp_connections.elts;
+    rec = r->connections.elts;
+    rec = &rec[rn->last_connection];
 
-    uc = &uc[r->last_connection++];
-    if (r->last_connection == r->udp_connections.nelts) {
-        r->last_connection = 0;
+    if (rec->log.handler == NULL) {
+        rec->log = *r->log;
+        rec->log.handler = ngx_resolver_log_error;
+        rec->log.data = rec;
+        rec->log.action = "resolving";
     }
 
-    if (uc->connection == NULL) {
-
-        uc->log = *r->log;
-        uc->log.handler = ngx_resolver_log_error;
-        uc->log.data = uc;
-        uc->log.action = "resolving";
+    if (rn->naddrs == (u_short) -1) {
+        rc = rn->tcp ? ngx_resolver_send_tcp_query(r, rec, rn->query, rn->qlen)
+                     : ngx_resolver_send_udp_query(r, rec, rn->query, rn->qlen);
 
-        if (ngx_udp_connect(uc) != NGX_OK) {
-            return NGX_ERROR;
+        if (rc != NGX_OK) {
+            return rc;
         }
-
-        uc->connection->data = r;
-        uc->connection->read->handler = ngx_resolver_read_response;
-        uc->connection->read->resolver = 1;
     }
 
-    if (rn->naddrs == (u_short) -1) {
-        n = ngx_send(uc->connection, rn->query, rn->qlen);
+#if (NGX_HAVE_INET6)
 
-        if (n == -1) {
-            return NGX_ERROR;
+    if (rn->query6 && rn->naddrs6 == (u_short) -1) {
+        rc = rn->tcp6
+                    ? ngx_resolver_send_tcp_query(r, rec, rn->query6, rn->qlen)
+                    : ngx_resolver_send_udp_query(r, rec, rn->query6, rn->qlen);
+
+        if (rc != NGX_OK) {
+            return rc;
         }
+    }
+
+#endif
+
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_resolver_send_udp_query(ngx_resolver_t *r, ngx_resolver_connection_t  *rec,
+    u_char *query, u_short qlen)
+{
+    ssize_t  n;
 
-        if ((size_t) n != (size_t) rn->qlen) {
-            ngx_log_error(NGX_LOG_CRIT, &uc->log, 0, "send() incomplete");
+    if (rec->udp == NULL) {
+        if (ngx_udp_connect(rec) != NGX_OK) {
             return NGX_ERROR;
         }
+
+        rec->udp->data = rec;
+        rec->udp->read->handler = ngx_resolver_udp_read;
+        rec->udp->read->resolver = 1;
     }
 
-#if (NGX_HAVE_INET6)
-    if (rn->query6 && rn->naddrs6 == (u_short) -1) {
-        n = ngx_send(uc->connection, rn->query6, rn->qlen);
+    n = ngx_send(rec->udp, query, qlen);
 
-        if (n == -1) {
-            return NGX_ERROR;
+    if (n == -1) {
+        return NGX_ERROR;
+    }
+
+    if ((size_t) n != (size_t) qlen) {
+        ngx_log_error(NGX_LOG_CRIT, &rec->log, 0, "send() incomplete");
+        return NGX_ERROR;
+    }
+
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_resolver_send_tcp_query(ngx_resolver_t *r, ngx_resolver_connection_t *rec,
+    u_char *query, u_short qlen)
+{
+    ngx_buf_t  *b;
+    ngx_int_t   rc;
+
+    rc = NGX_OK;
+
+    if (rec->tcp == NULL) {
+        b = rec->read_buf;
+
+        if (b == NULL) {
+            b = ngx_resolver_calloc(r, sizeof(ngx_buf_t));
+            if (b == NULL) {
+                return NGX_ERROR;
+            }
+
+            b->start = ngx_resolver_alloc(r, NGX_RESOLVER_TCP_RSIZE);
+            if (b->start == NULL) {
+                ngx_resolver_free(r, b);
+                return NGX_ERROR;
+            }
+
+            b->end = b->start + NGX_RESOLVER_TCP_RSIZE;
+
+            rec->read_buf = b;
+        }
+
+        b->pos = b->start;
+        b->last = b->start;
+
+        b = rec->write_buf;
+
+        if (b == NULL) {
+            b = ngx_resolver_calloc(r, sizeof(ngx_buf_t));
+            if (b == NULL) {
+                return NGX_ERROR;
+            }
+
+            b->start = ngx_resolver_alloc(r, NGX_RESOLVER_TCP_WSIZE);
+            if (b->start == NULL) {
+                ngx_resolver_free(r, b);
+                return NGX_ERROR;
+            }
+
+            b->end = b->start + NGX_RESOLVER_TCP_WSIZE;
+
+            rec->write_buf = b;
         }
 
-        if ((size_t) n != (size_t) rn->qlen) {
-            ngx_log_error(NGX_LOG_CRIT, &uc->log, 0, "send() incomplete");
+        b->pos = b->start;
+        b->last = b->start;
+
+        rc = ngx_tcp_connect(rec);
+        if (rc == NGX_ERROR) {
             return NGX_ERROR;
         }
+
+        rec->tcp->data = rec;
+        rec->tcp->write->handler = ngx_resolver_tcp_write;
+        rec->tcp->read->handler = ngx_resolver_tcp_read;
+        rec->tcp->read->resolver = 1;
+
+        ngx_add_timer(rec->tcp->write, (ngx_msec_t) (r->tcp_timeout * 1000));
+    }
+
+    b = rec->write_buf;
+
+    if (b->end - b->last <  2 + qlen) {
+        ngx_log_error(NGX_LOG_CRIT, &rec->log, 0, "buffer overflow");
+        return NGX_ERROR;
+    }
+
+    *b->last++ = (u_char) (qlen >> 8);
+    *b->last++ = (u_char) qlen;
+    b->last = ngx_cpymem(b->last, query, qlen);
+
+    if (rc == NGX_OK) {
+        ngx_resolver_tcp_write(rec->tcp->write);
     }
-#endif
 
     return NGX_OK;
 }
@@ -1146,7 +1426,7 @@ ngx_resolver_send_query(ngx_resolver_t *r, ngx_resolver_node_t *rn)
 static void
 ngx_resolver_resend_handler(ngx_event_t *ev)
 {
-    time_t           timer, atimer, ntimer;
+    time_t           timer, atimer, stimer, ntimer;
 #if (NGX_HAVE_INET6)
     time_t           a6timer;
 #endif
@@ -1161,6 +1441,8 @@ ngx_resolver_resend_handler(ngx_event_t *ev)
 
     ntimer = ngx_resolver_resend(r, &r->name_rbtree, &r->name_resend_queue);
 
+    stimer = ngx_resolver_resend(r, &r->srv_rbtree, &r->srv_resend_queue);
+
     /* unlock name mutex */
 
     /* lock addr mutex */
@@ -1188,6 +1470,13 @@ ngx_resolver_resend_handler(ngx_event_t *ev)
         timer = ngx_min(timer, atimer);
     }
 
+    if (timer == 0) {
+        timer = stimer;
+
+    } else if (stimer) {
+        timer = ngx_min(timer, stimer);
+    }
+
 #if (NGX_HAVE_INET6)
 
     if (timer == 0) {
@@ -1235,6 +1524,10 @@ ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree, ngx_queue_t *queue)
 
         if (rn->waiting) {
 
+            if (++rn->last_connection == r->connections.nelts) {
+                rn->last_connection = 0;
+            }
+
             (void) ngx_resolver_send_query(r, rn);
 
             rn->expire = now + r->resend_timeout;
@@ -1251,14 +1544,27 @@ ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree, ngx_queue_t *queue)
 }
 
 
+static ngx_uint_t
+ngx_resolver_resend_empty(ngx_resolver_t *r)
+{
+    return ngx_queue_empty(&r->name_resend_queue)
+#if (NGX_HAVE_INET6)
+           && ngx_queue_empty(&r->addr6_resend_queue)
+#endif
+           && ngx_queue_empty(&r->addr_resend_queue);
+}
+
+
 static void
-ngx_resolver_read_response(ngx_event_t *rev)
+ngx_resolver_udp_read(ngx_event_t *rev)
 {
-    ssize_t            n;
-    ngx_connection_t  *c;
-    u_char             buf[NGX_RESOLVER_UDP_SIZE];
+    ssize_t                     n;
+    ngx_connection_t           *c;
+    ngx_resolver_connection_t  *rec;
+    u_char                      buf[NGX_RESOLVER_UDP_SIZE];
 
     c = rev->data;
+    rec = c->data;
 
     do {
         n = ngx_udp_recv(c, buf, NGX_RESOLVER_UDP_SIZE);
@@ -1267,73 +1573,202 @@ ngx_resolver_read_response(ngx_event_t *rev)
             return;
         }
 
-        ngx_resolver_process_response(c->data, buf, n);
+        ngx_resolver_process_response(rec->resolver, buf, n, 0);
 
     } while (rev->ready);
 }
 
 
 static void
-ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n)
+ngx_resolver_tcp_write(ngx_event_t *wev)
 {
-    char                 *err;
-    ngx_uint_t            i, times, ident, qident, flags, code, nqs, nan,
-                          qtype, qclass;
-#if (NGX_HAVE_INET6)
-    ngx_uint_t            qident6;
-#endif
-    ngx_queue_t          *q;
-    ngx_resolver_qs_t    *qs;
-    ngx_resolver_hdr_t   *response;
-    ngx_resolver_node_t  *rn;
-
-    if (n < sizeof(ngx_resolver_hdr_t)) {
-        goto short_response;
+    off_t                       sent;
+    ssize_t                     n;
+    ngx_buf_t                  *b;
+    ngx_resolver_t             *r;
+    ngx_connection_t           *c;
+    ngx_resolver_connection_t  *rec;
+
+    c = wev->data;
+    rec = c->data;
+    b = rec->write_buf;
+    r = rec->resolver;
+
+    if (wev->timedout) {
+        goto failed;
     }
 
-    response = (ngx_resolver_hdr_t *) buf;
+    sent = c->sent;
 
-    ident = (response->ident_hi << 8) + response->ident_lo;
-    flags = (response->flags_hi << 8) + response->flags_lo;
-    nqs = (response->nqs_hi << 8) + response->nqs_lo;
-    nan = (response->nan_hi << 8) + response->nan_lo;
+    while (wev->ready && b->pos < b->last) {
+        n = ngx_send(c, b->pos, b->last - b->pos);
 
-    ngx_log_debug6(NGX_LOG_DEBUG_CORE, r->log, 0,
-                   "resolver DNS response %ui fl:%04Xui %ui/%ui/%ud/%ud",
-                   ident, flags, nqs, nan,
-                   (response->nns_hi << 8) + response->nns_lo,
-                   (response->nar_hi << 8) + response->nar_lo);
+        if (n == NGX_AGAIN) {
+            break;
+        }
 
-    /* response to a standard query */
-    if ((flags & 0xf870) != 0x8000) {
-        ngx_log_error(r->log_level, r->log, 0,
-                      "invalid DNS response %ui fl:%04Xui", ident, flags);
-        return;
+        if (n == NGX_ERROR) {
+            goto failed;
+        }
+
+        b->pos += n;
     }
 
-    code = flags & 0xf;
+    if (b->pos != b->start) {
+        b->last = ngx_movemem(b->start, b->pos, b->last - b->pos);
+        b->pos = b->start;
+    }
 
-    if (code == NGX_RESOLVE_FORMERR) {
+    if (c->sent != sent) {
+        ngx_add_timer(wev, (ngx_msec_t) (r->tcp_timeout * 1000));
+    }
 
-        times = 0;
+    if (ngx_handle_write_event(wev, 0) != NGX_OK) {
+        goto failed;
+    }
 
-        for (q = ngx_queue_head(&r->name_resend_queue);
-             q != ngx_queue_sentinel(&r->name_resend_queue) && times++ < 100;
-             q = ngx_queue_next(q))
-        {
-            rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
-            qident = (rn->query[0] << 8) + rn->query[1];
+    return;
 
-            if (qident == ident) {
-                goto dns_error_name;
-            }
+failed:
 
-#if (NGX_HAVE_INET6)
-            if (rn->query6) {
-                qident6 = (rn->query6[0] << 8) + rn->query6[1];
+    ngx_close_connection(c);
+    rec->tcp = NULL;
+}
 
-                if (qident6 == ident) {
-                    goto dns_error_name;
+
+static void
+ngx_resolver_tcp_read(ngx_event_t *rev)
+{
+    u_char                     *p;
+    size_t                      size;
+    ssize_t                     n;
+    u_short                     qlen;
+    ngx_buf_t                  *b;
+    ngx_resolver_t             *r;
+    ngx_connection_t           *c;
+    ngx_resolver_connection_t  *rec;
+
+    c = rev->data;
+    rec = c->data;
+    b = rec->read_buf;
+    r = rec->resolver;
+
+    while (rev->ready) {
+        n = ngx_recv(c, b->last, b->end - b->last);
+
+        if (n == NGX_AGAIN) {
+            break;
+        }
+
+        if (n == NGX_ERROR || n == 0) {
+            goto failed;
+        }
+
+        b->last += n;
+
+        for ( ;; ) {
+            p = b->pos;
+            size = b->last - p;
+
+            if (size < 2) {
+                break;
+            }
+
+            qlen = (u_short) *p++ << 8;
+            qlen += *p++;
+
+            if (size < (size_t) (2 + qlen)) {
+                break;
+            }
+
+            ngx_resolver_process_response(r, p, qlen, 1);
+
+            b->pos += 2 + qlen;
+        }
+
+        if (b->pos != b->start) {
+            b->last = ngx_movemem(b->start, b->pos, b->last - b->pos);
+            b->pos = b->start;
+        }
+    }
+
+    if (ngx_handle_read_event(rev, 0) != NGX_OK) {
+        goto failed;
+    }
+
+    return;
+
+failed:
+
+    ngx_close_connection(c);
+    rec->tcp = NULL;
+}
+
+
+static void
+ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n,
+    ngx_uint_t tcp)
+{
+    char                 *err;
+    ngx_uint_t            i, times, ident, qident, flags, code, nqs, nan, trunc,
+                          qtype, qclass;
+#if (NGX_HAVE_INET6)
+    ngx_uint_t            qident6;
+#endif
+    ngx_queue_t          *q;
+    ngx_resolver_qs_t    *qs;
+    ngx_resolver_hdr_t   *response;
+    ngx_resolver_node_t  *rn;
+
+    if (n < sizeof(ngx_resolver_hdr_t)) {
+        goto short_response;
+    }
+
+    response = (ngx_resolver_hdr_t *) buf;
+
+    ident = (response->ident_hi << 8) + response->ident_lo;
+    flags = (response->flags_hi << 8) + response->flags_lo;
+    nqs = (response->nqs_hi << 8) + response->nqs_lo;
+    nan = (response->nan_hi << 8) + response->nan_lo;
+    trunc = flags & 0x0200;
+
+    ngx_log_debug6(NGX_LOG_DEBUG_CORE, r->log, 0,
+                   "resolver DNS response %ui fl:%04Xi %ui/%ui/%ud/%ud",
+                   ident, flags, nqs, nan,
+                   (response->nns_hi << 8) + response->nns_lo,
+                   (response->nar_hi << 8) + response->nar_lo);
+
+    /* response to a standard query */
+    if ((flags & 0xf870) != 0x8000 || (trunc && tcp)) {
+        ngx_log_error(r->log_level, r->log, 0,
+                      "invalid %s DNS response %ui fl:%04Xi",
+                      tcp ? "TCP" : "UDP", ident, flags);
+        return;
+    }
+
+    code = flags & 0xf;
+
+    if (code == NGX_RESOLVE_FORMERR) {
+
+        times = 0;
+
+        for (q = ngx_queue_head(&r->name_resend_queue);
+             q != ngx_queue_sentinel(&r->name_resend_queue) && times++ < 100;
+             q = ngx_queue_next(q))
+        {
+            rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
+            qident = (rn->query[0] << 8) + rn->query[1];
+
+            if (qident == ident) {
+                goto dns_error_name;
+            }
+
+#if (NGX_HAVE_INET6)
+            if (rn->query6) {
+                qident6 = (rn->query6[0] << 8) + rn->query6[1];
+
+                if (qident6 == ident) {
+                    goto dns_error_name;
                 }
             }
 #endif
@@ -1397,11 +1832,18 @@ found:
     case NGX_RESOLVE_AAAA:
 #endif
 
-        ngx_resolver_process_a(r, buf, n, ident, code, qtype, nan,
+        ngx_resolver_process_a(r, buf, n, ident, code, qtype, nan, trunc,
                                i + sizeof(ngx_resolver_qs_t));
 
         break;
 
+    case NGX_RESOLVE_SRV:
+
+        ngx_resolver_process_srv(r, buf, n, ident, code, nan, trunc,
+                                 i + sizeof(ngx_resolver_qs_t));
+
+        break;
+
     case NGX_RESOLVE_PTR:
 
         ngx_resolver_process_ptr(r, buf, n, ident, code, nan);
@@ -1431,7 +1873,7 @@ dns_error_name:
     ngx_log_error(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);
+                  (size_t) rn->nlen, rn->name);
     return;
 
 dns_error:
@@ -1444,28 +1886,29 @@ dns_error:
 
 
 static void
-ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
+ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
     ngx_uint_t ident, ngx_uint_t code, ngx_uint_t qtype,
-    ngx_uint_t nan, ngx_uint_t ans)
+    ngx_uint_t nan, ngx_uint_t trunc, ngx_uint_t ans)
 {
-    char                 *err;
-    u_char               *cname;
-    size_t                len;
-    int32_t               ttl;
-    uint32_t              hash;
-    in_addr_t            *addr;
-    ngx_str_t             name;
-    ngx_addr_t           *addrs;
-    ngx_uint_t            type, class, qident, naddrs, a, i, n, start;
+    char                       *err;
+    u_char                     *cname;
+    size_t                      len;
+    int32_t                     ttl;
+    uint32_t                    hash;
+    in_addr_t                  *addr;
+    ngx_str_t                   name;
+    ngx_uint_t                  type, class, qident, naddrs, a, i, j, start;
 #if (NGX_HAVE_INET6)
-    struct in6_addr      *addr6;
+    struct in6_addr            *addr6;
 #endif
-    ngx_resolver_an_t    *an;
-    ngx_resolver_ctx_t   *ctx, *next;
-    ngx_resolver_node_t  *rn;
+    ngx_resolver_an_t          *an;
+    ngx_resolver_ctx_t         *ctx, *next;
+    ngx_resolver_node_t        *rn;
+    ngx_resolver_addr_t        *addrs;
+    ngx_resolver_connection_t  *rec;
 
     if (ngx_resolver_copy(r, &name, buf,
-                          buf + sizeof(ngx_resolver_hdr_t), buf + last)
+                          buf + sizeof(ngx_resolver_hdr_t), buf + n)
         != NGX_OK)
     {
         return;
@@ -1498,6 +1941,11 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
             goto failed;
         }
 
+        if (trunc && rn->tcp6) {
+            ngx_resolver_free(r, name.data);
+            goto failed;
+        }
+
         qident = (rn->query6[0] << 8) + rn->query6[1];
 
         break;
@@ -1512,6 +1960,11 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
             goto failed;
         }
 
+        if (trunc && rn->tcp) {
+            ngx_resolver_free(r, name.data);
+            goto failed;
+        }
+
         qident = (rn->query[0] << 8) + rn->query[1];
     }
 
@@ -1525,6 +1978,45 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
 
     ngx_resolver_free(r, name.data);
 
+    if (trunc) {
+
+        ngx_queue_remove(&rn->queue);
+
+        if (rn->waiting == NULL) {
+            ngx_rbtree_delete(&r->name_rbtree, &rn->node);
+            ngx_resolver_free_node(r, rn);
+            goto next;
+        }
+
+        rec = r->connections.elts;
+        rec = &rec[rn->last_connection];
+
+        switch (qtype) {
+
+#if (NGX_HAVE_INET6)
+        case NGX_RESOLVE_AAAA:
+
+            rn->tcp6 = 1;
+
+            (void) ngx_resolver_send_tcp_query(r, rec, rn->query6, rn->qlen);
+
+            break;
+#endif
+
+        default: /* NGX_RESOLVE_A */
+
+            rn->tcp = 1;
+
+            (void) ngx_resolver_send_tcp_query(r, rec, rn->query, rn->qlen);
+        }
+
+        rn->expire = ngx_time() + r->resend_timeout;
+
+        ngx_queue_insert_head(&r->name_resend_queue, &rn->queue);
+
+        goto next;
+    }
+
     if (code == 0 && rn->code) {
         code = rn->code;
     }
@@ -1604,6 +2096,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
         while (next) {
             ctx = next;
             ctx->state = code;
+            ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
             next = ctx->next;
 
             ctx->handler(ctx);
@@ -1622,7 +2115,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
 
         start = i;
 
-        while (i < last) {
+        while (i < n) {
 
             if (buf[i] & 0xc0) {
                 i += 2;
@@ -1648,7 +2141,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
 
     found:
 
-        if (i + sizeof(ngx_resolver_an_t) >= last) {
+        if (i + sizeof(ngx_resolver_an_t) >= n) {
             goto short_response;
         }
 
@@ -1688,7 +2181,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
                 goto invalid;
             }
 
-            if (i + 4 > last) {
+            if (i + 4 > n) {
                 goto short_response;
             }
 
@@ -1709,7 +2202,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
                 goto invalid;
             }
 
-            if (i + 16 > last) {
+            if (i + 16 > n) {
                 goto short_response;
             }
 
@@ -1790,7 +2283,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
 #endif
         }
 
-        n = 0;
+        j = 0;
         i = ans;
 
         for (a = 0; a < nan; a++) {
@@ -1819,10 +2312,10 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
 
             if (type == NGX_RESOLVE_A) {
 
-                addr[n] = htonl((buf[i] << 24) + (buf[i + 1] << 16)
+                addr[j] = htonl((buf[i] << 24) + (buf[i + 1] << 16)
                                 + (buf[i + 2] << 8) + (buf[i + 3]));
 
-                if (++n == naddrs) {
+                if (++j == naddrs) {
 
 #if (NGX_HAVE_INET6)
                     if (rn->naddrs6 == (u_short) -1) {
@@ -1837,9 +2330,9 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
 #if (NGX_HAVE_INET6)
             else if (type == NGX_RESOLVE_AAAA) {
 
-                ngx_memcpy(addr6[n].s6_addr, &buf[i], 16);
+                ngx_memcpy(addr6[j].s6_addr, &buf[i], 16);
 
-                if (++n == naddrs) {
+                if (++j == naddrs) {
 
                     if (rn->naddrs == (u_short) -1) {
                         goto next;
@@ -1918,6 +2411,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
         while (next) {
             ctx = next;
             ctx->state = NGX_OK;
+            ctx->valid = rn->valid;
             ctx->naddrs = naddrs;
 
             if (addrs == NULL) {
@@ -1964,7 +2458,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t last,
             goto next;
         }
 
-        if (ngx_resolver_copy(r, &name, buf, cname, buf + last) != NGX_OK) {
+        if (ngx_resolver_copy(r, &name, buf, cname, buf + n) != NGX_OK) {
             goto failed;
         }
 
@@ -2047,128 +2541,654 @@ next:
 
 
 static void
-ngx_resolver_process_ptr(ngx_resolver_t *r, u_char *buf, size_t n,
-    ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan)
+ngx_resolver_process_srv(ngx_resolver_t *r, u_char *buf, size_t n,
+    ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan,
+    ngx_uint_t trunc, ngx_uint_t ans)
 {
-    char                 *err;
-    size_t                len;
-    u_char                text[NGX_SOCKADDR_STRLEN];
-    in_addr_t             addr;
-    int32_t               ttl;
-    ngx_int_t             octet;
-    ngx_str_t             name;
-    ngx_uint_t            i, mask, qident, class;
-    ngx_queue_t          *expire_queue;
-    ngx_rbtree_t         *tree;
-    ngx_resolver_an_t    *an;
-    ngx_resolver_ctx_t   *ctx, *next;
-    ngx_resolver_node_t  *rn;
-#if (NGX_HAVE_INET6)
-    uint32_t              hash;
-    ngx_int_t             digit;
-    struct in6_addr       addr6;
-#endif
+    char                       *err;
+    u_char                     *cname;
+    size_t                      len;
+    int32_t                     ttl;
+    uint32_t                    hash;
+    ngx_str_t                   name;
+    ngx_uint_t                  type, qident, class, start, nsrvs, a, i, j;
+    ngx_resolver_an_t          *an;
+    ngx_resolver_ctx_t         *ctx, *next;
+    ngx_resolver_srv_t         *srvs;
+    ngx_resolver_node_t        *rn;
+    ngx_resolver_connection_t  *rec;
 
-    if (ngx_resolver_copy(r, NULL, buf,
+    if (ngx_resolver_copy(r, &name, buf,
                           buf + sizeof(ngx_resolver_hdr_t), buf + n)
         != NGX_OK)
     {
         return;
     }
 
-    /* AF_INET */
-
-    addr = 0;
-    i = sizeof(ngx_resolver_hdr_t);
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver qs:%V", &name);
 
-    for (mask = 0; mask < 32; mask += 8) {
-        len = buf[i++];
+    hash = ngx_crc32_short(name.data, name.len);
 
-        octet = ngx_atoi(&buf[i], len);
-        if (octet == NGX_ERROR || octet > 255) {
-            goto invalid_in_addr_arpa;
-        }
+    rn = ngx_resolver_lookup_srv(r, &name, hash);
 
-        addr += octet << mask;
-        i += len;
+    if (rn == NULL || rn->query == NULL) {
+        ngx_log_error(r->log_level, r->log, 0,
+                      "unexpected response for %V", &name);
+        ngx_resolver_free(r, name.data);
+        goto failed;
     }
 
-    if (ngx_strcasecmp(&buf[i], (u_char *) "\7in-addr\4arpa") == 0) {
-        i += sizeof("\7in-addr\4arpa");
-
-        /* lock addr mutex */
-
-        rn = ngx_resolver_lookup_addr(r, addr);
-
-        tree = &r->addr_rbtree;
-        expire_queue = &r->addr_expire_queue;
+    if (trunc && rn->tcp) {
+        ngx_resolver_free(r, name.data);
+        goto failed;
+    }
 
-        addr = htonl(addr);
-        name.len = ngx_inet_ntop(AF_INET, &addr, text, NGX_SOCKADDR_STRLEN);
-        name.data = text;
+    qident = (rn->query[0] << 8) + rn->query[1];
 
-        goto valid;
+    if (ident != qident) {
+        ngx_log_error(r->log_level, r->log, 0,
+                      "wrong ident %ui response for %V, expect %ui",
+                      ident, &name, qident);
+        ngx_resolver_free(r, name.data);
+        goto failed;
     }
 
-invalid_in_addr_arpa:
+    ngx_resolver_free(r, name.data);
 
-#if (NGX_HAVE_INET6)
+    if (trunc) {
 
-    i = sizeof(ngx_resolver_hdr_t);
+        ngx_queue_remove(&rn->queue);
 
-    for (octet = 15; octet >= 0; octet--) {
-        if (buf[i++] != '\1') {
-            goto invalid_ip6_arpa;
+        if (rn->waiting == NULL) {
+            ngx_rbtree_delete(&r->srv_rbtree, &rn->node);
+            ngx_resolver_free_node(r, rn);
+            return;
         }
 
-        digit = ngx_hextoi(&buf[i++], 1);
-        if (digit == NGX_ERROR) {
-            goto invalid_ip6_arpa;
-        }
+        rec = r->connections.elts;
+        rec = &rec[rn->last_connection];
 
-        addr6.s6_addr[octet] = (u_char) digit;
+        rn->tcp = 1;
 
-        if (buf[i++] != '\1') {
-            goto invalid_ip6_arpa;
-        }
+        (void) ngx_resolver_send_tcp_query(r, rec, rn->query, rn->qlen);
 
-        digit = ngx_hextoi(&buf[i++], 1);
-        if (digit == NGX_ERROR) {
-            goto invalid_ip6_arpa;
-        }
+        rn->expire = ngx_time() + r->resend_timeout;
 
-        addr6.s6_addr[octet] += (u_char) (digit * 16);
+        ngx_queue_insert_head(&r->srv_resend_queue, &rn->queue);
+
+        return;
     }
 
-    if (ngx_strcasecmp(&buf[i], (u_char *) "\3ip6\4arpa") == 0) {
-        i += sizeof("\3ip6\4arpa");
+    if (code == 0 && rn->code) {
+        code = rn->code;
+    }
 
-        /* lock addr mutex */
+    if (code == 0 && nan == 0) {
+        code = NGX_RESOLVE_NXDOMAIN;
+    }
 
-        hash = ngx_crc32_short(addr6.s6_addr, 16);
-        rn = ngx_resolver_lookup_addr6(r, &addr6, hash);
+    if (code) {
+        next = rn->waiting;
+        rn->waiting = NULL;
 
-        tree = &r->addr6_rbtree;
-        expire_queue = &r->addr6_expire_queue;
+        ngx_queue_remove(&rn->queue);
 
-        name.len = ngx_inet6_ntop(addr6.s6_addr, text, NGX_SOCKADDR_STRLEN);
-        name.data = text;
+        ngx_rbtree_delete(&r->srv_rbtree, &rn->node);
 
-        goto valid;
-    }
+        while (next) {
+            ctx = next;
+            ctx->state = code;
+            ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
+            next = ctx->next;
 
-invalid_ip6_arpa:
-#endif
+            ctx->handler(ctx);
+        }
 
-    ngx_log_error(r->log_level, r->log, 0,
-                  "invalid in-addr.arpa or ip6.arpa name in DNS response");
-    return;
+        ngx_resolver_free_node(r, rn);
 
-valid:
+        return;
+    }
+
+    i = ans;
+    nsrvs = 0;
+    cname = NULL;
+
+    for (a = 0; a < nan; a++) {
+
+        start = i;
+
+        while (i < n) {
+
+            if (buf[i] & 0xc0) {
+                i += 2;
+                goto found;
+            }
+
+            if (buf[i] == 0) {
+                i++;
+                goto test_length;
+            }
+
+            i += 1 + buf[i];
+        }
+
+        goto short_response;
+
+    test_length:
+
+        if (i - start < 2) {
+            err = "invalid name DNS response";
+            goto invalid;
+        }
+
+    found:
+
+        if (i + sizeof(ngx_resolver_an_t) >= n) {
+            goto short_response;
+        }
+
+        an = (ngx_resolver_an_t *) &buf[i];
+
+        type = (an->type_hi << 8) + an->type_lo;
+        class = (an->class_hi << 8) + an->class_lo;
+        len = (an->len_hi << 8) + an->len_lo;
+        ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16)
+            + (an->ttl[2] << 8) + (an->ttl[3]);
+
+        if (class != 1) {
+            ngx_log_error(r->log_level, r->log, 0,
+                          "unexpected RR class %ui", class);
+            goto failed;
+        }
+
+        if (ttl < 0) {
+            ttl = 0;
+        }
+
+        rn->ttl = ngx_min(rn->ttl, (uint32_t) ttl);
+
+        i += sizeof(ngx_resolver_an_t);
+
+        switch (type) {
+
+        case NGX_RESOLVE_SRV:
+
+            if (i + 6 > n) {
+                goto short_response;
+            }
+
+            if (ngx_resolver_copy(r, NULL, buf, &buf[i + 6], buf + n)
+                != NGX_OK)
+            {
+                goto failed;
+            }
+
+            nsrvs++;
+
+            break;
+
+        case NGX_RESOLVE_CNAME:
+
+            cname = &buf[i];
+
+            break;
+
+        case NGX_RESOLVE_DNAME:
+
+            break;
+
+        default:
+
+            ngx_log_error(r->log_level, r->log, 0,
+                          "unexpected RR type %ui", type);
+        }
+
+        i += len;
+    }
+
+    ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
+                   "resolver nsrvs:%ui cname:%p ttl:%uD",
+                   nsrvs, cname, rn->ttl);
+
+    if (nsrvs) {
+
+        srvs = ngx_resolver_calloc(r, nsrvs * sizeof(ngx_resolver_srv_t));
+        if (srvs == NULL) {
+            goto failed;
+        }
+
+        rn->u.srvs = srvs;
+        rn->nsrvs = (u_short) nsrvs;
+
+        j = 0;
+        i = ans;
+
+        for (a = 0; a < nan; a++) {
+
+            for ( ;; ) {
+
+                if (buf[i] & 0xc0) {
+                    i += 2;
+                    break;
+                }
+
+                if (buf[i] == 0) {
+                    i++;
+                    break;
+                }
+
+                i += 1 + buf[i];
+            }
+
+            an = (ngx_resolver_an_t *) &buf[i];
+
+            type = (an->type_hi << 8) + an->type_lo;
+            len = (an->len_hi << 8) + an->len_lo;
+
+            i += sizeof(ngx_resolver_an_t);
+
+            if (type == NGX_RESOLVE_SRV) {
+
+                srvs[j].priority = (buf[i] << 8) + buf[i + 1];
+                srvs[j].weight = (buf[i + 2] << 8) + buf[i + 3];
+
+                if (srvs[j].weight == 0) {
+                    srvs[j].weight = 1;
+                }
+
+                srvs[j].port = (buf[i + 4] << 8) + buf[i + 5];
+
+                if (ngx_resolver_copy(r, &srvs[j].name, buf, &buf[i + 6],
+                                      buf + n)
+                    != NGX_OK)
+                {
+                    goto failed;
+                }
+
+                j++;
+            }
+
+            i += len;
+        }
+
+        ngx_sort(srvs, nsrvs, sizeof(ngx_resolver_srv_t),
+                 ngx_resolver_cmp_srvs);
+
+        ngx_resolver_free(r, rn->query);
+        rn->query = NULL;
+
+        ngx_queue_remove(&rn->queue);
+
+        rn->valid = ngx_time() + (r->valid ? r->valid : (time_t) rn->ttl);
+        rn->expire = ngx_time() + r->expire;
+
+        ngx_queue_insert_head(&r->srv_expire_queue, &rn->queue);
+
+        next = rn->waiting;
+        rn->waiting = NULL;
+
+        while (next) {
+            ctx = next;
+            next = ctx->next;
+
+            ngx_resolver_resolve_srv_names(ctx, rn);
+        }
+
+        return;
+    }
+
+    rn->nsrvs = 0;
+
+    if (cname) {
+
+        /* CNAME only */
+
+        if (ngx_resolver_copy(r, &name, buf, cname, buf + n) != NGX_OK) {
+            goto failed;
+        }
+
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
+                       "resolver cname:\"%V\"", &name);
+
+        ngx_queue_remove(&rn->queue);
+
+        rn->cnlen = (u_short) name.len;
+        rn->u.cname = name.data;
+
+        rn->valid = ngx_time() + (r->valid ? r->valid : (time_t) rn->ttl);
+        rn->expire = ngx_time() + r->expire;
+
+        ngx_queue_insert_head(&r->srv_expire_queue, &rn->queue);
+
+        ngx_resolver_free(r, rn->query);
+        rn->query = NULL;
+#if (NGX_HAVE_INET6)
+        rn->query6 = NULL;
+#endif
+
+        ctx = rn->waiting;
+        rn->waiting = NULL;
+
+        if (ctx) {
+
+            if (ctx->recursion++ >= NGX_RESOLVER_MAX_RECURSION) {
+
+                /* unlock name mutex */
+
+                do {
+                    ctx->state = NGX_RESOLVE_NXDOMAIN;
+                    next = ctx->next;
+
+                    ctx->handler(ctx);
+
+                    ctx = next;
+                } while (ctx);
+
+                return;
+            }
+
+            for (next = ctx; next; next = next->next) {
+                next->node = NULL;
+            }
+
+            (void) ngx_resolve_name_locked(r, ctx, &name);
+        }
+
+        /* unlock name mutex */
+
+        return;
+    }
+
+    ngx_log_error(r->log_level, r->log, 0, "no SRV type in DNS response");
+
+    return;
+
+short_response:
+
+    err = "short DNS response";
+
+invalid:
+
+    /* unlock name mutex */
+
+    ngx_log_error(r->log_level, r->log, 0, err);
+
+    return;
+
+failed:
+
+    /* unlock name mutex */
+
+    return;
+}
+
+
+static void
+ngx_resolver_resolve_srv_names(ngx_resolver_ctx_t *ctx, ngx_resolver_node_t *rn)
+{
+    ngx_uint_t                i;
+    ngx_resolver_t           *r;
+    ngx_resolver_ctx_t       *cctx;
+    ngx_resolver_srv_name_t  *srvs;
+
+    r = ctx->resolver;
+
+    ctx->node = NULL;
+    ctx->state = NGX_OK;
+    ctx->valid = rn->valid;
+    ctx->count = rn->nsrvs;
+
+    srvs = ngx_resolver_calloc(r, rn->nsrvs * sizeof(ngx_resolver_srv_name_t));
+    if (srvs == NULL) {
+        goto failed;
+    }
+
+    ctx->srvs = srvs;
+    ctx->nsrvs = rn->nsrvs;
+
+    for (i = 0; i < rn->nsrvs; i++) {
+        srvs[i].name.data = ngx_resolver_alloc(r, rn->u.srvs[i].name.len);
+        if (srvs[i].name.data == NULL) {
+            goto failed;
+        }
+
+        srvs[i].name.len = rn->u.srvs[i].name.len;
+        ngx_memcpy(srvs[i].name.data, rn->u.srvs[i].name.data,
+                   srvs[i].name.len);
+
+        cctx = ngx_resolve_start(r, NULL);
+        if (cctx == NULL) {
+            goto failed;
+        }
+
+        cctx->name = srvs[i].name;
+        cctx->handler = ngx_resolver_srv_names_handler;
+        cctx->data = ctx;
+        cctx->srvs = &srvs[i];
+        cctx->timeout = 0;
+
+        srvs[i].priority = rn->u.srvs[i].priority;
+        srvs[i].weight = rn->u.srvs[i].weight;
+        srvs[i].port = rn->u.srvs[i].port;
+        srvs[i].ctx = cctx;
+
+        if (ngx_resolve_name(cctx) == NGX_ERROR) {
+            srvs[i].ctx = NULL;
+            goto failed;
+        }
+    }
+
+    return;
+
+failed:
+
+    ctx->state = NGX_ERROR;
+    ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
+
+    ctx->handler(ctx);
+}
+
+
+static void
+ngx_resolver_srv_names_handler(ngx_resolver_ctx_t *cctx)
+{
+    ngx_uint_t                 i;
+    u_char                   (*sockaddr)[NGX_SOCKADDRLEN];
+    ngx_addr_t                *addrs;
+    ngx_resolver_t            *r;
+    struct sockaddr_in        *sin;
+    ngx_resolver_ctx_t        *ctx;
+    ngx_resolver_srv_name_t   *srv;
+#if (NGX_HAVE_INET6)
+    struct sockaddr_in6       *sin6;
+#endif
+
+    r = cctx->resolver;
+    ctx = cctx->data;
+    srv = cctx->srvs;
+
+    ctx->count--;
+
+    srv->ctx = NULL;
+
+    if (cctx->naddrs) {
+
+        ctx->valid = ngx_min(ctx->valid, cctx->valid);
+
+        addrs = ngx_resolver_calloc(r, cctx->naddrs * sizeof(ngx_addr_t));
+        if (addrs == NULL) {
+            ngx_resolve_name_done(cctx);
+
+            ctx->state = NGX_ERROR;
+            ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
+
+            ctx->handler(ctx);
+            return;
+        }
+
+        sockaddr = ngx_resolver_alloc(r, cctx->naddrs * NGX_SOCKADDRLEN);
+        if (sockaddr == NULL) {
+            ngx_resolver_free(r, addrs);
+            ngx_resolve_name_done(cctx);
+
+            ctx->state = NGX_ERROR;
+            ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
+
+            ctx->handler(ctx);
+            return;
+        }
+
+        for (i = 0; i < cctx->naddrs; i++) {
+            addrs[i].sockaddr = (struct sockaddr *) sockaddr[i];
+            addrs[i].socklen = cctx->addrs[i].socklen;
+
+            ngx_memcpy(sockaddr[i], cctx->addrs[i].sockaddr,
+                       addrs[i].socklen);
+
+            switch (addrs[i].sockaddr->sa_family) {
+#if (NGX_HAVE_INET6)
+            case AF_INET6:
+                sin6 = (struct sockaddr_in6 *) addrs[i].sockaddr;
+                sin6->sin6_port = htons(srv->port);
+                break;
+#endif
+            default: /* AF_INET */
+                sin = (struct sockaddr_in *) addrs[i].sockaddr;
+                sin->sin_port = htons(srv->port);
+            }
+        }
+
+        srv->addrs = addrs;
+        srv->naddrs = cctx->naddrs;
+    }
+
+    ngx_resolve_name_done(cctx);
+
+    if (ctx->count == 0) {
+        ngx_resolver_report_srv(r, ctx);
+    }
+}
+
+
+static void
+ngx_resolver_process_ptr(ngx_resolver_t *r, u_char *buf, size_t n,
+    ngx_uint_t ident, ngx_uint_t code, ngx_uint_t nan)
+{
+    char                 *err;
+    size_t                len;
+    in_addr_t             addr;
+    int32_t               ttl;
+    ngx_int_t             octet;
+    ngx_str_t             name;
+    ngx_uint_t            mask, type, class, qident, a, i, start;
+    ngx_queue_t          *expire_queue;
+    ngx_rbtree_t         *tree;
+    ngx_resolver_an_t    *an;
+    ngx_resolver_ctx_t   *ctx, *next;
+    ngx_resolver_node_t  *rn;
+#if (NGX_HAVE_INET6)
+    uint32_t              hash;
+    ngx_int_t             digit;
+    struct in6_addr       addr6;
+#endif
+
+    if (ngx_resolver_copy(r, &name, buf,
+                          buf + sizeof(ngx_resolver_hdr_t), buf + n)
+        != NGX_OK)
+    {
+        return;
+    }
+
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver qs:%V", &name);
+
+    /* AF_INET */
+
+    addr = 0;
+    i = sizeof(ngx_resolver_hdr_t);
+
+    for (mask = 0; mask < 32; mask += 8) {
+        len = buf[i++];
+
+        octet = ngx_atoi(&buf[i], len);
+        if (octet == NGX_ERROR || octet > 255) {
+            goto invalid_in_addr_arpa;
+        }
+
+        addr += octet << mask;
+        i += len;
+    }
+
+    if (ngx_strcasecmp(&buf[i], (u_char *) "\7in-addr\4arpa") == 0) {
+        i += sizeof("\7in-addr\4arpa");
+
+        /* lock addr mutex */
+
+        rn = ngx_resolver_lookup_addr(r, addr);
+
+        tree = &r->addr_rbtree;
+        expire_queue = &r->addr_expire_queue;
+
+        goto valid;
+    }
+
+invalid_in_addr_arpa:
+
+#if (NGX_HAVE_INET6)
+
+    i = sizeof(ngx_resolver_hdr_t);
+
+    for (octet = 15; octet >= 0; octet--) {
+        if (buf[i++] != '\1') {
+            goto invalid_ip6_arpa;
+        }
+
+        digit = ngx_hextoi(&buf[i++], 1);
+        if (digit == NGX_ERROR) {
+            goto invalid_ip6_arpa;
+        }
+
+        addr6.s6_addr[octet] = (u_char) digit;
+
+        if (buf[i++] != '\1') {
+            goto invalid_ip6_arpa;
+        }
+
+        digit = ngx_hextoi(&buf[i++], 1);
+        if (digit == NGX_ERROR) {
+            goto invalid_ip6_arpa;
+        }
+
+        addr6.s6_addr[octet] += (u_char) (digit * 16);
+    }
+
+    if (ngx_strcasecmp(&buf[i], (u_char *) "\3ip6\4arpa") == 0) {
+        i += sizeof("\3ip6\4arpa");
+
+        /* lock addr mutex */
+
+        hash = ngx_crc32_short(addr6.s6_addr, 16);
+        rn = ngx_resolver_lookup_addr6(r, &addr6, hash);
+
+        tree = &r->addr6_rbtree;
+        expire_queue = &r->addr6_expire_queue;
+
+        goto valid;
+    }
+
+invalid_ip6_arpa:
+#endif
+
+    ngx_log_error(r->log_level, r->log, 0,
+                  "invalid in-addr.arpa or ip6.arpa name in DNS response");
+    ngx_resolver_free(r, name.data);
+    return;
+
+valid:
 
     if (rn == NULL || rn->query == NULL) {
         ngx_log_error(r->log_level, r->log, 0,
                       "unexpected response for %V", &name);
+        ngx_resolver_free(r, name.data);
         goto failed;
     }
 
@@ -2178,9 +3198,12 @@ valid:
         ngx_log_error(r->log_level, r->log, 0,
                       "wrong ident %ui response for %V, expect %ui",
                       ident, &name, qident);
+        ngx_resolver_free(r, name.data);
         goto failed;
     }
 
+    ngx_resolver_free(r, name.data);
+
     if (code == 0 && nan == 0) {
         code = NGX_RESOLVE_NXDOMAIN;
     }
@@ -2198,6 +3221,7 @@ valid:
         while (next) {
             ctx = next;
             ctx->state = code;
+            ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
             next = ctx->next;
 
             ctx->handler(ctx);
@@ -2210,45 +3234,91 @@ valid:
 
     i += sizeof(ngx_resolver_qs_t);
 
-    if (i + 2 + sizeof(ngx_resolver_an_t) >= n) {
+    for (a = 0; a < nan; a++) {
+
+        start = i;
+
+        while (i < n) {
+
+            if (buf[i] & 0xc0) {
+                i += 2;
+                goto found;
+            }
+
+            if (buf[i] == 0) {
+                i++;
+                goto test_length;
+            }
+
+            i += 1 + buf[i];
+        }
+
         goto short_response;
-    }
 
-    /* compression pointer to *.arpa */
+    test_length:
 
-    if (buf[i] != 0xc0 || buf[i + 1] != sizeof(ngx_resolver_hdr_t)) {
-        err = "invalid in-addr.arpa or ip6.arpa name in DNS response";
-        goto invalid;
-    }
+        if (i - start < 2) {
+            err = "invalid name in DNS response";
+            goto invalid;
+        }
 
-    an = (ngx_resolver_an_t *) &buf[i + 2];
+    found:
 
-    class = (an->class_hi << 8) + an->class_lo;
-    len = (an->len_hi << 8) + an->len_lo;
-    ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16)
-        + (an->ttl[2] << 8) + (an->ttl[3]);
+        if (i + sizeof(ngx_resolver_an_t) >= n) {
+            goto short_response;
+        }
 
-    if (class != 1) {
-        ngx_log_error(r->log_level, r->log, 0,
-                      "unexpected RR class %ui", class);
-        goto failed;
-    }
+        an = (ngx_resolver_an_t *) &buf[i];
 
-    if (ttl < 0) {
-        ttl = 0;
-    }
+        type = (an->type_hi << 8) + an->type_lo;
+        class = (an->class_hi << 8) + an->class_lo;
+        len = (an->len_hi << 8) + an->len_lo;
+        ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16)
+            + (an->ttl[2] << 8) + (an->ttl[3]);
 
-    ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
-                  "resolver qt:%ui cl:%ui len:%uz",
-                  (an->type_hi << 8) + an->type_lo,
-                  class, len);
+        if (class != 1) {
+            ngx_log_error(r->log_level, r->log, 0,
+                          "unexpected RR class %ui", class);
+            goto failed;
+        }
+
+        if (ttl < 0) {
+            ttl = 0;
+        }
 
-    i += 2 + sizeof(ngx_resolver_an_t);
+        ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0,
+                      "resolver qt:%ui cl:%ui len:%uz",
+                      type, class, len);
 
-    if (i + len > n) {
-        goto short_response;
+        i += sizeof(ngx_resolver_an_t);
+
+        switch (type) {
+
+        case NGX_RESOLVE_PTR:
+
+            goto ptr;
+
+        case NGX_RESOLVE_CNAME:
+
+            break;
+
+        default:
+
+            ngx_log_error(r->log_level, r->log, 0,
+                          "unexpected RR type %ui", type);
+        }
+
+        i += len;
     }
 
+    /* unlock addr mutex */
+
+    ngx_log_error(r->log_level, r->log, 0,
+                  "no PTR type in DNS response");
+    return;
+
+ptr:
+
     if (ngx_resolver_copy(r, &name, buf, buf + i, buf + n) != NGX_OK) {
         goto failed;
     }
@@ -2286,6 +3356,7 @@ valid:
     while (next) {
         ctx = next;
         ctx->state = NGX_OK;
+        ctx->valid = rn->valid;
         ctx->name = name;
         next = ctx->next;
 
@@ -2317,14 +3388,55 @@ failed:
 
 
 static ngx_resolver_node_t *
-ngx_resolver_lookup_name(ngx_resolver_t *r, ngx_str_t *name, uint32_t hash)
+ngx_resolver_lookup_name(ngx_resolver_t *r, ngx_str_t *name, uint32_t hash)
+{
+    ngx_int_t             rc;
+    ngx_rbtree_node_t    *node, *sentinel;
+    ngx_resolver_node_t  *rn;
+
+    node = r->name_rbtree.root;
+    sentinel = r->name_rbtree.sentinel;
+
+    while (node != sentinel) {
+
+        if (hash < node->key) {
+            node = node->left;
+            continue;
+        }
+
+        if (hash > node->key) {
+            node = node->right;
+            continue;
+        }
+
+        /* hash == node->key */
+
+        rn = ngx_resolver_node(node);
+
+        rc = ngx_memn2cmp(name->data, rn->name, name->len, rn->nlen);
+
+        if (rc == 0) {
+            return rn;
+        }
+
+        node = (rc < 0) ? node->left : node->right;
+    }
+
+    /* not found */
+
+    return NULL;
+}
+
+
+static ngx_resolver_node_t *
+ngx_resolver_lookup_srv(ngx_resolver_t *r, ngx_str_t *name, uint32_t hash)
 {
     ngx_int_t             rc;
     ngx_rbtree_node_t    *node, *sentinel;
     ngx_resolver_node_t  *rn;
 
-    node = r->name_rbtree.root;
-    sentinel = r->name_rbtree.sentinel;
+    node = r->srv_rbtree.root;
+    sentinel = r->srv_rbtree.sentinel;
 
     while (node != sentinel) {
 
@@ -2644,9 +3756,97 @@ ngx_resolver_create_name_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
 }
 
 
+static ngx_int_t
+ngx_resolver_create_srv_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
+    ngx_str_t *name)
+{
+    u_char              *p, *s;
+    size_t               len, nlen;
+    ngx_uint_t           ident;
+    ngx_resolver_qs_t   *qs;
+    ngx_resolver_hdr_t  *query;
+
+    nlen = name->len ? (1 + name->len + 1) : 1;
+
+    len = sizeof(ngx_resolver_hdr_t) + nlen + sizeof(ngx_resolver_qs_t);
+
+    p = ngx_resolver_alloc(r, len);
+    if (p == NULL) {
+        return NGX_ERROR;
+    }
+
+    rn->qlen = (u_short) len;
+    rn->query = p;
+
+    query = (ngx_resolver_hdr_t *) p;
+
+    ident = ngx_random();
+
+    ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
+                   "resolve: \"%V\" SRV %i", name, ident & 0xffff);
+
+    query->ident_hi = (u_char) ((ident >> 8) & 0xff);
+    query->ident_lo = (u_char) (ident & 0xff);
+
+    /* recursion query */
+    query->flags_hi = 1; query->flags_lo = 0;
+
+    /* one question */
+    query->nqs_hi = 0; query->nqs_lo = 1;
+    query->nan_hi = 0; query->nan_lo = 0;
+    query->nns_hi = 0; query->nns_lo = 0;
+    query->nar_hi = 0; query->nar_lo = 0;
+
+    p += sizeof(ngx_resolver_hdr_t) + nlen;
+
+    qs = (ngx_resolver_qs_t *) p;
+
+    /* query type */
+    qs->type_hi = 0; qs->type_lo = NGX_RESOLVE_SRV;
+
+    /* IN query class */
+    qs->class_hi = 0; qs->class_lo = 1;
+
+    /* converts "www.example.com" to "\3www\7example\3com\0" */
+
+    len = 0;
+    p--;
+    *p-- = '\0';
+
+    if (name->len == 0)  {
+        return NGX_DECLINED;
+    }
+
+    for (s = name->data + name->len - 1; s >= name->data; s--) {
+        if (*s != '.') {
+            *p = *s;
+            len++;
+
+        } else {
+            if (len == 0 || len > 255) {
+                return NGX_DECLINED;
+            }
+
+            *p = (u_char) len;
+            len = 0;
+        }
+
+        p--;
+    }
+
+    if (len == 0 || len > 255) {
+        return NGX_DECLINED;
+    }
+
+    *p = (u_char) len;
+
+    return NGX_OK;
+}
+
+
 static ngx_int_t
 ngx_resolver_create_addr_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
-    ngx_addr_t *addr)
+    ngx_resolver_addr_t *addr)
 {
     u_char               *p, *d;
     size_t                len;
@@ -2850,6 +4050,8 @@ ngx_resolver_timeout_handler(ngx_event_t *ev)
 static void
 ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn)
 {
+    ngx_uint_t  i;
+
     /* lock alloc mutex */
 
     if (rn->query) {
@@ -2874,6 +4076,16 @@ ngx_resolver_free_node(ngx_resolver_t *r, ngx_resolver_node_t *rn)
     }
 #endif
 
+    if (rn->nsrvs) {
+        for (i = 0; i < rn->nsrvs; i++) {
+            if (rn->u.srvs[i].name.data) {
+                ngx_resolver_free_locked(r, rn->u.srvs[i].name.data);
+            }
+        }
+
+        ngx_resolver_free_locked(r, rn->u.srvs);
+    }
+
     ngx_resolver_free_locked(r, rn);
 
     /* unlock alloc mutex */
@@ -2945,15 +4157,15 @@ ngx_resolver_dup(ngx_resolver_t *r, void *src, size_t size)
 }
 
 
-static ngx_addr_t *
+static ngx_resolver_addr_t *
 ngx_resolver_export(ngx_resolver_t *r, ngx_resolver_node_t *rn,
     ngx_uint_t rotate)
 {
-    ngx_addr_t            *dst;
     ngx_uint_t             d, i, j, n;
     u_char               (*sockaddr)[NGX_SOCKADDRLEN];
     in_addr_t             *addr;
     struct sockaddr_in    *sin;
+    ngx_resolver_addr_t   *dst;
 #if (NGX_HAVE_INET6)
     struct in6_addr       *addr6;
     struct sockaddr_in6   *sin6;
@@ -2964,7 +4176,7 @@ ngx_resolver_export(ngx_resolver_t *r, ngx_resolver_node_t *rn,
     n += rn->naddrs6;
 #endif
 
-    dst = ngx_resolver_calloc(r, n * sizeof(ngx_addr_t));
+    dst = ngx_resolver_calloc(r, n * sizeof(ngx_resolver_addr_t));
     if (dst == NULL) {
         return NULL;
     }
@@ -3028,6 +4240,99 @@ ngx_resolver_export(ngx_resolver_t *r, ngx_resolver_node_t *rn,
 }
 
 
+static void
+ngx_resolver_report_srv(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx)
+{
+    ngx_uint_t                naddrs, nsrvs, nw, i, j, k, l, m, n, w;
+    ngx_resolver_addr_t      *addrs;
+    ngx_resolver_srv_name_t  *srvs;
+
+    naddrs = 0;
+
+    for (i = 0; i < ctx->nsrvs; i++) {
+        naddrs += ctx->srvs[i].naddrs;
+    }
+
+    if (naddrs == 0) {
+        ctx->state = NGX_RESOLVE_NXDOMAIN;
+        ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
+
+        ctx->handler(ctx);
+        return;
+    }
+
+    addrs = ngx_resolver_calloc(r, naddrs * sizeof(ngx_resolver_addr_t));
+    if (addrs == NULL) {
+        ctx->state = NGX_ERROR;
+        ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
+
+        ctx->handler(ctx);
+        return;
+    }
+
+    srvs = ctx->srvs;
+    nsrvs = ctx->nsrvs;
+
+    i = 0;
+    n = 0;
+
+    do {
+        nw = 0;
+
+        for (j = i; j < nsrvs; j++) {
+            if (srvs[j].priority != srvs[i].priority) {
+                break;
+            }
+
+            nw += srvs[j].naddrs * srvs[j].weight;
+        }
+
+        if (nw == 0) {
+            goto next_srv;
+        }
+
+        w = ngx_random() % nw;
+
+        for (k = i; k < j; k++) {
+            if (w < srvs[k].naddrs * srvs[k].weight) {
+                break;
+            }
+
+            w -= srvs[k].naddrs * srvs[k].weight;
+        }
+
+        for (l = i; l < j; l++) {
+
+            for (m = 0; m < srvs[k].naddrs; m++) {
+                addrs[n].socklen = srvs[k].addrs[m].socklen;
+                addrs[n].sockaddr = srvs[k].addrs[m].sockaddr;
+                addrs[n].name = srvs[k].name;
+                addrs[n].priority = srvs[k].priority;
+                addrs[n].weight = srvs[k].weight;
+                n++;
+            }
+
+            if (++k == j) {
+                k = i;
+            }
+        }
+
+next_srv:
+
+        i = j;
+
+    } while (i < ctx->nsrvs);
+
+    ctx->state = NGX_OK;
+    ctx->addrs = addrs;
+    ctx->naddrs = naddrs;
+
+    ctx->handler(ctx);
+
+    ngx_resolver_free(r, addrs);
+}
+
+
 char *
 ngx_resolver_strerror(ngx_int_t err)
 {
@@ -3054,8 +4359,8 @@ ngx_resolver_strerror(ngx_int_t err)
 static u_char *
 ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len)
 {
-    u_char                *p;
-    ngx_udp_connection_t  *uc;
+    u_char                     *p;
+    ngx_resolver_connection_t  *rec;
 
     p = buf;
 
@@ -3064,10 +4369,10 @@ ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len)
         len -= p - buf;
     }
 
-    uc = log->data;
+    rec = log->data;
 
-    if (uc) {
-        p = ngx_snprintf(p, len, ", resolver: %V", &uc->server);
+    if (rec) {
+        p = ngx_snprintf(p, len, ", resolver: %V", &rec->server);
     }
 
     return p;
@@ -3075,7 +4380,7 @@ ngx_resolver_log_error(ngx_log_t *log, u_char *buf, size_t len)
 
 
 ngx_int_t
-ngx_udp_connect(ngx_udp_connection_t *uc)
+ngx_udp_connect(ngx_resolver_connection_t *rec)
 {
     int                rc;
     ngx_int_t          event;
@@ -3083,21 +4388,21 @@ ngx_udp_connect(ngx_udp_connection_t *uc)
     ngx_socket_t       s;
     ngx_connection_t  *c;
 
-    s = ngx_socket(uc->sockaddr->sa_family, SOCK_DGRAM, 0);
+    s = ngx_socket(rec->sockaddr->sa_family, SOCK_DGRAM, 0);
 
-    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, &uc->log, 0, "UDP socket %d", s);
+    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, &rec->log, 0, "UDP socket %d", s);
 
     if (s == (ngx_socket_t) -1) {
-        ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
+        ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
                       ngx_socket_n " failed");
         return NGX_ERROR;
     }
 
-    c = ngx_get_connection(s, &uc->log);
+    c = ngx_get_connection(s, &rec->log);
 
     if (c == NULL) {
         if (ngx_close_socket(s) == -1) {
-            ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
+            ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
                           ngx_close_socket_n "failed");
         }
 
@@ -3105,7 +4410,7 @@ ngx_udp_connect(ngx_udp_connection_t *uc)
     }
 
     if (ngx_nonblocking(s) == -1) {
-        ngx_log_error(NGX_LOG_ALERT, &uc->log, ngx_socket_errno,
+        ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
                       ngx_nonblocking_n " failed");
 
         goto failed;
@@ -3114,22 +4419,22 @@ ngx_udp_connect(ngx_udp_connection_t *uc)
     rev = c->read;
     wev = c->write;
 
-    rev->log = &uc->log;
-    wev->log = &uc->log;
+    rev->log = &rec->log;
+    wev->log = &rec->log;
 
-    uc->connection = c;
+    rec->udp = c;
 
     c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
 
-    ngx_log_debug3(NGX_LOG_DEBUG_EVENT, &uc->log, 0,
-                   "connect to %V, fd:%d #%uA", &uc->server, s, c->number);
+    ngx_log_debug3(NGX_LOG_DEBUG_EVENT, &rec->log, 0,
+                   "connect to %V, fd:%d #%uA", &rec->server, s, c->number);
 
-    rc = connect(s, uc->sockaddr, uc->socklen);
+    rc = connect(s, rec->sockaddr, rec->socklen);
 
-    /* TODO: aio, iocp */
+    /* TODO: iocp */
 
     if (rc == -1) {
-        ngx_log_error(NGX_LOG_CRIT, &uc->log, ngx_socket_errno,
+        ngx_log_error(NGX_LOG_CRIT, &rec->log, ngx_socket_errno,
                       "connect() failed");
 
         goto failed;
@@ -3138,31 +4443,220 @@ ngx_udp_connect(ngx_udp_connection_t *uc)
     /* UDP sockets are always ready to write */
     wev->ready = 1;
 
-    if (ngx_add_event) {
+    event = (ngx_event_flags & NGX_USE_CLEAR_EVENT) ?
+                /* kqueue, epoll */                 NGX_CLEAR_EVENT:
+                /* select, poll, /dev/poll */       NGX_LEVEL_EVENT;
+                /* eventport event type has no meaning: oneshot only */
+
+    if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
+        goto failed;
+    }
+
+    return NGX_OK;
+
+failed:
+
+    ngx_close_connection(c);
+    rec->udp = NULL;
+
+    return NGX_ERROR;
+}
+
+
+ngx_int_t
+ngx_tcp_connect(ngx_resolver_connection_t *rec)
+{
+    int                rc;
+    ngx_int_t          event;
+    ngx_err_t          err;
+    ngx_uint_t         level;
+    ngx_socket_t       s;
+    ngx_event_t       *rev, *wev;
+    ngx_connection_t  *c;
+
+    s = ngx_socket(rec->sockaddr->sa_family, SOCK_STREAM, 0);
+
+    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, &rec->log, 0, "TCP socket %d", s);
+
+    if (s == (ngx_socket_t) -1) {
+        ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
+                      ngx_socket_n " failed");
+        return NGX_ERROR;
+    }
+
+    c = ngx_get_connection(s, &rec->log);
+
+    if (c == NULL) {
+        if (ngx_close_socket(s) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
+                          ngx_close_socket_n "failed");
+        }
+
+        return NGX_ERROR;
+    }
+
+    if (ngx_nonblocking(s) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
+                      ngx_nonblocking_n " failed");
+
+        goto failed;
+    }
+
+    rev = c->read;
+    wev = c->write;
+
+    rev->log = &rec->log;
+    wev->log = &rec->log;
+
+    rec->tcp = c;
+
+    c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
+
+    if (ngx_add_conn) {
+        if (ngx_add_conn(c) == NGX_ERROR) {
+            goto failed;
+        }
+    }
+
+    ngx_log_debug3(NGX_LOG_DEBUG_EVENT, &rec->log, 0,
+                   "connect to %V, fd:%d #%uA", &rec->server, s, c->number);
+
+    rc = connect(s, rec->sockaddr, rec->socklen);
+
+    if (rc == -1) {
+        err = ngx_socket_errno;
+
+
+        if (err != NGX_EINPROGRESS
+#if (NGX_WIN32)
+            /* Winsock returns WSAEWOULDBLOCK (NGX_EAGAIN) */
+            && err != NGX_EAGAIN
+#endif
+            )
+        {
+            if (err == NGX_ECONNREFUSED
+#if (NGX_LINUX)
+                /*
+                 * Linux returns EAGAIN instead of ECONNREFUSED
+                 * for unix sockets if listen queue is full
+                 */
+                || err == NGX_EAGAIN
+#endif
+                || err == NGX_ECONNRESET
+                || err == NGX_ENETDOWN
+                || err == NGX_ENETUNREACH
+                || err == NGX_EHOSTDOWN
+                || err == NGX_EHOSTUNREACH)
+            {
+                level = NGX_LOG_ERR;
+
+            } else {
+                level = NGX_LOG_CRIT;
+            }
+
+            ngx_log_error(level, c->log, err, "connect() to %V failed",
+                          &rec->server);
+
+            ngx_close_connection(c);
+            rec->tcp = NULL;
+
+            return NGX_ERROR;
+        }
+    }
+
+    if (ngx_add_conn) {
+        if (rc == -1) {
+
+            /* NGX_EINPROGRESS */
+
+            return NGX_AGAIN;
+        }
+
+        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, &rec->log, 0, "connected");
+
+        wev->ready = 1;
+
+        return NGX_OK;
+    }
+
+    if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
 
-        event = (ngx_event_flags & NGX_USE_CLEAR_EVENT) ?
-                    /* kqueue, epoll */                 NGX_CLEAR_EVENT:
-                    /* select, poll, /dev/poll */       NGX_LEVEL_EVENT;
-                    /* eventport event type has no meaning: oneshot only */
+        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, &rec->log, ngx_socket_errno,
+                       "connect(): %d", rc);
 
-        if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
+        if (ngx_blocking(s) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
+                          ngx_blocking_n " failed");
             goto failed;
         }
 
+        /*
+         * FreeBSD's aio allows to post an operation on non-connected socket.
+         * NT does not support it.
+         *
+         * TODO: check in Win32, etc. As workaround we can use NGX_ONESHOT_EVENT
+         */
+
+        rev->ready = 1;
+        wev->ready = 1;
+
+        return NGX_OK;
+    }
+
+    if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {
+
+        /* kqueue */
+
+        event = NGX_CLEAR_EVENT;
+
     } else {
-        /* rtsig */
 
-        if (ngx_add_conn(c) == NGX_ERROR) {
+        /* select, poll, /dev/poll */
+
+        event = NGX_LEVEL_EVENT;
+    }
+
+    if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
+        goto failed;
+    }
+
+    if (rc == -1) {
+
+        /* NGX_EINPROGRESS */
+
+        if (ngx_add_event(wev, NGX_WRITE_EVENT, event) != NGX_OK) {
             goto failed;
         }
+
+        return NGX_AGAIN;
     }
 
+    ngx_log_debug0(NGX_LOG_DEBUG_EVENT, &rec->log, 0, "connected");
+
+    wev->ready = 1;
+
     return NGX_OK;
 
 failed:
 
     ngx_close_connection(c);
-    uc->connection = NULL;
+    rec->tcp = NULL;
 
     return NGX_ERROR;
 }
+
+
+static ngx_int_t
+ngx_resolver_cmp_srvs(const void *one, const void *two)
+{
+    ngx_int_t            p1, p2;
+    ngx_resolver_srv_t  *first, *second;
+
+    first = (ngx_resolver_srv_t *) one;
+    second = (ngx_resolver_srv_t *) two;
+
+    p1 = first->priority;
+    p2 = second->priority;
+
+    return p1 - p2;
+}