One Level Up Top Level

src/core/ngx_inet.c - nginx source code

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);
  15. static ngx_int_t ngx_inet_add_addr(ngx_pool_t *pool, ngx_url_t *u,
  16.     struct sockaddr *sockaddr, socklen_t socklen, ngx_uint_t total);


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

  26.     addr = 0;
  27.     octet = 0;
  28.     n = 0;

  30.     for (p = text; p < text + len; p++) {
  31.         c = *p;

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

  36.             if (octet > 255) {
  37.                 return INADDR_NONE;
  38.             }

  40.             continue;
  41.         }

  43.         if (c == '.') {
  44.             addr = (addr << 8) + octet;
  45.             octet = 0;
  46.             n++;
  47.             continue;
  48.         }

  50.         return INADDR_NONE;
  51.     }

  53.     if (n == 3) {
  54.         addr = (addr << 8) + octet;
  55.         return htonl(addr);
  56.     }

  58.     return INADDR_NONE;
  59. }


  62. #if (NGX_HAVE_INET6)

  64. ngx_int_t
  65. ‌ngx_inet6_addr(u_char *p, size_t len, u_char *addr)
  66. {
  67.     u_char      c, *zero, *digit, *s, *d;
  68.     size_t      len4;
  69.     ngx_uint_t  n, nibbles, word;

  71.     if (len == 0) {
  72.         return NGX_ERROR;
  73.     }

  75.     zero = NULL;
  76.     digit = NULL;
  77.     len4 = 0;
  78.     nibbles = 0;
  79.     word = 0;
  80.     n = 8;

  82.     if (p[0] == ':') {
  83.         p++;
  84.         len--;
  85.     }

  87.     for (/* void */; len; len--) {
  88.         c = *p++;

  90.         if (c == ':') {
  91.             if (nibbles) {
  92.                 digit = p;
  93.                 len4 = len;
  94.                 *addr++ = (u_char) (word >> 8);
  95.                 *addr++ = (u_char) (word & 0xff);

  97.                 if (--n) {
  98.                     nibbles = 0;
  99.                     word = 0;
  100.                     continue;
  101.                 }

  103.             } else {
  104.                 if (zero == NULL) {
  105.                     digit = p;
  106.                     len4 = len;
  107.                     zero = addr;
  108.                     continue;
  109.                 }
  110.             }

  112.             return NGX_ERROR;
  113.         }

  115.         if (c == '.' && nibbles) {
  116.             if (n < 2 || digit == NULL) {
  117.                 return NGX_ERROR;
  118.             }

  120.             word = ngx_inet_addr(digit, len4 - 1);
  121.             if (word == INADDR_NONE) {
  122.                 return NGX_ERROR;
  123.             }

  125.             word = ntohl(word);
  126.             *addr++ = (u_char) ((word >> 24) & 0xff);
  127.             *addr++ = (u_char) ((word >> 16) & 0xff);
  128.             n--;
  129.             break;
  130.         }

  132.         if (++nibbles > 4) {
  133.             return NGX_ERROR;
  134.         }

  136.         if (c >= '0' && c <= '9') {
  137.             word = word * 16 + (c - '0');
  138.             continue;
  139.         }

  141.         c |= 0x20;

  143.         if (c >= 'a' && c <= 'f') {
  144.             word = word * 16 + (c - 'a') + 10;
  145.             continue;
  146.         }

  148.         return NGX_ERROR;
  149.     }

  151.     if (nibbles == 0 && zero == NULL) {
  152.         return NGX_ERROR;
  153.     }

  155.     *addr++ = (u_char) (word >> 8);
  156.     *addr++ = (u_char) (word & 0xff);

  158.     if (--n) {
  159.         if (zero) {
  160.             n *= 2;
  161.             s = addr - 1;
  162.             d = s + n;
  163.             while (s >= zero) {
  164.                 *d-- = *s--;
  165.             }
  166.             ngx_memzero(zero, n);
  167.             return NGX_OK;
  168.         }

  170.     } else {
  171.         if (zero == NULL) {
  172.             return NGX_OK;
  173.         }
  174.     }

  176.     return NGX_ERROR;
  177. }

  179. #endif


  182. size_t
  183. ‌ngx_sock_ntop(struct sockaddr *sa, socklen_t socklen, u_char *text, size_t len,
  184.     ngx_uint_t port)
  185. {
  186.     u_char               *p;
  187. #if (NGX_HAVE_INET6 || NGX_HAVE_UNIX_DOMAIN)
  188.     size_t                n;
  189. #endif
  190.     struct sockaddr_in   *sin;
  191. #if (NGX_HAVE_INET6)
  192.     struct sockaddr_in6  *sin6;
  193. #endif
  194. #if (NGX_HAVE_UNIX_DOMAIN)
  195.     struct sockaddr_un   *saun;
  196. #endif

  198.     switch (sa->sa_family) {

  200.     case AF_INET:

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

  205.         if (port) {
  206.             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud:%d",
  207.                              p[0], p[1], p[2], p[3], ntohs(sin->sin_port));
  208.         } else {
  209.             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
  210.                              p[0], p[1], p[2], p[3]);
  211.         }

  213.         return (p - text);

  215. #if (NGX_HAVE_INET6)

  217.     case AF_INET6:

  219.         sin6 = (struct sockaddr_in6 *) sa;

  221.         n = 0;

  223.         if (port) {
  224.             text[n++] = '[';
  225.         }

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

  229.         if (port) {
  230.             n = ngx_sprintf(&text[1 + n], "]:%d",
  231.                             ntohs(sin6->sin6_port)) - text;
  232.         }

  234.         return n;
  235. #endif

  237. #if (NGX_HAVE_UNIX_DOMAIN)

  239.     case AF_UNIX:
  240.         saun = (struct sockaddr_un *) sa;

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

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

  247.         } else {
  248.             n = ngx_strnlen((u_char *) saun->sun_path,
  249.                             socklen - offsetof(struct sockaddr_un, sun_path));
  250.             p = ngx_snprintf(text, len, "unix:%*s%Z", n, saun->sun_path);
  251.         }

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

  255.         return (p - text - 1);

  257. #endif

  259.     default:
  260.         return 0;
  261.     }
  262. }


  265. size_t
  266. ‌ngx_inet_ntop(int family, void *addr, u_char *text, size_t len)
  267. {
  268.     u_char  *p;

  270.     switch (family) {

  272.     case AF_INET:

  274.         p = addr;

  276.         return ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
  277.                             p[0], p[1], p[2], p[3])
  278.                - text;

  280. #if (NGX_HAVE_INET6)

  282.     case AF_INET6:
  283.         return ngx_inet6_ntop(addr, text, len);

  285. #endif

  287.     default:
  288.         return 0;
  289.     }
  290. }


  293. #if (NGX_HAVE_INET6)

  295. size_t
  296. ‌ngx_inet6_ntop(u_char *p, u_char *text, size_t len)
  297. {
  298.     u_char      *dst;
  299.     size_t       max, n;
  300.     ngx_uint_t   i, zero, last;

  302.     if (len < NGX_INET6_ADDRSTRLEN) {
  303.         return 0;
  304.     }

  306.     zero = (ngx_uint_t) -1;
  307.     last = (ngx_uint_t) -1;
  308.     max = 1;
  309.     n = 0;

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

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

  315.             if (max < n) {
  316.                 zero = last;
  317.                 max = n;
  318.             }

  320.             n = 0;
  321.             continue;
  322.         }

  324.         if (n++ == 0) {
  325.             last = i;
  326.         }
  327.     }

  329.     if (max < n) {
  330.         zero = last;
  331.         max = n;
  332.     }

  334.     dst = text;
  335.     n = 16;

  337.     if (zero == 0) {

  339.         if ((max == 5 && p[10] == 0xff && p[11] == 0xff)
  340.             || (max == 6)
  341.             || (max == 7 && p[14] != 0 && p[15] != 1))
  342.         {
  343.             n = 12;
  344.         }

  346.         *dst++ = ':';
  347.     }

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

  351.         if (i == zero) {
  352.             *dst++ = ':';
  353.             i += (max - 1) * 2;
  354.             continue;
  355.         }

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

  359.         if (i < 14) {
  360.             *dst++ = ':';
  361.         }
  362.     }

  364.     if (n == 12) {
  365.         dst = ngx_sprintf(dst, "%ud.%ud.%ud.%ud", p[12], p[13], p[14], p[15]);
  366.     }

  368.     return dst - text;
  369. }

  371. #endif


  374. ngx_int_t
  375. ‌ngx_ptocidr(ngx_str_t *text, ngx_cidr_t *cidr)
  376. {
  377.     u_char      *addr, *mask, *last;
  378.     size_t       len;
  379.     ngx_int_t    shift;
  380. #if (NGX_HAVE_INET6)
  381.     ngx_int_t    rc;
  382.     ngx_uint_t   s, i;
  383. #endif

  385.     addr = text->data;
  386.     last = addr + text->len;

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

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

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

  396.         if (mask == NULL) {
  397.             cidr->u.in.mask = 0xffffffff;
  398.             return NGX_OK;
  399.         }

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

  405.         if (mask == NULL) {
  406.             ngx_memset(cidr->u.in6.mask.s6_addr, 0xff, 16);
  407.             return NGX_OK;
  408.         }

  410. #endif
  411.     } else {
  412.         return NGX_ERROR;
  413.     }

  415.     mask++;

  417.     shift = ngx_atoi(mask, last - mask);
  418.     if (shift == NGX_ERROR) {
  419.         return NGX_ERROR;
  420.     }

  422.     switch (cidr->family) {

  424. #if (NGX_HAVE_INET6)
  425.     case AF_INET6:
  426.         if (shift > 128) {
  427.             return NGX_ERROR;
  428.         }

  430.         addr = cidr->u.in6.addr.s6_addr;
  431.         mask = cidr->u.in6.mask.s6_addr;
  432.         rc = NGX_OK;

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

  436.             s = (shift > 8) ? 8 : shift;
  437.             shift -= s;

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

  441.             if (addr[i] != (addr[i] & mask[i])) {
  442.                 rc = NGX_DONE;
  443.                 addr[i] &= mask[i];
  444.             }
  445.         }

  447.         return rc;
  448. #endif

  450.     default: /* AF_INET */
  451.         if (shift > 32) {
  452.             return NGX_ERROR;
  453.         }

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

  458.         } else {
  459.             /* x86 compilers use a shl instruction that shifts by modulo 32 */
  460.             cidr->u.in.mask = 0;
  461.         }

  463.         if (cidr->u.in.addr == (cidr->u.in.addr & cidr->u.in.mask)) {
  464.             return NGX_OK;
  465.         }

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

  469.         return NGX_DONE;
  470.     }
  471. }


  474. ngx_int_t
  475. ‌ngx_cidr_match(struct sockaddr *sa, ngx_array_t *cidrs)
  476. {
  477. #if (NGX_HAVE_INET6)
  478.     u_char           *p;
  479. #endif
  480.     in_addr_t         inaddr;
  481.     ngx_cidr_t       *cidr;
  482.     ngx_uint_t        family, i;
  483. #if (NGX_HAVE_INET6)
  484.     ngx_uint_t        n;
  485.     struct in6_addr  *inaddr6;
  486. #endif

  488. #if (NGX_SUPPRESS_WARN)
  489.     inaddr = 0;
  490. #if (NGX_HAVE_INET6)
  491.     inaddr6 = NULL;
  492. #endif
  493. #endif

  495.     family = sa->sa_family;

  497.     if (family == AF_INET) {
  498.         inaddr = ((struct sockaddr_in *) sa)->sin_addr.s_addr;
  499.     }

  501. #if (NGX_HAVE_INET6)
  502.     else if (family == AF_INET6) {
  503.         inaddr6 = &((struct sockaddr_in6 *) sa)->sin6_addr;

  505.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  506.             family = AF_INET;

  508.             p = inaddr6->s6_addr;

  510.             inaddr = (in_addr_t) p[12] << 24;
  511.             inaddr += p[13] << 16;
  512.             inaddr += p[14] << 8;
  513.             inaddr += p[15];

  515.             inaddr = htonl(inaddr);
  516.         }
  517.     }
  518. #endif

  520.     for (cidr = cidrs->elts, i = 0; i < cidrs->nelts; i++) {
  521.         if (cidr[i].family != family) {
  522.             goto next;
  523.         }

  525.         switch (family) {

  527. #if (NGX_HAVE_INET6)
  528.         case AF_INET6:
  529.             for (n = 0; n < 16; n++) {
  530.                 if ((inaddr6->s6_addr[n] & cidr[i].u.in6.mask.s6_addr[n])
  531.                     != cidr[i].u.in6.addr.s6_addr[n])
  532.                 {
  533.                     goto next;
  534.                 }
  535.             }
  536.             break;
  537. #endif

  539. #if (NGX_HAVE_UNIX_DOMAIN)
  540.         case AF_UNIX:
  541.             break;
  542. #endif

  544.         default: /* AF_INET */
  545.             if ((inaddr & cidr[i].u.in.mask) != cidr[i].u.in.addr) {
  546.                 goto next;
  547.             }
  548.             break;
  549.         }

  551.         return NGX_OK;

  553.     next:
  554.         continue;
  555.     }

  557.     return NGX_DECLINED;
  558. }


  561. ngx_int_t
  562. ‌ngx_parse_addr(ngx_pool_t *pool, ngx_addr_t *addr, u_char *text, size_t len)
  563. {
  564.     in_addr_t             inaddr;
  565.     ngx_uint_t            family;
  566.     struct sockaddr_in   *sin;
  567. #if (NGX_HAVE_INET6)
  568.     struct in6_addr       inaddr6;
  569.     struct sockaddr_in6  *sin6;

  571.     /*
  572.      * prevent MSVC8 warning:
  573.      *    potentially uninitialized local variable 'inaddr6' used
  574.      */
  575.     ngx_memzero(&inaddr6, sizeof(struct in6_addr));
  576. #endif

  578.     inaddr = ngx_inet_addr(text, len);

  580.     if (inaddr != INADDR_NONE) {
  581.         family = AF_INET;
  582.         len = sizeof(struct sockaddr_in);

  584. #if (NGX_HAVE_INET6)
  585.     } else if (ngx_inet6_addr(text, len, inaddr6.s6_addr) == NGX_OK) {
  586.         family = AF_INET6;
  587.         len = sizeof(struct sockaddr_in6);

  589. #endif
  590.     } else {
  591.         return NGX_DECLINED;
  592.     }

  594.     addr->sockaddr = ngx_pcalloc(pool, len);
  595.     if (addr->sockaddr == NULL) {
  596.         return NGX_ERROR;
  597.     }

  599.     addr->sockaddr->sa_family = (u_char) family;
  600.     addr->socklen = len;

  602.     switch (family) {

  604. #if (NGX_HAVE_INET6)
  605.     case AF_INET6:
  606.         sin6 = (struct sockaddr_in6 *) addr->sockaddr;
  607.         ngx_memcpy(sin6->sin6_addr.s6_addr, inaddr6.s6_addr, 16);
  608.         break;
  609. #endif

  611.     default: /* AF_INET */
  612.         sin = (struct sockaddr_in *) addr->sockaddr;
  613.         sin->sin_addr.s_addr = inaddr;
  614.         break;
  615.     }

  617.     return NGX_OK;
  618. }


  621. ngx_int_t
  622. ‌ngx_parse_addr_port(ngx_pool_t *pool, ngx_addr_t *addr, u_char *text,
  623.     size_t len)
  624. {
  625.     u_char     *p, *last;
  626.     size_t      plen;
  627.     ngx_int_t   rc, port;

  629.     rc = ngx_parse_addr(pool, addr, text, len);

  631.     if (rc != NGX_DECLINED) {
  632.         return rc;
  633.     }

  635.     last = text + len;

  637. #if (NGX_HAVE_INET6)
  638.     if (len && text[0] == '[') {

  640.         p = ngx_strlchr(text, last, ']');

  642.         if (p == last - 1) {
  643.             return ngx_parse_addr(pool, addr, text + 1, len - 2);
  644.         }

  646.         if (p == NULL || *++p != ':') {
  647.             return NGX_DECLINED;
  648.         }

  650.         text++;
  651.         len -= 2;

  653.     } else
  654. #endif

  656.     {
  657.         p = ngx_strlchr(text, last, ':');

  659.         if (p == NULL) {
  660.             return NGX_DECLINED;
  661.         }
  662.     }

  664.     p++;
  665.     plen = last - p;

  667.     port = ngx_atoi(p, plen);

  669.     if (port < 1 || port > 65535) {
  670.         return NGX_DECLINED;
  671.     }

  673.     len -= plen + 1;

  675.     rc = ngx_parse_addr(pool, addr, text, len);

  677.     if (rc != NGX_OK) {
  678.         return rc;
  679.     }

  681.     ngx_inet_set_port(addr->sockaddr, (in_port_t) port);

  683.     return NGX_OK;
  684. }


  687. ngx_int_t
  688. ‌ngx_parse_url(ngx_pool_t *pool, ngx_url_t *u)
  689. {
  690.     u_char  *p;
  691.     size_t   len;

  693.     p = u->url.data;
  694.     len = u->url.len;

  696.     if (len >= 5 && ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0) {
  697.         return ngx_parse_unix_domain_url(pool, u);
  698.     }

  700.     if (len && p[0] == '[') {
  701.         return ngx_parse_inet6_url(pool, u);
  702.     }

  704.     return ngx_parse_inet_url(pool, u);
  705. }


  708. static ngx_int_t
  709. ‌ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u)
  710. {
  711. #if (NGX_HAVE_UNIX_DOMAIN)
  712.     u_char              *path, *uri, *last;
  713.     size_t               len;
  714.     struct sockaddr_un  *saun;

  716.     len = u->url.len;
  717.     path = u->url.data;

  719.     path += 5;
  720.     len -= 5;

  722.     if (u->uri_part) {

  724.         last = path + len;
  725.         uri = ngx_strlchr(path, last, ':');

  727.         if (uri) {
  728.             len = uri - path;
  729.             uri++;
  730.             u->uri.len = last - uri;
  731.             u->uri.data = uri;
  732.         }
  733.     }

  735.     if (len == 0) {
  736.         u->err = "no path in the unix domain socket";
  737.         return NGX_ERROR;
  738.     }

  740.     u->host.len = len++;
  741.     u->host.data = path;

  743.     if (len > sizeof(saun->sun_path)) {
  744.         u->err = "too long path in the unix domain socket";
  745.         return NGX_ERROR;
  746.     }

  748.     u->socklen = sizeof(struct sockaddr_un);
  749.     saun = (struct sockaddr_un *) &u->sockaddr;
  750.     saun->sun_family = AF_UNIX;
  751.     (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);

  753.     u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
  754.     if (u->addrs == NULL) {
  755.         return NGX_ERROR;
  756.     }

  758.     saun = ngx_pcalloc(pool, sizeof(struct sockaddr_un));
  759.     if (saun == NULL) {
  760.         return NGX_ERROR;
  761.     }

  763.     u->family = AF_UNIX;
  764.     u->naddrs = 1;

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

  769.     u->addrs[0].sockaddr = (struct sockaddr *) saun;
  770.     u->addrs[0].socklen = sizeof(struct sockaddr_un);
  771.     u->addrs[0].name.len = len + 4;
  772.     u->addrs[0].name.data = u->url.data;

  774.     return NGX_OK;

  776. #else

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

  780.     return NGX_ERROR;

  782. #endif
  783. }


  786. static ngx_int_t
  787. ‌ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
  788. {
  789.     u_char              *host, *port, *last, *uri, *args, *dash;
  790.     size_t               len;
  791.     ngx_int_t            n;
  792.     struct sockaddr_in  *sin;

  794.     u->socklen = sizeof(struct sockaddr_in);
  795.     sin = (struct sockaddr_in *) &u->sockaddr;
  796.     sin->sin_family = AF_INET;

  798.     u->family = AF_INET;

  800.     host = u->url.data;

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

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

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

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

  810.     if (args) {
  811.         if (uri == NULL || args < uri) {
  812.             uri = args;
  813.         }
  814.     }

  816.     if (uri) {
  817.         if (u->listen || !u->uri_part) {
  818.             u->err = "invalid host";
  819.             return NGX_ERROR;
  820.         }

  822.         u->uri.len = last - uri;
  823.         u->uri.data = uri;

  825.         last = uri;

  827.         if (uri < port) {
  828.             port = NULL;
  829.         }
  830.     }

  832.     if (port) {
  833.         port++;

  835.         len = last - port;

  837.         if (u->listen) {
  838.             dash = ngx_strlchr(port, last, '-');

  840.             if (dash) {
  841.                 dash++;

  843.                 n = ngx_atoi(dash, last - dash);

  845.                 if (n < 1 || n > 65535) {
  846.                     u->err = "invalid port";
  847.                     return NGX_ERROR;
  848.                 }

  850.                 u->last_port = (in_port_t) n;

  852.                 len = dash - port - 1;
  853.             }
  854.         }

  856.         n = ngx_atoi(port, len);

  858.         if (n < 1 || n > 65535) {
  859.             u->err = "invalid port";
  860.             return NGX_ERROR;
  861.         }

  863.         if (u->last_port && n > u->last_port) {
  864.             u->err = "invalid port range";
  865.             return NGX_ERROR;
  866.         }

  868.         u->port = (in_port_t) n;
  869.         sin->sin_port = htons((in_port_t) n);

  871.         u->port_text.len = last - port;
  872.         u->port_text.data = port;

  874.         last = port - 1;

  876.     } else {
  877.         if (uri == NULL) {

  879.             if (u->listen) {

  881.                 /* test value as port only */

  883.                 len = last - host;

  885.                 dash = ngx_strlchr(host, last, '-');

  887.                 if (dash) {
  888.                     dash++;

  890.                     n = ngx_atoi(dash, last - dash);

  892.                     if (n == NGX_ERROR) {
  893.                         goto no_port;
  894.                     }

  896.                     if (n < 1 || n > 65535) {
  897.                         u->err = "invalid port";

  899.                     } else {
  900.                         u->last_port = (in_port_t) n;
  901.                     }

  903.                     len = dash - host - 1;
  904.                 }

  906.                 n = ngx_atoi(host, len);

  908.                 if (n != NGX_ERROR) {

  910.                     if (u->err) {
  911.                         return NGX_ERROR;
  912.                     }

  914.                     if (n < 1 || n > 65535) {
  915.                         u->err = "invalid port";
  916.                         return NGX_ERROR;
  917.                     }

  919.                     if (u->last_port && n > u->last_port) {
  920.                         u->err = "invalid port range";
  921.                         return NGX_ERROR;
  922.                     }

  924.                     u->port = (in_port_t) n;
  925.                     sin->sin_port = htons((in_port_t) n);
  926.                     sin->sin_addr.s_addr = INADDR_ANY;

  928.                     u->port_text.len = last - host;
  929.                     u->port_text.data = host;

  931.                     u->wildcard = 1;

  933.                     return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr,
  934.                                              u->socklen, 1);
  935.                 }
  936.             }
  937.         }

  939. no_port:

  941.         u->err = NULL;
  942.         u->no_port = 1;
  943.         u->port = u->default_port;
  944.         sin->sin_port = htons(u->default_port);
  945.         u->last_port = 0;
  946.     }

  948.     len = last - host;

  950.     if (len == 0) {
  951.         u->err = "no host";
  952.         return NGX_ERROR;
  953.     }

  955.     u->host.len = len;
  956.     u->host.data = host;

  958.     if (u->listen && len == 1 && *host == '*') {
  959.         sin->sin_addr.s_addr = INADDR_ANY;
  960.         u->wildcard = 1;
  961.         return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr, u->socklen, 1);
  962.     }

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

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

  968.         if (sin->sin_addr.s_addr == INADDR_ANY) {
  969.             u->wildcard = 1;
  970.         }

  972.         return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr, u->socklen, 1);
  973.     }

  975.     if (u->no_resolve) {
  976.         return NGX_OK;
  977.     }

  979.     if (ngx_inet_resolve_host(pool, u) != NGX_OK) {
  980.         return NGX_ERROR;
  981.     }

  983.     u->family = u->addrs[0].sockaddr->sa_family;
  984.     u->socklen = u->addrs[0].socklen;
  985.     ngx_memcpy(&u->sockaddr, u->addrs[0].sockaddr, u->addrs[0].socklen);
  986.     u->wildcard = ngx_inet_wildcard(&u->sockaddr.sockaddr);

  988.     return NGX_OK;
  989. }


  992. static ngx_int_t
  993. ‌ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
  994. {
  995. #if (NGX_HAVE_INET6)
  996.     u_char               *p, *host, *port, *last, *uri, *dash;
  997.     size_t                len;
  998.     ngx_int_t             n;
  999.     struct sockaddr_in6  *sin6;

  1001.     u->socklen = sizeof(struct sockaddr_in6);
  1002.     sin6 = (struct sockaddr_in6 *) &u->sockaddr;
  1003.     sin6->sin6_family = AF_INET6;

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

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

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

  1011.     if (p == NULL) {
  1012.         u->err = "invalid host";
  1013.         return NGX_ERROR;
  1014.     }

  1016.     port = p + 1;

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

  1020.     if (uri) {
  1021.         if (u->listen || !u->uri_part) {
  1022.             u->err = "invalid host";
  1023.             return NGX_ERROR;
  1024.         }

  1026.         u->uri.len = last - uri;
  1027.         u->uri.data = uri;

  1029.         last = uri;
  1030.     }

  1032.     if (port < last) {
  1033.         if (*port != ':') {
  1034.             u->err = "invalid host";
  1035.             return NGX_ERROR;
  1036.         }

  1038.         port++;

  1040.         len = last - port;

  1042.         if (u->listen) {
  1043.             dash = ngx_strlchr(port, last, '-');

  1045.             if (dash) {
  1046.                 dash++;

  1048.                 n = ngx_atoi(dash, last - dash);

  1050.                 if (n < 1 || n > 65535) {
  1051.                     u->err = "invalid port";
  1052.                     return NGX_ERROR;
  1053.                 }

  1055.                 u->last_port = (in_port_t) n;

  1057.                 len = dash - port - 1;
  1058.             }
  1059.         }

  1061.         n = ngx_atoi(port, len);

  1063.         if (n < 1 || n > 65535) {
  1064.             u->err = "invalid port";
  1065.             return NGX_ERROR;
  1066.         }

  1068.         if (u->last_port && n > u->last_port) {
  1069.             u->err = "invalid port range";
  1070.             return NGX_ERROR;
  1071.         }

  1073.         u->port = (in_port_t) n;
  1074.         sin6->sin6_port = htons((in_port_t) n);

  1076.         u->port_text.len = last - port;
  1077.         u->port_text.data = port;

  1079.     } else {
  1080.         u->no_port = 1;
  1081.         u->port = u->default_port;
  1082.         sin6->sin6_port = htons(u->default_port);
  1083.     }

  1085.     len = p - host;

  1087.     if (len == 0) {
  1088.         u->err = "no host";
  1089.         return NGX_ERROR;
  1090.     }

  1092.     u->host.len = len + 2;
  1093.     u->host.data = host - 1;

  1095.     if (ngx_inet6_addr(host, len, sin6->sin6_addr.s6_addr) != NGX_OK) {
  1096.         u->err = "invalid IPv6 address";
  1097.         return NGX_ERROR;
  1098.     }

  1100.     if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  1101.         u->wildcard = 1;
  1102.     }

  1104.     u->family = AF_INET6;

  1106.     return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr, u->socklen, 1);

  1108. #else

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

  1112.     return NGX_ERROR;

  1114. #endif
  1115. }


  1118. #if (NGX_HAVE_GETADDRINFO && NGX_HAVE_INET6)

  1120. ngx_int_t
  1121. ‌ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
  1122. {
  1123.     u_char           *host;
  1124.     ngx_uint_t        n;
  1125.     struct addrinfo   hints, *res, *rp;

  1127.     host = ngx_alloc(u->host.len + 1, pool->log);
  1128.     if (host == NULL) {
  1129.         return NGX_ERROR;
  1130.     }

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

  1134.     ngx_memzero(&hints, sizeof(struct addrinfo));
  1135.     hints.ai_family = AF_UNSPEC;
  1136.     hints.ai_socktype = SOCK_STREAM;
  1137. #ifdef AI_ADDRCONFIG
  1138.     hints.ai_flags = AI_ADDRCONFIG;
  1139. #endif

  1141.     if (getaddrinfo((char *) host, NULL, &hints, &res) != 0) {
  1142.         u->err = "host not found";
  1143.         ngx_free(host);
  1144.         return NGX_ERROR;
  1145.     }

  1147.     ngx_free(host);

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

  1151.         switch (rp->ai_family) {

  1153.         case AF_INET:
  1154.         case AF_INET6:
  1155.             break;

  1157.         default:
  1158.             continue;
  1159.         }

  1161.         n++;
  1162.     }

  1164.     if (n == 0) {
  1165.         u->err = "host not found";
  1166.         goto failed;
  1167.     }

  1169.     /* MP: ngx_shared_palloc() */

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

  1173.         switch (rp->ai_family) {

  1175.         case AF_INET:
  1176.         case AF_INET6:
  1177.             break;

  1179.         default:
  1180.             continue;
  1181.         }

  1183.         if (ngx_inet_add_addr(pool, u, rp->ai_addr, rp->ai_addrlen, n)
  1184.             != NGX_OK)
  1185.         {
  1186.             goto failed;
  1187.         }
  1188.     }

  1190.     freeaddrinfo(res);
  1191.     return NGX_OK;

  1193. failed:

  1195.     freeaddrinfo(res);
  1196.     return NGX_ERROR;
  1197. }

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

  1201. ngx_int_t
  1202. ‌ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
  1203. {
  1204.     u_char              *host;
  1205.     ngx_uint_t           i, n;
  1206.     struct hostent      *h;
  1207.     struct sockaddr_in   sin;

  1209.     /* AF_INET only */

  1211.     ngx_memzero(&sin, sizeof(struct sockaddr_in));

  1213.     sin.sin_family = AF_INET;
  1214.     sin.sin_addr.s_addr = ngx_inet_addr(u->host.data, u->host.len);

  1216.     if (sin.sin_addr.s_addr == INADDR_NONE) {
  1217.         host = ngx_alloc(u->host.len + 1, pool->log);
  1218.         if (host == NULL) {
  1219.             return NGX_ERROR;
  1220.         }

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

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

  1226.         ngx_free(host);

  1228.         if (h == NULL || h->h_addr_list[0] == NULL) {
  1229.             u->err = "host not found";
  1230.             return NGX_ERROR;
  1231.         }

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

  1235.         /* MP: ngx_shared_palloc() */

  1237.         for (i = 0; i < n; i++) {
  1238.             sin.sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);

  1240.             if (ngx_inet_add_addr(pool, u, (struct sockaddr *) &sin,
  1241.                                   sizeof(struct sockaddr_in), n)
  1242.                 != NGX_OK)
  1243.             {
  1244.                 return NGX_ERROR;
  1245.             }
  1246.         }

  1248.     } else {

  1250.         /* MP: ngx_shared_palloc() */

  1252.         if (ngx_inet_add_addr(pool, u, (struct sockaddr *) &sin,
  1253.                               sizeof(struct sockaddr_in), 1)
  1254.             != NGX_OK)
  1255.         {
  1256.             return NGX_ERROR;
  1257.         }
  1258.     }

  1260.     return NGX_OK;
  1261. }

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


  1266. static ngx_int_t
  1267. ‌ngx_inet_add_addr(ngx_pool_t *pool, ngx_url_t *u, struct sockaddr *sockaddr,
  1268.     socklen_t socklen, ngx_uint_t total)
  1269. {
  1270.     u_char           *p;
  1271.     size_t            len;
  1272.     ngx_uint_t        i, nports;
  1273.     ngx_addr_t       *addr;
  1274.     struct sockaddr  *sa;

  1276.     nports = u->last_port ? u->last_port - u->port + 1 : 1;

  1278.     if (u->addrs == NULL) {
  1279.         u->addrs = ngx_palloc(pool, total * nports * sizeof(ngx_addr_t));
  1280.         if (u->addrs == NULL) {
  1281.             return NGX_ERROR;
  1282.         }
  1283.     }

  1285.     for (i = 0; i < nports; i++) {
  1286.         sa = ngx_pcalloc(pool, socklen);
  1287.         if (sa == NULL) {
  1288.             return NGX_ERROR;
  1289.         }

  1291.         ngx_memcpy(sa, sockaddr, socklen);

  1293.         ngx_inet_set_port(sa, u->port + i);

  1295.         switch (sa->sa_family) {

  1297. #if (NGX_HAVE_INET6)
  1298.         case AF_INET6:
  1299.             len = NGX_INET6_ADDRSTRLEN + sizeof("[]:65536") - 1;
  1300.             break;
  1301. #endif

  1303.         default: /* AF_INET */
  1304.             len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
  1305.         }

  1307.         p = ngx_pnalloc(pool, len);
  1308.         if (p == NULL) {
  1309.             return NGX_ERROR;
  1310.         }

  1312.         len = ngx_sock_ntop(sa, socklen, p, len, 1);

  1314.         addr = &u->addrs[u->naddrs++];

  1316.         addr->sockaddr = sa;
  1317.         addr->socklen = socklen;

  1319.         addr->name.len = len;
  1320.         addr->name.data = p;
  1321.     }

  1323.     return NGX_OK;
  1324. }


  1327. ngx_int_t
  1328. ‌ngx_cmp_sockaddr(struct sockaddr *sa1, socklen_t slen1,
  1329.     struct sockaddr *sa2, socklen_t slen2, ngx_uint_t cmp_port)
  1330. {
  1331.     struct sockaddr_in   *sin1, *sin2;
  1332. #if (NGX_HAVE_INET6)
  1333.     struct sockaddr_in6  *sin61, *sin62;
  1334. #endif
  1335. #if (NGX_HAVE_UNIX_DOMAIN)
  1336.     size_t                len;
  1337.     struct sockaddr_un   *saun1, *saun2;
  1338. #endif

  1340.     if (sa1->sa_family != sa2->sa_family) {
  1341.         return NGX_DECLINED;
  1342.     }

  1344.     switch (sa1->sa_family) {

  1346. #if (NGX_HAVE_INET6)
  1347.     case AF_INET6:

  1349.         sin61 = (struct sockaddr_in6 *) sa1;
  1350.         sin62 = (struct sockaddr_in6 *) sa2;

  1352.         if (cmp_port && sin61->sin6_port != sin62->sin6_port) {
  1353.             return NGX_DECLINED;
  1354.         }

  1356.         if (ngx_memcmp(&sin61->sin6_addr, &sin62->sin6_addr, 16) != 0) {
  1357.             return NGX_DECLINED;
  1358.         }

  1360.         break;
  1361. #endif

  1363. #if (NGX_HAVE_UNIX_DOMAIN)
  1364.     case AF_UNIX:

  1366.         saun1 = (struct sockaddr_un *) sa1;
  1367.         saun2 = (struct sockaddr_un *) sa2;

  1369.         if (slen1 < slen2) {
  1370.             len = slen1 - offsetof(struct sockaddr_un, sun_path);

  1372.         } else {
  1373.             len = slen2 - offsetof(struct sockaddr_un, sun_path);
  1374.         }

  1376.         if (len > sizeof(saun1->sun_path)) {
  1377.             len = sizeof(saun1->sun_path);
  1378.         }

  1380.         if (ngx_memcmp(&saun1->sun_path, &saun2->sun_path, len) != 0) {
  1381.             return NGX_DECLINED;
  1382.         }

  1384.         break;
  1385. #endif

  1387.     default: /* AF_INET */

  1389.         sin1 = (struct sockaddr_in *) sa1;
  1390.         sin2 = (struct sockaddr_in *) sa2;

  1392.         if (cmp_port && sin1->sin_port != sin2->sin_port) {
  1393.             return NGX_DECLINED;
  1394.         }

  1396.         if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) {
  1397.             return NGX_DECLINED;
  1398.         }

  1400.         break;
  1401.     }

  1403.     return NGX_OK;
  1404. }


  1407. in_port_t
  1408. ‌ngx_inet_get_port(struct sockaddr *sa)
  1409. {
  1410.     struct sockaddr_in   *sin;
  1411. #if (NGX_HAVE_INET6)
  1412.     struct sockaddr_in6  *sin6;
  1413. #endif

  1415.     switch (sa->sa_family) {

  1417. #if (NGX_HAVE_INET6)
  1418.     case AF_INET6:
  1419.         sin6 = (struct sockaddr_in6 *) sa;
  1420.         return ntohs(sin6->sin6_port);
  1421. #endif

  1423. #if (NGX_HAVE_UNIX_DOMAIN)
  1424.     case AF_UNIX:
  1425.         return 0;
  1426. #endif

  1428.     default: /* AF_INET */
  1429.         sin = (struct sockaddr_in *) sa;
  1430.         return ntohs(sin->sin_port);
  1431.     }
  1432. }


  1435. void
  1436. ‌ngx_inet_set_port(struct sockaddr *sa, in_port_t port)
  1437. {
  1438.     struct sockaddr_in   *sin;
  1439. #if (NGX_HAVE_INET6)
  1440.     struct sockaddr_in6  *sin6;
  1441. #endif

  1443.     switch (sa->sa_family) {

  1445. #if (NGX_HAVE_INET6)
  1446.     case AF_INET6:
  1447.         sin6 = (struct sockaddr_in6 *) sa;
  1448.         sin6->sin6_port = htons(port);
  1449.         break;
  1450. #endif

  1452. #if (NGX_HAVE_UNIX_DOMAIN)
  1453.     case AF_UNIX:
  1454.         break;
  1455. #endif

  1457.     default: /* AF_INET */
  1458.         sin = (struct sockaddr_in *) sa;
  1459.         sin->sin_port = htons(port);
  1460.         break;
  1461.     }
  1462. }


  1465. ngx_uint_t
  1466. ‌ngx_inet_wildcard(struct sockaddr *sa)
  1467. {
  1468.     struct sockaddr_in   *sin;
  1469. #if (NGX_HAVE_INET6)
  1470.     struct sockaddr_in6  *sin6;
  1471. #endif

  1473.     switch (sa->sa_family) {

  1475.     case AF_INET:
  1476.         sin = (struct sockaddr_in *) sa;

  1478.         if (sin->sin_addr.s_addr == INADDR_ANY) {
  1479.             return 1;
  1480.         }

  1482.         break;

  1484. #if (NGX_HAVE_INET6)

  1486.     case AF_INET6:
  1487.         sin6 = (struct sockaddr_in6 *) sa;

  1489.         if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  1490.             return 1;
  1491.         }

  1493.         break;

  1495. #endif
  1496.     }

  1498.     return 0;
  1499. }

One Level Up Top Level