nginxtra 1.8.1.12 → 1.10.1.12

data/vendor/nginx/src/http/{ngx_http_spdy_module.h → v2/ngx_http_v2_module.h}

@@ -5,8 +5,8 @@
  */
 
 
-#ifndef _NGX_HTTP_SPDY_MODULE_H_INCLUDED_
-#define _NGX_HTTP_SPDY_MODULE_H_INCLUDED_
+#ifndef _NGX_HTTP_V2_MODULE_H_INCLUDED_
+#define _NGX_HTTP_V2_MODULE_H_INCLUDED_
 
 
 #include <ngx_config.h>
@@ -17,25 +17,26 @@
 typedef struct {
     size_t                          recv_buffer_size;
     u_char                         *recv_buffer;
-} ngx_http_spdy_main_conf_t;
+} ngx_http_v2_main_conf_t;
 
 
 typedef struct {
     size_t                          pool_size;
     ngx_uint_t                      concurrent_streams;
+    size_t                          max_field_size;
+    size_t                          max_header_size;
     ngx_uint_t                      streams_index_mask;
     ngx_msec_t                      recv_timeout;
-    ngx_msec_t                      keepalive_timeout;
-    ngx_int_t                       headers_comp;
-} ngx_http_spdy_srv_conf_t;
+    ngx_msec_t                      idle_timeout;
+} ngx_http_v2_srv_conf_t;
 
 
 typedef struct {
     size_t                          chunk_size;
-} ngx_http_spdy_loc_conf_t;
+} ngx_http_v2_loc_conf_t;
 
 
-extern ngx_module_t  ngx_http_spdy_module;
+extern ngx_module_t  ngx_http_v2_module;
 
 
-#endif /* _NGX_HTTP_SPDY_MODULE_H_INCLUDED_ */
+#endif /* _NGX_HTTP_V2_MODULE_H_INCLUDED_ */

data/vendor/nginx/src/http/v2/ngx_http_v2_table.c

@@ -0,0 +1,349 @@
+
+/*
+ * Copyright (C) Nginx, Inc.
+ * Copyright (C) Valentin V. Bartenev
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_http.h>
+
+
+#define NGX_HTTP_V2_TABLE_SIZE  4096
+
+
+static ngx_int_t ngx_http_v2_table_account(ngx_http_v2_connection_t *h2c,
+    size_t size);
+
+
+static ngx_http_v2_header_t  ngx_http_v2_static_table[] = {
+    { ngx_string(":authority"), ngx_string("") },
+    { ngx_string(":method"), ngx_string("GET") },
+    { ngx_string(":method"), ngx_string("POST") },
+    { ngx_string(":path"), ngx_string("/") },
+    { ngx_string(":path"), ngx_string("/index.html") },
+    { ngx_string(":scheme"), ngx_string("http") },
+    { ngx_string(":scheme"), ngx_string("https") },
+    { ngx_string(":status"), ngx_string("200") },
+    { ngx_string(":status"), ngx_string("204") },
+    { ngx_string(":status"), ngx_string("206") },
+    { ngx_string(":status"), ngx_string("304") },
+    { ngx_string(":status"), ngx_string("400") },
+    { ngx_string(":status"), ngx_string("404") },
+    { ngx_string(":status"), ngx_string("500") },
+    { ngx_string("accept-charset"), ngx_string("") },
+    { ngx_string("accept-encoding"), ngx_string("gzip, deflate") },
+    { ngx_string("accept-language"), ngx_string("") },
+    { ngx_string("accept-ranges"), ngx_string("") },
+    { ngx_string("accept"), ngx_string("") },
+    { ngx_string("access-control-allow-origin"), ngx_string("") },
+    { ngx_string("age"), ngx_string("") },
+    { ngx_string("allow"), ngx_string("") },
+    { ngx_string("authorization"), ngx_string("") },
+    { ngx_string("cache-control"), ngx_string("") },
+    { ngx_string("content-disposition"), ngx_string("") },
+    { ngx_string("content-encoding"), ngx_string("") },
+    { ngx_string("content-language"), ngx_string("") },
+    { ngx_string("content-length"), ngx_string("") },
+    { ngx_string("content-location"), ngx_string("") },
+    { ngx_string("content-range"), ngx_string("") },
+    { ngx_string("content-type"), ngx_string("") },
+    { ngx_string("cookie"), ngx_string("") },
+    { ngx_string("date"), ngx_string("") },
+    { ngx_string("etag"), ngx_string("") },
+    { ngx_string("expect"), ngx_string("") },
+    { ngx_string("expires"), ngx_string("") },
+    { ngx_string("from"), ngx_string("") },
+    { ngx_string("host"), ngx_string("") },
+    { ngx_string("if-match"), ngx_string("") },
+    { ngx_string("if-modified-since"), ngx_string("") },
+    { ngx_string("if-none-match"), ngx_string("") },
+    { ngx_string("if-range"), ngx_string("") },
+    { ngx_string("if-unmodified-since"), ngx_string("") },
+    { ngx_string("last-modified"), ngx_string("") },
+    { ngx_string("link"), ngx_string("") },
+    { ngx_string("location"), ngx_string("") },
+    { ngx_string("max-forwards"), ngx_string("") },
+    { ngx_string("proxy-authenticate"), ngx_string("") },
+    { ngx_string("proxy-authorization"), ngx_string("") },
+    { ngx_string("range"), ngx_string("") },
+    { ngx_string("referer"), ngx_string("") },
+    { ngx_string("refresh"), ngx_string("") },
+    { ngx_string("retry-after"), ngx_string("") },
+    { ngx_string("server"), ngx_string("") },
+    { ngx_string("set-cookie"), ngx_string("") },
+    { ngx_string("strict-transport-security"), ngx_string("") },
+    { ngx_string("transfer-encoding"), ngx_string("") },
+    { ngx_string("user-agent"), ngx_string("") },
+    { ngx_string("vary"), ngx_string("") },
+    { ngx_string("via"), ngx_string("") },
+    { ngx_string("www-authenticate"), ngx_string("") },
+};
+
+#define NGX_HTTP_V2_STATIC_TABLE_ENTRIES                                      \
+    (sizeof(ngx_http_v2_static_table)                                         \
+     / sizeof(ngx_http_v2_header_t))
+
+
+ngx_int_t
+ngx_http_v2_get_indexed_header(ngx_http_v2_connection_t *h2c, ngx_uint_t index,
+    ngx_uint_t name_only)
+{
+    u_char                *p;
+    size_t                 rest;
+    ngx_http_v2_header_t  *entry;
+
+    if (index == 0) {
+        ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
+                      "client sent invalid hpack table index 0");
+        return NGX_ERROR;
+    }
+
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
+                   "http2 get indexed %s: %ui",
+                   name_only ? "header" : "header name", index);
+
+    index--;
+
+    if (index < NGX_HTTP_V2_STATIC_TABLE_ENTRIES) {
+        h2c->state.header = ngx_http_v2_static_table[index];
+        return NGX_OK;
+    }
+
+    index -= NGX_HTTP_V2_STATIC_TABLE_ENTRIES;
+
+    if (index < h2c->hpack.added - h2c->hpack.deleted) {
+        index = (h2c->hpack.added - index - 1) % h2c->hpack.allocated;
+        entry = h2c->hpack.entries[index];
+
+        p = ngx_pnalloc(h2c->state.pool, entry->name.len + 1);
+        if (p == NULL) {
+            return NGX_ERROR;
+        }
+
+        h2c->state.header.name.len = entry->name.len;
+        h2c->state.header.name.data = p;
+
+        rest = h2c->hpack.storage + NGX_HTTP_V2_TABLE_SIZE - entry->name.data;
+
+        if (entry->name.len > rest) {
+            p = ngx_cpymem(p, entry->name.data, rest);
+            p = ngx_cpymem(p, h2c->hpack.storage, entry->name.len - rest);
+
+        } else {
+            p = ngx_cpymem(p, entry->name.data, entry->name.len);
+        }
+
+        *p = '\0';
+
+        if (name_only) {
+            return NGX_OK;
+        }
+
+        p = ngx_pnalloc(h2c->state.pool, entry->value.len + 1);
+        if (p == NULL) {
+            return NGX_ERROR;
+        }
+
+        h2c->state.header.value.len = entry->value.len;
+        h2c->state.header.value.data = p;
+
+        rest = h2c->hpack.storage + NGX_HTTP_V2_TABLE_SIZE - entry->value.data;
+
+        if (entry->value.len > rest) {
+            p = ngx_cpymem(p, entry->value.data, rest);
+            p = ngx_cpymem(p, h2c->hpack.storage, entry->value.len - rest);
+
+        } else {
+            p = ngx_cpymem(p, entry->value.data, entry->value.len);
+        }
+
+        *p = '\0';
+
+        return NGX_OK;
+    }
+
+    ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
+                  "client sent out of bound hpack table index: %ui", index);
+
+    return NGX_ERROR;
+}
+
+
+ngx_int_t
+ngx_http_v2_add_header(ngx_http_v2_connection_t *h2c,
+    ngx_http_v2_header_t *header)
+{
+    size_t                 avail;
+    ngx_uint_t             index;
+    ngx_http_v2_header_t  *entry, **entries;
+
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
+                   "http2 add header to hpack table: \"%V: %V\"",
+                   &header->name, &header->value);
+
+    if (h2c->hpack.entries == NULL) {
+        h2c->hpack.allocated = 64;
+        h2c->hpack.size = NGX_HTTP_V2_TABLE_SIZE;
+        h2c->hpack.free = NGX_HTTP_V2_TABLE_SIZE;
+
+        h2c->hpack.entries = ngx_palloc(h2c->connection->pool,
+                                        sizeof(ngx_http_v2_header_t *)
+                                        * h2c->hpack.allocated);
+        if (h2c->hpack.entries == NULL) {
+            return NGX_ERROR;
+        }
+
+        h2c->hpack.storage = ngx_palloc(h2c->connection->pool,
+                                        h2c->hpack.free);
+        if (h2c->hpack.storage == NULL) {
+            return NGX_ERROR;
+        }
+
+        h2c->hpack.pos = h2c->hpack.storage;
+    }
+
+    if (ngx_http_v2_table_account(h2c, header->name.len + header->value.len)
+        != NGX_OK)
+    {
+        return NGX_OK;
+    }
+
+    if (h2c->hpack.reused == h2c->hpack.deleted) {
+        entry = ngx_palloc(h2c->connection->pool, sizeof(ngx_http_v2_header_t));
+        if (entry == NULL) {
+            return NGX_ERROR;
+        }
+
+    } else {
+        entry = h2c->hpack.entries[h2c->hpack.reused++ % h2c->hpack.allocated];
+    }
+
+    avail = h2c->hpack.storage + NGX_HTTP_V2_TABLE_SIZE - h2c->hpack.pos;
+
+    entry->name.len = header->name.len;
+    entry->name.data = h2c->hpack.pos;
+
+    if (avail >= header->name.len) {
+        h2c->hpack.pos = ngx_cpymem(h2c->hpack.pos, header->name.data,
+                                    header->name.len);
+    } else {
+        ngx_memcpy(h2c->hpack.pos, header->name.data, avail);
+        h2c->hpack.pos = ngx_cpymem(h2c->hpack.storage,
+                                    header->name.data + avail,
+                                    header->name.len - avail);
+        avail = NGX_HTTP_V2_TABLE_SIZE;
+    }
+
+    avail -= header->name.len;
+
+    entry->value.len = header->value.len;
+    entry->value.data = h2c->hpack.pos;
+
+    if (avail >= header->value.len) {
+        h2c->hpack.pos = ngx_cpymem(h2c->hpack.pos, header->value.data,
+                                    header->value.len);
+    } else {
+        ngx_memcpy(h2c->hpack.pos, header->value.data, avail);
+        h2c->hpack.pos = ngx_cpymem(h2c->hpack.storage,
+                                    header->value.data + avail,
+                                    header->value.len - avail);
+    }
+
+    if (h2c->hpack.allocated == h2c->hpack.added - h2c->hpack.deleted) {
+
+        entries = ngx_palloc(h2c->connection->pool,
+                             sizeof(ngx_http_v2_header_t *)
+                             * (h2c->hpack.allocated + 64));
+        if (entries == NULL) {
+            return NGX_ERROR;
+        }
+
+        index = h2c->hpack.deleted % h2c->hpack.allocated;
+
+        ngx_memcpy(entries, &h2c->hpack.entries[index],
+                   (h2c->hpack.allocated - index)
+                   * sizeof(ngx_http_v2_header_t *));
+
+        ngx_memcpy(&entries[h2c->hpack.allocated - index], h2c->hpack.entries,
+                   index * sizeof(ngx_http_v2_header_t *));
+
+        (void) ngx_pfree(h2c->connection->pool, h2c->hpack.entries);
+
+        h2c->hpack.entries = entries;
+
+        h2c->hpack.added = h2c->hpack.allocated;
+        h2c->hpack.deleted = 0;
+        h2c->hpack.reused = 0;
+        h2c->hpack.allocated += 64;
+    }
+
+    h2c->hpack.entries[h2c->hpack.added++ % h2c->hpack.allocated] = entry;
+
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_http_v2_table_account(ngx_http_v2_connection_t *h2c, size_t size)
+{
+    ngx_http_v2_header_t  *entry;
+
+    size += 32;
+
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
+                   "http2 hpack table account: %uz free:%uz",
+                   size, h2c->hpack.free);
+
+    if (size <= h2c->hpack.free) {
+        h2c->hpack.free -= size;
+        return NGX_OK;
+    }
+
+    if (size > h2c->hpack.size) {
+        h2c->hpack.deleted = h2c->hpack.added;
+        h2c->hpack.free = h2c->hpack.size;
+        return NGX_DECLINED;
+    }
+
+    do {
+        entry = h2c->hpack.entries[h2c->hpack.deleted++ % h2c->hpack.allocated];
+        h2c->hpack.free += 32 + entry->name.len + entry->value.len;
+    } while (size > h2c->hpack.free);
+
+    h2c->hpack.free -= size;
+
+    return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_http_v2_table_size(ngx_http_v2_connection_t *h2c, size_t size)
+{
+    ssize_t                needed;
+    ngx_http_v2_header_t  *entry;
+
+    if (size > NGX_HTTP_V2_TABLE_SIZE) {
+        ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
+                      "client sent invalid table size update: %uz", size);
+
+        return NGX_ERROR;
+    }
+
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
+                   "http2 new hpack table size: %uz was:%uz",
+                   size, h2c->hpack.size);
+
+    needed = h2c->hpack.size - size;
+
+    while (needed > (ssize_t) h2c->hpack.free) {
+        entry = h2c->hpack.entries[h2c->hpack.deleted++ % h2c->hpack.allocated];
+        h2c->hpack.free += 32 + entry->name.len + entry->value.len;
+    }
+
+    h2c->hpack.size = size;
+    h2c->hpack.free -= needed;
+
+    return NGX_OK;
+}

data/vendor/nginx/src/mail/ngx_mail.c

@@ -36,13 +36,6 @@ static ngx_command_t  ngx_mail_commands[] = {
       0,
       NULL },
 
-    { ngx_string("imap"),
-      NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
-      ngx_mail_block,
-      0,
-      0,
-      NULL },
-
       ngx_null_command
 };
 
@@ -83,10 +76,8 @@ ngx_mail_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
     ngx_mail_core_srv_conf_t   **cscfp;
     ngx_mail_core_main_conf_t   *cmcf;
 
-    if (cmd->name.data[0] == 'i') {
-        ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
-                           "the \"imap\" directive is deprecated, "
-                           "use the \"mail\" directive instead");
+    if (*(ngx_mail_conf_ctx_t **) conf) {
+        return "is duplicate";
     }
 
     /* the main mail context */
@@ -100,14 +91,7 @@ ngx_mail_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     /* count the number of the mail modules and set up their indices */
 
-    ngx_mail_max_module = 0;
-    for (m = 0; ngx_modules[m]; m++) {
-        if (ngx_modules[m]->type != NGX_MAIL_MODULE) {
-            continue;
-        }
-
-        ngx_modules[m]->ctx_index = ngx_mail_max_module++;
-    }
+    ngx_mail_max_module = ngx_count_modules(cf->cycle, NGX_MAIL_MODULE);
 
 
     /* the mail main_conf context, it is the same in the all mail contexts */
@@ -134,13 +118,13 @@ ngx_mail_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
      * create the main_conf's and the null srv_conf's of the all mail modules
      */
 
-    for (m = 0; ngx_modules[m]; m++) {
-        if (ngx_modules[m]->type != NGX_MAIL_MODULE) {
+    for (m = 0; cf->cycle->modules[m]; m++) {
+        if (cf->cycle->modules[m]->type != NGX_MAIL_MODULE) {
             continue;
         }
 
-        module = ngx_modules[m]->ctx;
-        mi = ngx_modules[m]->ctx_index;
+        module = cf->cycle->modules[m]->ctx;
+        mi = cf->cycle->modules[m]->ctx_index;
 
         if (module->create_main_conf) {
             ctx->main_conf[mi] = module->create_main_conf(cf);
@@ -178,13 +162,13 @@ ngx_mail_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
     cmcf = ctx->main_conf[ngx_mail_core_module.ctx_index];
     cscfp = cmcf->servers.elts;
 
-    for (m = 0; ngx_modules[m]; m++) {
-        if (ngx_modules[m]->type != NGX_MAIL_MODULE) {
+    for (m = 0; cf->cycle->modules[m]; m++) {
+        if (cf->cycle->modules[m]->type != NGX_MAIL_MODULE) {
             continue;
         }
 
-        module = ngx_modules[m]->ctx;
-        mi = ngx_modules[m]->ctx_index;
+        module = cf->cycle->modules[m]->ctx;
+        mi = cf->cycle->modules[m]->ctx_index;
 
         /* init mail{} main_conf's */
 
@@ -251,13 +235,13 @@ ngx_mail_add_ports(ngx_conf_t *cf, ngx_array_t *ports,
     struct sockaddr_in6   *sin6;
 #endif
 
-    sa = (struct sockaddr *) &listen->sockaddr;
+    sa = &listen->u.sockaddr;
 
     switch (sa->sa_family) {
 
 #if (NGX_HAVE_INET6)
     case AF_INET6:
-        sin6 = (struct sockaddr_in6 *) sa;
+        sin6 = &listen->u.sockaddr_in6;
         p = sin6->sin6_port;
         break;
 #endif
@@ -269,7 +253,7 @@ ngx_mail_add_ports(ngx_conf_t *cf, ngx_array_t *ports,
 #endif
 
     default: /* AF_INET */
-        sin = (struct sockaddr_in *) sa;
+        sin = &listen->u.sockaddr_in;
         p = sin->sin_port;
         break;
     }
@@ -309,23 +293,7 @@ found:
         return NGX_ERROR;
     }
 
-    addr->sockaddr = (struct sockaddr *) &listen->sockaddr;
-    addr->socklen = listen->socklen;
-    addr->ctx = listen->ctx;
-    addr->bind = listen->bind;
-    addr->wildcard = listen->wildcard;
-    addr->so_keepalive = listen->so_keepalive;
-#if (NGX_HAVE_KEEPALIVE_TUNABLE)
-    addr->tcp_keepidle = listen->tcp_keepidle;
-    addr->tcp_keepintvl = listen->tcp_keepintvl;
-    addr->tcp_keepcnt = listen->tcp_keepcnt;
-#endif
-#if (NGX_MAIL_SSL)
-    addr->ssl = listen->ssl;
-#endif
-#if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
-    addr->ipv6only = listen->ipv6only;
-#endif
+    addr->opt = *listen;
 
     return NGX_OK;
 }
@@ -334,11 +302,12 @@ found:
 static char *
 ngx_mail_optimize_servers(ngx_conf_t *cf, ngx_array_t *ports)
 {
-    ngx_uint_t             i, p, last, bind_wildcard;
-    ngx_listening_t       *ls;
-    ngx_mail_port_t       *mport;
-    ngx_mail_conf_port_t  *port;
-    ngx_mail_conf_addr_t  *addr;
+    ngx_uint_t                 i, p, last, bind_wildcard;
+    ngx_listening_t           *ls;
+    ngx_mail_port_t           *mport;
+    ngx_mail_conf_port_t      *port;
+    ngx_mail_conf_addr_t      *addr;
+    ngx_mail_core_srv_conf_t  *cscf;
 
     port = ports->elts;
     for (p = 0; p < ports->nelts; p++) {
@@ -354,8 +323,8 @@ ngx_mail_optimize_servers(ngx_conf_t *cf, ngx_array_t *ports)
          * to the "*:port" only and ignore the other bindings
          */
 
-        if (addr[last - 1].wildcard) {
-            addr[last - 1].bind = 1;
+        if (addr[last - 1].opt.wildcard) {
+            addr[last - 1].opt.bind = 1;
             bind_wildcard = 1;
 
         } else {
@@ -366,12 +335,13 @@ ngx_mail_optimize_servers(ngx_conf_t *cf, ngx_array_t *ports)
 
         while (i < last) {
 
-            if (bind_wildcard && !addr[i].bind) {
+            if (bind_wildcard && !addr[i].opt.bind) {
                 i++;
                 continue;
             }
 
-            ls = ngx_create_listening(cf, addr[i].sockaddr, addr[i].socklen);
+            ls = ngx_create_listening(cf, &addr[i].opt.u.sockaddr,
+                                      addr[i].opt.socklen);
             if (ls == NULL) {
                 return NGX_CONF_ERROR;
             }
@@ -380,20 +350,23 @@ ngx_mail_optimize_servers(ngx_conf_t *cf, ngx_array_t *ports)
             ls->handler = ngx_mail_init_connection;
             ls->pool_size = 256;
 
-            /* TODO: error_log directive */
-            ls->logp = &cf->cycle->new_log;
+            cscf = addr->opt.ctx->srv_conf[ngx_mail_core_module.ctx_index];
+
+            ls->logp = cscf->error_log;
             ls->log.data = &ls->addr_text;
             ls->log.handler = ngx_accept_log_error;
 
-            ls->keepalive = addr[i].so_keepalive;
+            ls->backlog = addr[i].opt.backlog;
+
+            ls->keepalive = addr[i].opt.so_keepalive;
 #if (NGX_HAVE_KEEPALIVE_TUNABLE)
-            ls->keepidle = addr[i].tcp_keepidle;
-            ls->keepintvl = addr[i].tcp_keepintvl;
-            ls->keepcnt = addr[i].tcp_keepcnt;
+            ls->keepidle = addr[i].opt.tcp_keepidle;
+            ls->keepintvl = addr[i].opt.tcp_keepintvl;
+            ls->keepcnt = addr[i].opt.tcp_keepcnt;
 #endif
 
 #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
-            ls->ipv6only = addr[i].ipv6only;
+            ls->ipv6only = addr[i].opt.ipv6only;
 #endif
 
             mport = ngx_palloc(cf->pool, sizeof(ngx_mail_port_t));
@@ -403,13 +376,7 @@ ngx_mail_optimize_servers(ngx_conf_t *cf, ngx_array_t *ports)
 
             ls->servers = mport;
 
-            if (i == last - 1) {
-                mport->naddrs = last;
-
-            } else {
-                mport->naddrs = 1;
-                i = 0;
-            }
+            mport->naddrs = i + 1;
 
             switch (ls->sockaddr->sa_family) {
 #if (NGX_HAVE_INET6)
@@ -456,15 +423,15 @@ ngx_mail_add_addrs(ngx_conf_t *cf, ngx_mail_port_t *mport,
 
     for (i = 0; i < mport->naddrs; i++) {
 
-        sin = (struct sockaddr_in *) addr[i].sockaddr;
+        sin = &addr[i].opt.u.sockaddr_in;
         addrs[i].addr = sin->sin_addr.s_addr;
 
-        addrs[i].conf.ctx = addr[i].ctx;
+        addrs[i].conf.ctx = addr[i].opt.ctx;
 #if (NGX_MAIL_SSL)
-        addrs[i].conf.ssl = addr[i].ssl;
+        addrs[i].conf.ssl = addr[i].opt.ssl;
 #endif
 
-        len = ngx_sock_ntop(addr[i].sockaddr, addr[i].socklen, buf,
+        len = ngx_sock_ntop(&addr[i].opt.u.sockaddr, addr[i].opt.socklen, buf,
                             NGX_SOCKADDR_STRLEN, 1);
 
         p = ngx_pnalloc(cf->pool, len);
@@ -505,15 +472,15 @@ ngx_mail_add_addrs6(ngx_conf_t *cf, ngx_mail_port_t *mport,
 
     for (i = 0; i < mport->naddrs; i++) {
 
-        sin6 = (struct sockaddr_in6 *) addr[i].sockaddr;
+        sin6 = &addr[i].opt.u.sockaddr_in6;
         addrs6[i].addr6 = sin6->sin6_addr;
 
-        addrs6[i].conf.ctx = addr[i].ctx;
+        addrs6[i].conf.ctx = addr[i].opt.ctx;
 #if (NGX_MAIL_SSL)
-        addrs6[i].conf.ssl = addr[i].ssl;
+        addrs6[i].conf.ssl = addr[i].opt.ssl;
 #endif
 
-        len = ngx_sock_ntop(addr[i].sockaddr, addr[i].socklen, buf,
+        len = ngx_sock_ntop(&addr[i].opt.u.sockaddr, addr[i].opt.socklen, buf,
                             NGX_SOCKADDR_STRLEN, 1);
 
         p = ngx_pnalloc(cf->pool, len);
@@ -541,22 +508,22 @@ ngx_mail_cmp_conf_addrs(const void *one, const void *two)
     first = (ngx_mail_conf_addr_t *) one;
     second = (ngx_mail_conf_addr_t *) two;
 
-    if (first->wildcard) {
+    if (first->opt.wildcard) {
         /* a wildcard must be the last resort, shift it to the end */
         return 1;
     }
 
-    if (second->wildcard) {
+    if (second->opt.wildcard) {
         /* a wildcard must be the last resort, shift it to the end */
         return -1;
     }
 
-    if (first->bind && !second->bind) {
+    if (first->opt.bind && !second->opt.bind) {
         /* shift explicit bind()ed addresses to the start */
         return -1;
     }
 
-    if (!first->bind && second->bind) {
+    if (!first->opt.bind && second->opt.bind) {
         /* shift explicit bind()ed addresses to the start */
         return 1;
     }