One Level Up Top Level

src/core/ngx_inet.c - nginx-1.7.10

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>


  12. static ngx_int_t ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u);
  13. static ngx_int_t ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u);
  14. static ngx_int_t ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u);


  17. in_addr_t
  18. ‌ngx_inet_addr(u_char *text, size_t len)
  19. {
  20.     u_char      *p, c;
  21.     in_addr_t    addr;
  22.     ngx_uint_t   octet, n;

  24.     addr = 0;
  25.     octet = 0;
  26.     n = 0;

  28.     for (p = text; p < text + len; p++) {

  30.         c = *p;

  32.         if (c >= '0' && c <= '9') {
  33.             octet = octet * 10 + (c - '0');
  34.             continue;
  35.         }

  37.         if (c == '.' && octet < 256) {
  38.             addr = (addr << 8) + octet;
  39.             octet = 0;
  40.             n++;
  41.             continue;
  42.         }

  44.         return INADDR_NONE;
  45.     }

  47.     if (n == 3 && octet < 256) {
  48.         addr = (addr << 8) + octet;
  49.         return htonl(addr);
  50.     }

  52.     return INADDR_NONE;
  53. }


  56. #if (NGX_HAVE_INET6)

  58. ngx_int_t
  59. ‌ngx_inet6_addr(u_char *p, size_t len, u_char *addr)
  60. {
  61.     u_char      c, *zero, *digit, *s, *d;
  62.     size_t      len4;
  63.     ngx_uint_t  n, nibbles, word;

  65.     if (len == 0) {
  66.         return NGX_ERROR;
  67.     }

  69.     zero = NULL;
  70.     digit = NULL;
  71.     len4 = 0;
  72.     nibbles = 0;
  73.     word = 0;
  74.     n = 8;

  76.     if (p[0] == ':') {
  77.         p++;
  78.         len--;
  79.     }

  81.     for (/* void */; len; len--) {
  82.         c = *p++;

  84.         if (c == ':') {
  85.             if (nibbles) {
  86.                 digit = p;
  87.                 len4 = len;
  88.                 *addr++ = (u_char) (word >> 8);
  89.                 *addr++ = (u_char) (word & 0xff);

  91.                 if (--n) {
  92.                     nibbles = 0;
  93.                     word = 0;
  94.                     continue;
  95.                 }

  97.             } else {
  98.                 if (zero == NULL) {
  99.                     digit = p;
  100.                     len4 = len;
  101.                     zero = addr;
  102.                     continue;
  103.                 }
  104.             }

  106.             return NGX_ERROR;
  107.         }

  109.         if (c == '.' && nibbles) {
  110.             if (n < 2 || digit == NULL) {
  111.                 return NGX_ERROR;
  112.             }

  114.             word = ngx_inet_addr(digit, len4 - 1);
  115.             if (word == INADDR_NONE) {
  116.                 return NGX_ERROR;
  117.             }

  119.             word = ntohl(word);
  120.             *addr++ = (u_char) ((word >> 24) & 0xff);
  121.             *addr++ = (u_char) ((word >> 16) & 0xff);
  122.             n--;
  123.             break;
  124.         }

  126.         if (++nibbles > 4) {
  127.             return NGX_ERROR;
  128.         }

  130.         if (c >= '0' && c <= '9') {
  131.             word = word * 16 + (c - '0');
  132.             continue;
  133.         }

  135.         c |= 0x20;

  137.         if (c >= 'a' && c <= 'f') {
  138.             word = word * 16 + (c - 'a') + 10;
  139.             continue;
  140.         }

  142.         return NGX_ERROR;
  143.     }

  145.     if (nibbles == 0 && zero == NULL) {
  146.         return NGX_ERROR;
  147.     }

  149.     *addr++ = (u_char) (word >> 8);
  150.     *addr++ = (u_char) (word & 0xff);

  152.     if (--n) {
  153.         if (zero) {
  154.             n *= 2;
  155.             s = addr - 1;
  156.             d = s + n;
  157.             while (s >= zero) {
  158.                 *d-- = *s--;
  159.             }
  160.             ngx_memzero(zero, n);
  161.             return NGX_OK;
  162.         }

  164.     } else {
  165.         if (zero == NULL) {
  166.             return NGX_OK;
  167.         }
  168.     }

  170.     return NGX_ERROR;
  171. }

  173. #endif


  176. size_t
  177. ‌ngx_sock_ntop(struct sockaddr *sa, socklen_t socklen, u_char *text, size_t len,
  178.     ngx_uint_t port)
  179. {
  180.     u_char               *p;
  181.     struct sockaddr_in   *sin;
  182. #if (NGX_HAVE_INET6)
  183.     size_t                n;
  184.     struct sockaddr_in6  *sin6;
  185. #endif
  186. #if (NGX_HAVE_UNIX_DOMAIN)
  187.     struct sockaddr_un   *saun;
  188. #endif

  190.     switch (sa->sa_family) {

  192.     case AF_INET:

  194.         sin = (struct sockaddr_in *) sa;
  195.         p = (u_char *) &sin->sin_addr;

  197.         if (port) {
  198.             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud:%d",
  199.                              p[0], p[1], p[2], p[3], ntohs(sin->sin_port));
  200.         } else {
  201.             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
  202.                              p[0], p[1], p[2], p[3]);
  203.         }

  205.         return (p - text);

  207. #if (NGX_HAVE_INET6)

  209.     case AF_INET6:

  211.         sin6 = (struct sockaddr_in6 *) sa;

  213.         n = 0;

  215.         if (port) {
  216.             text[n++] = '[';
  217.         }

  219.         n = ngx_inet6_ntop(sin6->sin6_addr.s6_addr, &text[n], len);

  221.         if (port) {
  222.             n = ngx_sprintf(&text[1 + n], "]:%d",
  223.                             ntohs(sin6->sin6_port)) - text;
  224.         }

  226.         return n;
  227. #endif

  229. #if (NGX_HAVE_UNIX_DOMAIN)

  231.     case AF_UNIX:
  232.         saun = (struct sockaddr_un *) sa;

  234.         /* on Linux sockaddr might not include sun_path at all */

  236.         if (socklen <= (socklen_t) offsetof(struct sockaddr_un, sun_path)) {
  237.             p = ngx_snprintf(text, len, "unix:%Z");

  239.         } else {
  240.             p = ngx_snprintf(text, len, "unix:%s%Z", saun->sun_path);
  241.         }

  243.         /* we do not include trailing zero in address length */

  245.         return (p - text - 1);

  247. #endif

  249.     default:
  250.         return 0;
  251.     }
  252. }


  255. size_t
  256. ‌ngx_inet_ntop(int family, void *addr, u_char *text, size_t len)
  257. {
  258.     u_char  *p;

  260.     switch (family) {

  262.     case AF_INET:

  264.         p = addr;

  266.         return ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
  267.                             p[0], p[1], p[2], p[3])
  268.                - text;

  270. #if (NGX_HAVE_INET6)

  272.     case AF_INET6:
  273.         return ngx_inet6_ntop(addr, text, len);

  275. #endif

  277.     default:
  278.         return 0;
  279.     }
  280. }


  283. #if (NGX_HAVE_INET6)

  285. size_t
  286. ‌ngx_inet6_ntop(u_char *p, u_char *text, size_t len)
  287. {
  288.     u_char      *dst;
  289.     size_t       max, n;
  290.     ngx_uint_t   i, zero, last;

  292.     if (len < NGX_INET6_ADDRSTRLEN) {
  293.         return 0;
  294.     }

  296.     zero = (ngx_uint_t) -1;
  297.     last = (ngx_uint_t) -1;
  298.     max = 1;
  299.     n = 0;

  301.     for (i = 0; i < 16; i += 2) {

  303.         if (p[i] || p[i + 1]) {

  305.             if (max < n) {
  306.                 zero = last;
  307.                 max = n;
  308.             }

  310.             n = 0;
  311.             continue;
  312.         }

  314.         if (n++ == 0) {
  315.             last = i;
  316.         }
  317.     }

  319.     if (max < n) {
  320.         zero = last;
  321.         max = n;
  322.     }

  324.     dst = text;
  325.     n = 16;

  327.     if (zero == 0) {

  329.         if ((max == 5 && p[10] == 0xff && p[11] == 0xff)
  330.             || (max == 6)
  331.             || (max == 7 && p[14] != 0 && p[15] != 1))
  332.         {
  333.             n = 12;
  334.         }

  336.         *dst++ = ':';
  337.     }

  339.     for (i = 0; i < n; i += 2) {

  341.         if (i == zero) {
  342.             *dst++ = ':';
  343.             i += (max - 1) * 2;
  344.             continue;
  345.         }

  347.         dst = ngx_sprintf(dst, "%uxi", p[i] * 256 + p[i + 1]);

  349.         if (i < 14) {
  350.             *dst++ = ':';
  351.         }
  352.     }

  354.     if (n == 12) {
  355.         dst = ngx_sprintf(dst, "%ud.%ud.%ud.%ud", p[12], p[13], p[14], p[15]);
  356.     }

  358.     return dst - text;
  359. }

  361. #endif


  364. ngx_int_t
  365. ‌ngx_ptocidr(ngx_str_t *text, ngx_cidr_t *cidr)
  366. {
  367.     u_char      *addr, *mask, *last;
  368.     size_t       len;
  369.     ngx_int_t    shift;
  370. #if (NGX_HAVE_INET6)
  371.     ngx_int_t    rc;
  372.     ngx_uint_t   s, i;
  373. #endif

  375.     addr = text->data;
  376.     last = addr + text->len;

  378.     mask = ngx_strlchr(addr, last, '/');
  379.     len = (mask ? mask : last) - addr;

  381.     cidr->u.in.addr = ngx_inet_addr(addr, len);

  383.     if (cidr->u.in.addr != INADDR_NONE) {
  384.         cidr->family = AF_INET;

  386.         if (mask == NULL) {
  387.             cidr->u.in.mask = 0xffffffff;
  388.             return NGX_OK;
  389.         }

  391. #if (NGX_HAVE_INET6)
  392.     } else if (ngx_inet6_addr(addr, len, cidr->u.in6.addr.s6_addr) == NGX_OK) {
  393.         cidr->family = AF_INET6;

  395.         if (mask == NULL) {
  396.             ngx_memset(cidr->u.in6.mask.s6_addr, 0xff, 16);
  397.             return NGX_OK;
  398.         }

  400. #endif
  401.     } else {
  402.         return NGX_ERROR;
  403.     }

  405.     mask++;

  407.     shift = ngx_atoi(mask, last - mask);
  408.     if (shift == NGX_ERROR) {
  409.         return NGX_ERROR;
  410.     }

  412.     switch (cidr->family) {

  414. #if (NGX_HAVE_INET6)
  415.     case AF_INET6:
  416.         if (shift > 128) {
  417.             return NGX_ERROR;
  418.         }

  420.         addr = cidr->u.in6.addr.s6_addr;
  421.         mask = cidr->u.in6.mask.s6_addr;
  422.         rc = NGX_OK;

  424.         for (i = 0; i < 16; i++) {

  426.             s = (shift > 8) ? 8 : shift;
  427.             shift -= s;

  429.             mask[i] = (u_char) (0xffu << (8 - s));

  431.             if (addr[i] != (addr[i] & mask[i])) {
  432.                 rc = NGX_DONE;
  433.                 addr[i] &= mask[i];
  434.             }
  435.         }

  437.         return rc;
  438. #endif

  440.     default: /* AF_INET */
  441.         if (shift > 32) {
  442.             return NGX_ERROR;
  443.         }

  445.         if (shift) {
  446.             cidr->u.in.mask = htonl((uint32_t) (0xffffffffu << (32 - shift)));

  448.         } else {
  449.             /* x86 compilers use a shl instruction that shifts by modulo 32 */
  450.             cidr->u.in.mask = 0;
  451.         }

  453.         if (cidr->u.in.addr == (cidr->u.in.addr & cidr->u.in.mask)) {
  454.             return NGX_OK;
  455.         }

  457.         cidr->u.in.addr &= cidr->u.in.mask;

  459.         return NGX_DONE;
  460.     }
  461. }


  464. ngx_int_t
  465. ‌ngx_parse_addr(ngx_pool_t *pool, ngx_addr_t *addr, u_char *text, size_t len)
  466. {
  467.     in_addr_t             inaddr;
  468.     ngx_uint_t            family;
  469.     struct sockaddr_in   *sin;
  470. #if (NGX_HAVE_INET6)
  471.     struct in6_addr       inaddr6;
  472.     struct sockaddr_in6  *sin6;

  474.     /*
  475.      * prevent MSVC8 warning:
  476.      *    potentially uninitialized local variable 'inaddr6' used
  477.      */
  478.     ngx_memzero(&inaddr6, sizeof(struct in6_addr));
  479. #endif

  481.     inaddr = ngx_inet_addr(text, len);

  483.     if (inaddr != INADDR_NONE) {
  484.         family = AF_INET;
  485.         len = sizeof(struct sockaddr_in);

  487. #if (NGX_HAVE_INET6)
  488.     } else if (ngx_inet6_addr(text, len, inaddr6.s6_addr) == NGX_OK) {
  489.         family = AF_INET6;
  490.         len = sizeof(struct sockaddr_in6);

  492. #endif
  493.     } else {
  494.         return NGX_DECLINED;
  495.     }

  497.     addr->sockaddr = ngx_pcalloc(pool, len);
  498.     if (addr->sockaddr == NULL) {
  499.         return NGX_ERROR;
  500.     }

  502.     addr->sockaddr->sa_family = (u_char) family;
  503.     addr->socklen = len;

  505.     switch (family) {

  507. #if (NGX_HAVE_INET6)
  508.     case AF_INET6:
  509.         sin6 = (struct sockaddr_in6 *) addr->sockaddr;
  510.         ngx_memcpy(sin6->sin6_addr.s6_addr, inaddr6.s6_addr, 16);
  511.         break;
  512. #endif

  514.     default: /* AF_INET */
  515.         sin = (struct sockaddr_in *) addr->sockaddr;
  516.         sin->sin_addr.s_addr = inaddr;
  517.         break;
  518.     }

  520.     return NGX_OK;
  521. }


  524. ngx_int_t
  525. ‌ngx_parse_url(ngx_pool_t *pool, ngx_url_t *u)
  526. {
  527.     u_char  *p;

  529.     p = u->url.data;

  531.     if (ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0) {
  532.         return ngx_parse_unix_domain_url(pool, u);
  533.     }

  535.     if (p[0] == '[') {
  536.         return ngx_parse_inet6_url(pool, u);
  537.     }

  539.     return ngx_parse_inet_url(pool, u);
  540. }


  543. static ngx_int_t
  544. ‌ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u)
  545. {
  546. #if (NGX_HAVE_UNIX_DOMAIN)
  547.     u_char              *path, *uri, *last;
  548.     size_t               len;
  549.     struct sockaddr_un  *saun;

  551.     len = u->url.len;
  552.     path = u->url.data;

  554.     path += 5;
  555.     len -= 5;

  557.     if (u->uri_part) {

  559.         last = path + len;
  560.         uri = ngx_strlchr(path, last, ':');

  562.         if (uri) {
  563.             len = uri - path;
  564.             uri++;
  565.             u->uri.len = last - uri;
  566.             u->uri.data = uri;
  567.         }
  568.     }

  570.     if (len == 0) {
  571.         u->err = "no path in the unix domain socket";
  572.         return NGX_ERROR;
  573.     }

  575.     u->host.len = len++;
  576.     u->host.data = path;

  578.     if (len > sizeof(saun->sun_path)) {
  579.         u->err = "too long path in the unix domain socket";
  580.         return NGX_ERROR;
  581.     }

  583.     u->socklen = sizeof(struct sockaddr_un);
  584.     saun = (struct sockaddr_un *) &u->sockaddr;
  585.     saun->sun_family = AF_UNIX;
  586.     (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);

  588.     u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
  589.     if (u->addrs == NULL) {
  590.         return NGX_ERROR;
  591.     }

  593.     saun = ngx_pcalloc(pool, sizeof(struct sockaddr_un));
  594.     if (saun == NULL) {
  595.         return NGX_ERROR;
  596.     }

  598.     u->family = AF_UNIX;
  599.     u->naddrs = 1;

  601.     saun->sun_family = AF_UNIX;
  602.     (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);

  604.     u->addrs[0].sockaddr = (struct sockaddr *) saun;
  605.     u->addrs[0].socklen = sizeof(struct sockaddr_un);
  606.     u->addrs[0].name.len = len + 4;
  607.     u->addrs[0].name.data = u->url.data;

  609.     return NGX_OK;

  611. #else

  613.     u->err = "the unix domain sockets are not supported on this platform";

  615.     return NGX_ERROR;

  617. #endif
  618. }


  621. static ngx_int_t
  622. ‌ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
  623. {
  624.     u_char               *p, *host, *port, *last, *uri, *args;
  625.     size_t                len;
  626.     ngx_int_t             n;
  627.     struct sockaddr_in   *sin;
  628. #if (NGX_HAVE_INET6)
  629.     struct sockaddr_in6  *sin6;
  630. #endif

  632.     u->socklen = sizeof(struct sockaddr_in);
  633.     sin = (struct sockaddr_in *) &u->sockaddr;
  634.     sin->sin_family = AF_INET;

  636.     u->family = AF_INET;

  638.     host = u->url.data;

  640.     last = host + u->url.len;

  642.     port = ngx_strlchr(host, last, ':');

  644.     uri = ngx_strlchr(host, last, '/');

  646.     args = ngx_strlchr(host, last, '?');

  648.     if (args) {
  649.         if (uri == NULL || args < uri) {
  650.             uri = args;
  651.         }
  652.     }

  654.     if (uri) {
  655.         if (u->listen || !u->uri_part) {
  656.             u->err = "invalid host";
  657.             return NGX_ERROR;
  658.         }

  660.         u->uri.len = last - uri;
  661.         u->uri.data = uri;

  663.         last = uri;

  665.         if (uri < port) {
  666.             port = NULL;
  667.         }
  668.     }

  670.     if (port) {
  671.         port++;

  673.         len = last - port;

  675.         n = ngx_atoi(port, len);

  677.         if (n < 1 || n > 65535) {
  678.             u->err = "invalid port";
  679.             return NGX_ERROR;
  680.         }

  682.         u->port = (in_port_t) n;
  683.         sin->sin_port = htons((in_port_t) n);

  685.         u->port_text.len = len;
  686.         u->port_text.data = port;

  688.         last = port - 1;

  690.     } else {
  691.         if (uri == NULL) {

  693.             if (u->listen) {

  695.                 /* test value as port only */

  697.                 n = ngx_atoi(host, last - host);

  699.                 if (n != NGX_ERROR) {

  701.                     if (n < 1 || n > 65535) {
  702.                         u->err = "invalid port";
  703.                         return NGX_ERROR;
  704.                     }

  706.                     u->port = (in_port_t) n;
  707.                     sin->sin_port = htons((in_port_t) n);

  709.                     u->port_text.len = last - host;
  710.                     u->port_text.data = host;

  712.                     u->wildcard = 1;

  714.                     return NGX_OK;
  715.                 }
  716.             }
  717.         }

  719.         u->no_port = 1;
  720.         u->port = u->default_port;
  721.         sin->sin_port = htons(u->default_port);
  722.     }

  724.     len = last - host;

  726.     if (len == 0) {
  727.         u->err = "no host";
  728.         return NGX_ERROR;
  729.     }

  731.     u->host.len = len;
  732.     u->host.data = host;

  734.     if (u->listen && len == 1 && *host == '*') {
  735.         sin->sin_addr.s_addr = INADDR_ANY;
  736.         u->wildcard = 1;
  737.         return NGX_OK;
  738.     }

  740.     sin->sin_addr.s_addr = ngx_inet_addr(host, len);

  742.     if (sin->sin_addr.s_addr != INADDR_NONE) {

  744.         if (sin->sin_addr.s_addr == INADDR_ANY) {
  745.             u->wildcard = 1;
  746.         }

  748.         u->naddrs = 1;

  750.         u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
  751.         if (u->addrs == NULL) {
  752.             return NGX_ERROR;
  753.         }

  755.         sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
  756.         if (sin == NULL) {
  757.             return NGX_ERROR;
  758.         }

  760.         ngx_memcpy(sin, u->sockaddr, sizeof(struct sockaddr_in));

  762.         u->addrs[0].sockaddr = (struct sockaddr *) sin;
  763.         u->addrs[0].socklen = sizeof(struct sockaddr_in);

  765.         p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
  766.         if (p == NULL) {
  767.             return NGX_ERROR;
  768.         }

  770.         u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
  771.                                            &u->host, u->port) - p;
  772.         u->addrs[0].name.data = p;

  774.         return NGX_OK;
  775.     }

  777.     if (u->no_resolve) {
  778.         return NGX_OK;
  779.     }

  781.     if (ngx_inet_resolve_host(pool, u) != NGX_OK) {
  782.         return NGX_ERROR;
  783.     }

  785.     u->family = u->addrs[0].sockaddr->sa_family;
  786.     u->socklen = u->addrs[0].socklen;
  787.     ngx_memcpy(u->sockaddr, u->addrs[0].sockaddr, u->addrs[0].socklen);

  789.     switch (u->family) {

  791. #if (NGX_HAVE_INET6)
  792.     case AF_INET6:
  793.         sin6 = (struct sockaddr_in6 *) &u->sockaddr;

  795.         if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  796.             u->wildcard = 1;
  797.         }

  799.         break;
  800. #endif

  802.     default: /* AF_INET */
  803.         sin = (struct sockaddr_in *) &u->sockaddr;

  805.         if (sin->sin_addr.s_addr == INADDR_ANY) {
  806.             u->wildcard = 1;
  807.         }

  809.         break;
  810.     }

  812.     return NGX_OK;
  813. }


  816. static ngx_int_t
  817. ‌ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
  818. {
  819. #if (NGX_HAVE_INET6)
  820.     u_char               *p, *host, *port, *last, *uri;
  821.     size_t                len;
  822.     ngx_int_t             n;
  823.     struct sockaddr_in6  *sin6;

  825.     u->socklen = sizeof(struct sockaddr_in6);
  826.     sin6 = (struct sockaddr_in6 *) &u->sockaddr;
  827.     sin6->sin6_family = AF_INET6;

  829.     host = u->url.data + 1;

  831.     last = u->url.data + u->url.len;

  833.     p = ngx_strlchr(host, last, ']');

  835.     if (p == NULL) {
  836.         u->err = "invalid host";
  837.         return NGX_ERROR;
  838.     }

  840.     if (last - p) {

  842.         port = p + 1;

  844.         uri = ngx_strlchr(port, last, '/');

  846.         if (uri) {
  847.             if (u->listen || !u->uri_part) {
  848.                 u->err = "invalid host";
  849.                 return NGX_ERROR;
  850.             }

  852.             u->uri.len = last - uri;
  853.             u->uri.data = uri;

  855.             last = uri;
  856.         }

  858.         if (*port == ':') {
  859.             port++;

  861.             len = last - port;

  863.             n = ngx_atoi(port, len);

  865.             if (n < 1 || n > 65535) {
  866.                 u->err = "invalid port";
  867.                 return NGX_ERROR;
  868.             }

  870.             u->port = (in_port_t) n;
  871.             sin6->sin6_port = htons((in_port_t) n);

  873.             u->port_text.len = len;
  874.             u->port_text.data = port;

  876.         } else {
  877.             u->no_port = 1;
  878.             u->port = u->default_port;
  879.             sin6->sin6_port = htons(u->default_port);
  880.         }
  881.     }

  883.     len = p - host;

  885.     if (len == 0) {
  886.         u->err = "no host";
  887.         return NGX_ERROR;
  888.     }

  890.     u->host.len = len + 2;
  891.     u->host.data = host - 1;

  893.     if (ngx_inet6_addr(host, len, sin6->sin6_addr.s6_addr) != NGX_OK) {
  894.         u->err = "invalid IPv6 address";
  895.         return NGX_ERROR;
  896.     }

  898.     if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  899.         u->wildcard = 1;
  900.     }

  902.     u->family = AF_INET6;
  903.     u->naddrs = 1;

  905.     u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
  906.     if (u->addrs == NULL) {
  907.         return NGX_ERROR;
  908.     }

  910.     sin6 = ngx_pcalloc(pool, sizeof(struct sockaddr_in6));
  911.     if (sin6 == NULL) {
  912.         return NGX_ERROR;
  913.     }

  915.     ngx_memcpy(sin6, u->sockaddr, sizeof(struct sockaddr_in6));

  917.     u->addrs[0].sockaddr = (struct sockaddr *) sin6;
  918.     u->addrs[0].socklen = sizeof(struct sockaddr_in6);

  920.     p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
  921.     if (p == NULL) {
  922.         return NGX_ERROR;
  923.     }

  925.     u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
  926.                                        &u->host, u->port) - p;
  927.     u->addrs[0].name.data = p;

  929.     return NGX_OK;

  931. #else

  933.     u->err = "the INET6 sockets are not supported on this platform";

  935.     return NGX_ERROR;

  937. #endif
  938. }


  941. #if (NGX_HAVE_GETADDRINFO && NGX_HAVE_INET6)

  943. ngx_int_t
  944. ‌ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
  945. {
  946.     u_char               *p, *host;
  947.     size_t                len;
  948.     in_port_t             port;
  949.     ngx_uint_t            i;
  950.     struct addrinfo       hints, *res, *rp;
  951.     struct sockaddr_in   *sin;
  952.     struct sockaddr_in6  *sin6;

  954.     port = htons(u->port);

  956.     host = ngx_alloc(u->host.len + 1, pool->log);
  957.     if (host == NULL) {
  958.         return NGX_ERROR;
  959.     }

  961.     (void) ngx_cpystrn(host, u->host.data, u->host.len + 1);

  963.     ngx_memzero(&hints, sizeof(struct addrinfo));
  964.     hints.ai_family = AF_UNSPEC;
  965.     hints.ai_socktype = SOCK_STREAM;
  966. #ifdef AI_ADDRCONFIG
  967.     hints.ai_flags = AI_ADDRCONFIG;
  968. #endif

  970.     if (getaddrinfo((char *) host, NULL, &hints, &res) != 0) {
  971.         u->err = "host not found";
  972.         ngx_free(host);
  973.         return NGX_ERROR;
  974.     }

  976.     ngx_free(host);

  978.     for (i = 0, rp = res; rp != NULL; rp = rp->ai_next) {

  980.         switch (rp->ai_family) {

  982.         case AF_INET:
  983.         case AF_INET6:
  984.             break;

  986.         default:
  987.             continue;
  988.         }

  990.         i++;
  991.     }

  993.     if (i == 0) {
  994.         u->err = "host not found";
  995.         goto failed;
  996.     }

  998.     /* MP: ngx_shared_palloc() */

  1000.     u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_addr_t));
  1001.     if (u->addrs == NULL) {
  1002.         goto failed;
  1003.     }

  1005.     u->naddrs = i;

  1007.     i = 0;

  1009.     /* AF_INET addresses first */

  1011.     for (rp = res; rp != NULL; rp = rp->ai_next) {

  1013.         if (rp->ai_family != AF_INET) {
  1014.             continue;
  1015.         }

  1017.         sin = ngx_pcalloc(pool, rp->ai_addrlen);
  1018.         if (sin == NULL) {
  1019.             goto failed;
  1020.         }

  1022.         ngx_memcpy(sin, rp->ai_addr, rp->ai_addrlen);

  1024.         sin->sin_port = port;

  1026.         u->addrs[i].sockaddr = (struct sockaddr *) sin;
  1027.         u->addrs[i].socklen = rp->ai_addrlen;

  1029.         len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;

  1031.         p = ngx_pnalloc(pool, len);
  1032.         if (p == NULL) {
  1033.             goto failed;
  1034.         }

  1036.         len = ngx_sock_ntop((struct sockaddr *) sin, rp->ai_addrlen, p, len, 1);

  1038.         u->addrs[i].name.len = len;
  1039.         u->addrs[i].name.data = p;

  1041.         i++;
  1042.     }

  1044.     for (rp = res; rp != NULL; rp = rp->ai_next) {

  1046.         if (rp->ai_family != AF_INET6) {
  1047.             continue;
  1048.         }

  1050.         sin6 = ngx_pcalloc(pool, rp->ai_addrlen);
  1051.         if (sin6 == NULL) {
  1052.             goto failed;
  1053.         }

  1055.         ngx_memcpy(sin6, rp->ai_addr, rp->ai_addrlen);

  1057.         sin6->sin6_port = port;

  1059.         u->addrs[i].sockaddr = (struct sockaddr *) sin6;
  1060.         u->addrs[i].socklen = rp->ai_addrlen;

  1062.         len = NGX_INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;

  1064.         p = ngx_pnalloc(pool, len);
  1065.         if (p == NULL) {
  1066.             goto failed;
  1067.         }

  1069.         len = ngx_sock_ntop((struct sockaddr *) sin6, rp->ai_addrlen, p,
  1070.                             len, 1);

  1072.         u->addrs[i].name.len = len;
  1073.         u->addrs[i].name.data = p;

  1075.         i++;
  1076.     }

  1078.     freeaddrinfo(res);
  1079.     return NGX_OK;

  1081. failed:

  1083.     freeaddrinfo(res);
  1084.     return NGX_ERROR;
  1085. }

  1087. #else /* !NGX_HAVE_GETADDRINFO || !NGX_HAVE_INET6 */

  1089. ngx_int_t
  1090. ‌ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
  1091. {
  1092.     u_char              *p, *host;
  1093.     size_t               len;
  1094.     in_port_t            port;
  1095.     in_addr_t            in_addr;
  1096.     ngx_uint_t           i;
  1097.     struct hostent      *h;
  1098.     struct sockaddr_in  *sin;

  1100.     /* AF_INET only */

  1102.     port = htons(u->port);

  1104.     in_addr = ngx_inet_addr(u->host.data, u->host.len);

  1106.     if (in_addr == INADDR_NONE) {
  1107.         host = ngx_alloc(u->host.len + 1, pool->log);
  1108.         if (host == NULL) {
  1109.             return NGX_ERROR;
  1110.         }

  1112.         (void) ngx_cpystrn(host, u->host.data, u->host.len + 1);

  1114.         h = gethostbyname((char *) host);

  1116.         ngx_free(host);

  1118.         if (h == NULL || h->h_addr_list[0] == NULL) {
  1119.             u->err = "host not found";
  1120.             return NGX_ERROR;
  1121.         }

  1123.         for (i = 0; h->h_addr_list[i] != NULL; i++) { /* void */ }

  1125.         /* MP: ngx_shared_palloc() */

  1127.         u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_addr_t));
  1128.         if (u->addrs == NULL) {
  1129.             return NGX_ERROR;
  1130.         }

  1132.         u->naddrs = i;

  1134.         for (i = 0; i < u->naddrs; i++) {

  1136.             sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
  1137.             if (sin == NULL) {
  1138.                 return NGX_ERROR;
  1139.             }

  1141.             sin->sin_family = AF_INET;
  1142.             sin->sin_port = port;
  1143.             sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);

  1145.             u->addrs[i].sockaddr = (struct sockaddr *) sin;
  1146.             u->addrs[i].socklen = sizeof(struct sockaddr_in);

  1148.             len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;

  1150.             p = ngx_pnalloc(pool, len);
  1151.             if (p == NULL) {
  1152.                 return NGX_ERROR;
  1153.             }

  1155.             len = ngx_sock_ntop((struct sockaddr *) sin,
  1156.                                 sizeof(struct sockaddr_in), p, len, 1);

  1158.             u->addrs[i].name.len = len;
  1159.             u->addrs[i].name.data = p;
  1160.         }

  1162.     } else {

  1164.         /* MP: ngx_shared_palloc() */

  1166.         u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
  1167.         if (u->addrs == NULL) {
  1168.             return NGX_ERROR;
  1169.         }

  1171.         sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
  1172.         if (sin == NULL) {
  1173.             return NGX_ERROR;
  1174.         }

  1176.         u->naddrs = 1;

  1178.         sin->sin_family = AF_INET;
  1179.         sin->sin_port = port;
  1180.         sin->sin_addr.s_addr = in_addr;

  1182.         u->addrs[0].sockaddr = (struct sockaddr *) sin;
  1183.         u->addrs[0].socklen = sizeof(struct sockaddr_in);

  1185.         p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
  1186.         if (p == NULL) {
  1187.             return NGX_ERROR;
  1188.         }

  1190.         u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
  1191.                                            &u->host, ntohs(port)) - p;
  1192.         u->addrs[0].name.data = p;
  1193.     }

  1195.     return NGX_OK;
  1196. }

  1198. #endif /* NGX_HAVE_GETADDRINFO && NGX_HAVE_INET6 */


  1201. ngx_int_t
  1202. ‌ngx_cmp_sockaddr(struct sockaddr *sa1, socklen_t slen1,
  1203.     struct sockaddr *sa2, socklen_t slen2, ngx_uint_t cmp_port)
  1204. {
  1205.     struct sockaddr_in   *sin1, *sin2;
  1206. #if (NGX_HAVE_INET6)
  1207.     struct sockaddr_in6  *sin61, *sin62;
  1208. #endif
  1209. #if (NGX_HAVE_UNIX_DOMAIN)
  1210.     struct sockaddr_un   *saun1, *saun2;
  1211. #endif

  1213.     if (sa1->sa_family != sa2->sa_family) {
  1214.         return NGX_DECLINED;
  1215.     }

  1217.     switch (sa1->sa_family) {

  1219. #if (NGX_HAVE_INET6)
  1220.     case AF_INET6:

  1222.         sin61 = (struct sockaddr_in6 *) sa1;
  1223.         sin62 = (struct sockaddr_in6 *) sa2;

  1225.         if (cmp_port && sin61->sin6_port != sin62->sin6_port) {
  1226.             return NGX_DECLINED;
  1227.         }

  1229.         if (ngx_memcmp(&sin61->sin6_addr, &sin62->sin6_addr, 16) != 0) {
  1230.             return NGX_DECLINED;
  1231.         }

  1233.         break;
  1234. #endif

  1236. #if (NGX_HAVE_UNIX_DOMAIN)
  1237.     case AF_UNIX:

  1239.        /* TODO length */

  1241.        saun1 = (struct sockaddr_un *) sa1;
  1242.        saun2 = (struct sockaddr_un *) sa2;

  1244.        if (ngx_memcmp(&saun1->sun_path, &saun2->sun_path,
  1245.                       sizeof(saun1->sun_path))
  1246.            != 0)
  1247.        {
  1248.            return NGX_DECLINED;
  1249.        }

  1251.        break;
  1252. #endif

  1254.     default: /* AF_INET */

  1256.         sin1 = (struct sockaddr_in *) sa1;
  1257.         sin2 = (struct sockaddr_in *) sa2;

  1259.         if (cmp_port && sin1->sin_port != sin2->sin_port) {
  1260.             return NGX_DECLINED;
  1261.         }

  1263.         if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) {
  1264.             return NGX_DECLINED;
  1265.         }

  1267.         break;
  1268.     }

  1270.     return NGX_OK;
  1271. }

One Level Up Top Level