release/src/router/nginx/src/core/ngx_inet.c

   1
   2 /*
   3  * Copyright (C) Igor Sysoev
   4  * Copyright (C) Nginx, Inc.
   5  */
   6
   7
   8 #include <ngx_config.h>
   9 #include <ngx_core.h>
  10
  11
  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
  16
  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;
  23
  24     addr = 0;
  25     octet = 0;
  26     n = 0;
  27
  28     for (p = text; p < text + len; p++) {
  29
  30         c = *p;
  31
  32         if (c >= '0' && c <= '9') {
  33             octet = octet * 10 + (c - '0');
  34             continue;
  35         }
  36
  37         if (c == '.' && octet < 256) {
  38             addr = (addr << 8) + octet;
  39             octet = 0;
  40             n++;
  41             continue;
  42         }
  43
  44         return INADDR_NONE;
  45     }
  46
  47     if (n == 3 && octet < 256) {
  48         addr = (addr << 8) + octet;
  49         return htonl(addr);
  50     }
  51
  52     return INADDR_NONE;
  53 }
  54
  55
  56 #if (NGX_HAVE_INET6)
  57
  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;
  64
  65     if (len == 0) {
  66         return NGX_ERROR;
  67     }
  68
  69     zero = NULL;
  70     digit = NULL;
  71     len4 = 0;
  72     nibbles = 0;
  73     word = 0;
  74     n = 8;
  75
  76     if (p[0] == ':') {
  77         p++;
  78         len--;
  79     }
  80
  81     for (/* void */; len; len--) {
  82         c = *p++;
  83
  84         if (c == ':') {
  85             if (nibbles) {
  86                 digit = p;
  87                 len4 = len;
  88                 *addr++ = (u_char) (word >> 8);
  89                 *addr++ = (u_char) (word & 0xff);
  90
  91                 if (--n) {
  92                     nibbles = 0;
  93                     word = 0;
  94                     continue;
  95                 }
  96
  97             } else {
  98                 if (zero == NULL) {
  99                     digit = p;
 100                     len4 = len;
 101                     zero = addr;
 102                     continue;
 103                 }
 104             }
 105
 106             return NGX_ERROR;
 107         }
 108
 109         if (c == '.' && nibbles) {
 110             if (n < 2 || digit == NULL) {
 111                 return NGX_ERROR;
 112             }
 113
 114             word = ngx_inet_addr(digit, len4 - 1);
 115             if (word == INADDR_NONE) {
 116                 return NGX_ERROR;
 117             }
 118
 119             word = ntohl(word);
 120             *addr++ = (u_char) ((word >> 24) & 0xff);
 121             *addr++ = (u_char) ((word >> 16) & 0xff);
 122             n--;
 123             break;
 124         }
 125
 126         if (++nibbles > 4) {
 127             return NGX_ERROR;
 128         }
 129
 130         if (c >= '0' && c <= '9') {
 131             word = word * 16 + (c - '0');
 132             continue;
 133         }
 134
 135         c |= 0x20;
 136
 137         if (c >= 'a' && c <= 'f') {
 138             word = word * 16 + (c - 'a') + 10;
 139             continue;
 140         }
 141
 142         return NGX_ERROR;
 143     }
 144
 145     if (nibbles == 0 && zero == NULL) {
 146         return NGX_ERROR;
 147     }
 148
 149     *addr++ = (u_char) (word >> 8);
 150     *addr++ = (u_char) (word & 0xff);
 151
 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         }
 163
 164     } else {
 165         if (zero == NULL) {
 166             return NGX_OK;
 167         }
 168     }
 169
 170     return NGX_ERROR;
 171 }
 172
 173 #endif
 174
 175
 176 size_t
 177 ngx_sock_ntop(struct sockaddr *sa, u_char *text, size_t len, ngx_uint_t port)
 178 {
 179     u_char               *p;
 180     struct sockaddr_in   *sin;
 181 #if (NGX_HAVE_INET6)
 182     size_t                n;
 183     struct sockaddr_in6  *sin6;
 184 #endif
 185 #if (NGX_HAVE_UNIX_DOMAIN)
 186     struct sockaddr_un   *saun;
 187 #endif
 188
 189     switch (sa->sa_family) {
 190
 191     case AF_INET:
 192
 193         sin = (struct sockaddr_in *) sa;
 194         p = (u_char *) &sin->sin_addr;
 195
 196         if (port) {
 197             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud:%d",
 198                              p[0], p[1], p[2], p[3], ntohs(sin->sin_port));
 199         } else {
 200             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
 201                              p[0], p[1], p[2], p[3]);
 202         }
 203
 204         return (p - text);
 205
 206 #if (NGX_HAVE_INET6)
 207
 208     case AF_INET6:
 209
 210         sin6 = (struct sockaddr_in6 *) sa;
 211
 212         n = 0;
 213
 214         if (port) {
 215             text[n++] = '[';
 216         }
 217
 218         n = ngx_inet6_ntop(sin6->sin6_addr.s6_addr, &text[n], len);
 219
 220         if (port) {
 221             n = ngx_sprintf(&text[1 + n], "]:%d",
 222                             ntohs(sin6->sin6_port)) - text;
 223         }
 224
 225         return n;
 226 #endif
 227
 228 #if (NGX_HAVE_UNIX_DOMAIN)
 229
 230     case AF_UNIX:
 231         saun = (struct sockaddr_un *) sa;
 232
 233         /* we do not include trailing zero in address length */
 234
 235         return ngx_snprintf(text, len, "unix:%s%Z", saun->sun_path) - text - 1;
 236
 237 #endif
 238
 239     default:
 240         return 0;
 241     }
 242 }
 243
 244
 245 size_t
 246 ngx_inet_ntop(int family, void *addr, u_char *text, size_t len)
 247 {
 248     u_char  *p;
 249
 250     switch (family) {
 251
 252     case AF_INET:
 253
 254         p = addr;
 255
 256         return ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
 257                             p[0], p[1], p[2], p[3])
 258                - text;
 259
 260 #if (NGX_HAVE_INET6)
 261
 262     case AF_INET6:
 263         return ngx_inet6_ntop(addr, text, len);
 264
 265 #endif
 266
 267     default:
 268         return 0;
 269     }
 270 }
 271
 272
 273 #if (NGX_HAVE_INET6)
 274
 275 size_t
 276 ngx_inet6_ntop(u_char *p, u_char *text, size_t len)
 277 {
 278     u_char      *dst;
 279     size_t       max, n;
 280     ngx_uint_t   i, zero, last;
 281
 282     if (len < NGX_INET6_ADDRSTRLEN) {
 283         return 0;
 284     }
 285
 286     zero = (ngx_uint_t) -1;
 287     last = (ngx_uint_t) -1;
 288     max = 1;
 289     n = 0;
 290
 291     for (i = 0; i < 16; i += 2) {
 292
 293         if (p[i] || p[i + 1]) {
 294
 295             if (max < n) {
 296                 zero = last;
 297                 max = n;
 298             }
 299
 300             n = 0;
 301             continue;
 302         }
 303
 304         if (n++ == 0) {
 305             last = i;
 306         }
 307     }
 308
 309     if (max < n) {
 310         zero = last;
 311         max = n;
 312     }
 313
 314     dst = text;
 315     n = 16;
 316
 317     if (zero == 0) {
 318
 319         if ((max == 5 && p[10] == 0xff && p[11] == 0xff)
 320             || (max == 6)
 321             || (max == 7 && p[14] != 0 && p[15] != 1))
 322         {
 323             n = 12;
 324         }
 325
 326         *dst++ = ':';
 327     }
 328
 329     for (i = 0; i < n; i += 2) {
 330
 331         if (i == zero) {
 332             *dst++ = ':';
 333             i += (max - 1) * 2;
 334             continue;
 335         }
 336
 337         dst = ngx_sprintf(dst, "%uxi", p[i] * 256 + p[i + 1]);
 338
 339         if (i < 14) {
 340             *dst++ = ':';
 341         }
 342     }
 343
 344     if (n == 12) {
 345         dst = ngx_sprintf(dst, "%ud.%ud.%ud.%ud", p[12], p[13], p[14], p[15]);
 346     }
 347
 348     return dst - text;
 349 }
 350
 351 #endif
 352
 353
 354 ngx_int_t
 355 ngx_ptocidr(ngx_str_t *text, ngx_cidr_t *cidr)
 356 {
 357     u_char      *addr, *mask, *last;
 358     size_t       len;
 359     ngx_int_t    shift;
 360 #if (NGX_HAVE_INET6)
 361     ngx_int_t    rc;
 362     ngx_uint_t   s, i;
 363 #endif
 364
 365     addr = text->data;
 366     last = addr + text->len;
 367
 368     mask = ngx_strlchr(addr, last, '/');
 369     len = (mask ? mask : last) - addr;
 370
 371     cidr->u.in.addr = ngx_inet_addr(addr, len);
 372
 373     if (cidr->u.in.addr != INADDR_NONE) {
 374         cidr->family = AF_INET;
 375
 376         if (mask == NULL) {
 377             cidr->u.in.mask = 0xffffffff;
 378             return NGX_OK;
 379         }
 380
 381 #if (NGX_HAVE_INET6)
 382     } else if (ngx_inet6_addr(addr, len, cidr->u.in6.addr.s6_addr) == NGX_OK) {
 383         cidr->family = AF_INET6;
 384
 385         if (mask == NULL) {
 386             ngx_memset(cidr->u.in6.mask.s6_addr, 0xff, 16);
 387             return NGX_OK;
 388         }
 389
 390 #endif
 391     } else {
 392         return NGX_ERROR;
 393     }
 394
 395     mask++;
 396
 397     shift = ngx_atoi(mask, last - mask);
 398     if (shift == NGX_ERROR) {
 399         return NGX_ERROR;
 400     }
 401
 402     switch (cidr->family) {
 403
 404 #if (NGX_HAVE_INET6)
 405     case AF_INET6:
 406         if (shift > 128) {
 407             return NGX_ERROR;
 408         }
 409
 410         addr = cidr->u.in6.addr.s6_addr;
 411         mask = cidr->u.in6.mask.s6_addr;
 412         rc = NGX_OK;
 413
 414         for (i = 0; i < 16; i++) {
 415
 416             s = (shift > 8) ? 8 : shift;
 417             shift -= s;
 418
 419             mask[i] = (u_char) (0xffu << (8 - s));
 420
 421             if (addr[i] != (addr[i] & mask[i])) {
 422                 rc = NGX_DONE;
 423                 addr[i] &= mask[i];
 424             }
 425         }
 426
 427         return rc;
 428 #endif
 429
 430     default: /* AF_INET */
 431         if (shift > 32) {
 432             return NGX_ERROR;
 433         }
 434
 435         if (shift) {
 436             cidr->u.in.mask = htonl((uint32_t) (0xffffffffu << (32 - shift)));
 437
 438         } else {
 439             /* x86 compilers use a shl instruction that shifts by modulo 32 */
 440             cidr->u.in.mask = 0;
 441         }
 442
 443         if (cidr->u.in.addr == (cidr->u.in.addr & cidr->u.in.mask)) {
 444             return NGX_OK;
 445         }
 446
 447         cidr->u.in.addr &= cidr->u.in.mask;
 448
 449         return NGX_DONE;
 450     }
 451 }
 452
 453
 454 ngx_int_t
 455 ngx_parse_addr(ngx_pool_t *pool, ngx_addr_t *addr, u_char *text, size_t len)
 456 {
 457     in_addr_t             inaddr;
 458     ngx_uint_t            family;
 459     struct sockaddr_in   *sin;
 460 #if (NGX_HAVE_INET6)
 461     struct in6_addr       inaddr6;
 462     struct sockaddr_in6  *sin6;
 463
 464     /*
 465      * prevent MSVC8 warning:
 466      *    potentially uninitialized local variable 'inaddr6' used
 467      */
 468     ngx_memzero(&inaddr6, sizeof(struct in6_addr));
 469 #endif
 470
 471     inaddr = ngx_inet_addr(text, len);
 472
 473     if (inaddr != INADDR_NONE) {
 474         family = AF_INET;
 475         len = sizeof(struct sockaddr_in);
 476
 477 #if (NGX_HAVE_INET6)
 478     } else if (ngx_inet6_addr(text, len, inaddr6.s6_addr) == NGX_OK) {
 479         family = AF_INET6;
 480         len = sizeof(struct sockaddr_in6);
 481
 482 #endif
 483     } else {
 484         return NGX_DECLINED;
 485     }
 486
 487     addr->sockaddr = ngx_pcalloc(pool, len);
 488     if (addr->sockaddr == NULL) {
 489         return NGX_ERROR;
 490     }
 491
 492     addr->sockaddr->sa_family = (u_char) family;
 493     addr->socklen = len;
 494
 495     switch (family) {
 496
 497 #if (NGX_HAVE_INET6)
 498     case AF_INET6:
 499         sin6 = (struct sockaddr_in6 *) addr->sockaddr;
 500         ngx_memcpy(sin6->sin6_addr.s6_addr, inaddr6.s6_addr, 16);
 501         break;
 502 #endif
 503
 504     default: /* AF_INET */
 505         sin = (struct sockaddr_in *) addr->sockaddr;
 506         sin->sin_addr.s_addr = inaddr;
 507         break;
 508     }
 509
 510     return NGX_OK;
 511 }
 512
 513
 514 ngx_int_t
 515 ngx_parse_url(ngx_pool_t *pool, ngx_url_t *u)
 516 {
 517     u_char  *p;
 518
 519     p = u->url.data;
 520
 521     if (ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0) {
 522         return ngx_parse_unix_domain_url(pool, u);
 523     }
 524
 525     if (p[0] == '[') {
 526         return ngx_parse_inet6_url(pool, u);
 527     }
 528
 529     return ngx_parse_inet_url(pool, u);
 530 }
 531
 532
 533 static ngx_int_t
 534 ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u)
 535 {
 536 #if (NGX_HAVE_UNIX_DOMAIN)
 537     u_char              *path, *uri, *last;
 538     size_t               len;
 539     struct sockaddr_un  *saun;
 540
 541     len = u->url.len;
 542     path = u->url.data;
 543
 544     path += 5;
 545     len -= 5;
 546
 547     if (u->uri_part) {
 548
 549         last = path + len;
 550         uri = ngx_strlchr(path, last, ':');
 551
 552         if (uri) {
 553             len = uri - path;
 554             uri++;
 555             u->uri.len = last - uri;
 556             u->uri.data = uri;
 557         }
 558     }
 559
 560     if (len == 0) {
 561         u->err = "no path in the unix domain socket";
 562         return NGX_ERROR;
 563     }
 564
 565     u->host.len = len++;
 566     u->host.data = path;
 567
 568     if (len > sizeof(saun->sun_path)) {
 569         u->err = "too long path in the unix domain socket";
 570         return NGX_ERROR;
 571     }
 572
 573     u->socklen = sizeof(struct sockaddr_un);
 574     saun = (struct sockaddr_un *) &u->sockaddr;
 575     saun->sun_family = AF_UNIX;
 576     (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);
 577
 578     u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
 579     if (u->addrs == NULL) {
 580         return NGX_ERROR;
 581     }
 582
 583     saun = ngx_pcalloc(pool, sizeof(struct sockaddr_un));
 584     if (saun == NULL) {
 585         return NGX_ERROR;
 586     }
 587
 588     u->family = AF_UNIX;
 589     u->naddrs = 1;
 590
 591     saun->sun_family = AF_UNIX;
 592     (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);
 593
 594     u->addrs[0].sockaddr = (struct sockaddr *) saun;
 595     u->addrs[0].socklen = sizeof(struct sockaddr_un);
 596     u->addrs[0].name.len = len + 4;
 597     u->addrs[0].name.data = u->url.data;
 598
 599     return NGX_OK;
 600
 601 #else
 602
 603     u->err = "the unix domain sockets are not supported on this platform";
 604
 605     return NGX_ERROR;
 606
 607 #endif
 608 }
 609
 610
 611 static ngx_int_t
 612 ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
 613 {
 614     u_char               *p, *host, *port, *last, *uri, *args;
 615     size_t                len;
 616     ngx_int_t             n;
 617     struct sockaddr_in   *sin;
 618 #if (NGX_HAVE_INET6)
 619     struct sockaddr_in6  *sin6;
 620 #endif
 621
 622     u->socklen = sizeof(struct sockaddr_in);
 623     sin = (struct sockaddr_in *) &u->sockaddr;
 624     sin->sin_family = AF_INET;
 625
 626     u->family = AF_INET;
 627
 628     host = u->url.data;
 629
 630     last = host + u->url.len;
 631
 632     port = ngx_strlchr(host, last, ':');
 633
 634     uri = ngx_strlchr(host, last, '/');
 635
 636     args = ngx_strlchr(host, last, '?');
 637
 638     if (args) {
 639         if (uri == NULL || args < uri) {
 640             uri = args;
 641         }
 642     }
 643
 644     if (uri) {
 645         if (u->listen || !u->uri_part) {
 646             u->err = "invalid host";
 647             return NGX_ERROR;
 648         }
 649
 650         u->uri.len = last - uri;
 651         u->uri.data = uri;
 652
 653         last = uri;
 654
 655         if (uri < port) {
 656             port = NULL;
 657         }
 658     }
 659
 660     if (port) {
 661         port++;
 662
 663         len = last - port;
 664
 665         n = ngx_atoi(port, len);
 666
 667         if (n < 1 || n > 65535) {
 668             u->err = "invalid port";
 669             return NGX_ERROR;
 670         }
 671
 672         u->port = (in_port_t) n;
 673         sin->sin_port = htons((in_port_t) n);
 674
 675         u->port_text.len = len;
 676         u->port_text.data = port;
 677
 678         last = port - 1;
 679
 680     } else {
 681         if (uri == NULL) {
 682
 683             if (u->listen) {
 684
 685                 /* test value as port only */
 686
 687                 n = ngx_atoi(host, last - host);
 688
 689                 if (n != NGX_ERROR) {
 690
 691                     if (n < 1 || n > 65535) {
 692                         u->err = "invalid port";
 693                         return NGX_ERROR;
 694                     }
 695
 696                     u->port = (in_port_t) n;
 697                     sin->sin_port = htons((in_port_t) n);
 698
 699                     u->port_text.len = last - host;
 700                     u->port_text.data = host;
 701
 702                     u->wildcard = 1;
 703
 704                     return NGX_OK;
 705                 }
 706             }
 707         }
 708
 709         u->no_port = 1;
 710         u->port = u->default_port;
 711         sin->sin_port = htons(u->default_port);
 712     }
 713
 714     len = last - host;
 715
 716     if (len == 0) {
 717         u->err = "no host";
 718         return NGX_ERROR;
 719     }
 720
 721     u->host.len = len;
 722     u->host.data = host;
 723
 724     if (u->listen && len == 1 && *host == '*') {
 725         sin->sin_addr.s_addr = INADDR_ANY;
 726         u->wildcard = 1;
 727         return NGX_OK;
 728     }
 729
 730     sin->sin_addr.s_addr = ngx_inet_addr(host, len);
 731
 732     if (sin->sin_addr.s_addr != INADDR_NONE) {
 733
 734         if (sin->sin_addr.s_addr == INADDR_ANY) {
 735             u->wildcard = 1;
 736         }
 737
 738         u->naddrs = 1;
 739
 740         u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
 741         if (u->addrs == NULL) {
 742             return NGX_ERROR;
 743         }
 744
 745         sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
 746         if (sin == NULL) {
 747             return NGX_ERROR;
 748         }
 749
 750         ngx_memcpy(sin, u->sockaddr, sizeof(struct sockaddr_in));
 751
 752         u->addrs[0].sockaddr = (struct sockaddr *) sin;
 753         u->addrs[0].socklen = sizeof(struct sockaddr_in);
 754
 755         p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
 756         if (p == NULL) {
 757             return NGX_ERROR;
 758         }
 759
 760         u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
 761                                            &u->host, u->port) - p;
 762         u->addrs[0].name.data = p;
 763
 764         return NGX_OK;
 765     }
 766
 767     if (u->no_resolve) {
 768         return NGX_OK;
 769     }
 770
 771     if (ngx_inet_resolve_host(pool, u) != NGX_OK) {
 772         return NGX_ERROR;
 773     }
 774
 775     u->family = u->addrs[0].sockaddr->sa_family;
 776     u->socklen = u->addrs[0].socklen;
 777     ngx_memcpy(u->sockaddr, u->addrs[0].sockaddr, u->addrs[0].socklen);
 778
 779     switch (u->family) {
 780
 781 #if (NGX_HAVE_INET6)
 782     case AF_INET6:
 783         sin6 = (struct sockaddr_in6 *) &u->sockaddr;
 784
 785         if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
 786             u->wildcard = 1;
 787         }
 788
 789         break;
 790 #endif
 791
 792     default: /* AF_INET */
 793         sin = (struct sockaddr_in *) &u->sockaddr;
 794
 795         if (sin->sin_addr.s_addr == INADDR_ANY) {
 796             u->wildcard = 1;
 797         }
 798
 799         break;
 800     }
 801
 802     return NGX_OK;
 803 }
 804
 805
 806 static ngx_int_t
 807 ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
 808 {
 809 #if (NGX_HAVE_INET6)
 810     u_char               *p, *host, *port, *last, *uri;
 811     size_t                len;
 812     ngx_int_t             n;
 813     struct sockaddr_in6  *sin6;
 814
 815     u->socklen = sizeof(struct sockaddr_in6);
 816     sin6 = (struct sockaddr_in6 *) &u->sockaddr;
 817     sin6->sin6_family = AF_INET6;
 818
 819     host = u->url.data + 1;
 820
 821     last = u->url.data + u->url.len;
 822
 823     p = ngx_strlchr(host, last, ']');
 824
 825     if (p == NULL) {
 826         u->err = "invalid host";
 827         return NGX_ERROR;
 828     }
 829
 830     if (last - p) {
 831
 832         port = p + 1;
 833
 834         uri = ngx_strlchr(port, last, '/');
 835
 836         if (uri) {
 837             if (u->listen || !u->uri_part) {
 838                 u->err = "invalid host";
 839                 return NGX_ERROR;
 840             }
 841
 842             u->uri.len = last - uri;
 843             u->uri.data = uri;
 844
 845             last = uri;
 846         }
 847
 848         if (*port == ':') {
 849             port++;
 850
 851             len = last - port;
 852
 853             n = ngx_atoi(port, len);
 854
 855             if (n < 1 || n > 65535) {
 856                 u->err = "invalid port";
 857                 return NGX_ERROR;
 858             }
 859
 860             u->port = (in_port_t) n;
 861             sin6->sin6_port = htons((in_port_t) n);
 862
 863             u->port_text.len = len;
 864             u->port_text.data = port;
 865
 866         } else {
 867             u->no_port = 1;
 868             u->port = u->default_port;
 869             sin6->sin6_port = htons(u->default_port);
 870         }
 871     }
 872
 873     len = p - host;
 874
 875     if (len == 0) {
 876         u->err = "no host";
 877         return NGX_ERROR;
 878     }
 879
 880     u->host.len = len + 2;
 881     u->host.data = host - 1;
 882
 883     if (ngx_inet6_addr(host, len, sin6->sin6_addr.s6_addr) != NGX_OK) {
 884         u->err = "invalid IPv6 address";
 885         return NGX_ERROR;
 886     }
 887
 888     if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
 889         u->wildcard = 1;
 890     }
 891
 892     u->family = AF_INET6;
 893     u->naddrs = 1;
 894
 895     u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
 896     if (u->addrs == NULL) {
 897         return NGX_ERROR;
 898     }
 899
 900     sin6 = ngx_pcalloc(pool, sizeof(struct sockaddr_in6));
 901     if (sin6 == NULL) {
 902         return NGX_ERROR;
 903     }
 904
 905     ngx_memcpy(sin6, u->sockaddr, sizeof(struct sockaddr_in6));
 906
 907     u->addrs[0].sockaddr = (struct sockaddr *) sin6;
 908     u->addrs[0].socklen = sizeof(struct sockaddr_in6);
 909
 910     p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
 911     if (p == NULL) {
 912         return NGX_ERROR;
 913     }
 914
 915     u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
 916                                        &u->host, u->port) - p;
 917     u->addrs[0].name.data = p;
 918
 919     return NGX_OK;
 920
 921 #else
 922
 923     u->err = "the INET6 sockets are not supported on this platform";
 924
 925     return NGX_ERROR;
 926
 927 #endif
 928 }
 929
 930
 931 #if (NGX_HAVE_GETADDRINFO && NGX_HAVE_INET6)
 932
 933 ngx_int_t
 934 ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
 935 {
 936     u_char               *p, *host;
 937     size_t                len;
 938     in_port_t             port;
 939     ngx_uint_t            i;
 940     struct addrinfo       hints, *res, *rp;
 941     struct sockaddr_in   *sin;
 942     struct sockaddr_in6  *sin6;
 943
 944     port = htons(u->port);
 945
 946     host = ngx_alloc(u->host.len + 1, pool->log);
 947     if (host == NULL) {
 948         return NGX_ERROR;
 949     }
 950
 951     (void) ngx_cpystrn(host, u->host.data, u->host.len + 1);
 952
 953     ngx_memzero(&hints, sizeof(struct addrinfo));
 954     hints.ai_family = AF_UNSPEC;
 955     hints.ai_socktype = SOCK_STREAM;
 956
 957     if (getaddrinfo((char *) host, NULL, &hints, &res) != 0) {
 958         u->err = "host not found";
 959         ngx_free(host);
 960         return NGX_ERROR;
 961     }
 962
 963     ngx_free(host);
 964
 965     for (i = 0, rp = res; rp != NULL; rp = rp->ai_next) {
 966
 967         switch (rp->ai_family) {
 968
 969         case AF_INET:
 970         case AF_INET6:
 971             break;
 972
 973         default:
 974             continue;
 975         }
 976
 977         i++;
 978     }
 979
 980     if (i == 0) {
 981         u->err = "host not found";
 982         goto failed;
 983     }
 984
 985     /* MP: ngx_shared_palloc() */
 986
 987     u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_addr_t));
 988     if (u->addrs == NULL) {
 989         goto failed;
 990     }
 991
 992     u->naddrs = i;
 993
 994     i = 0;
 995
 996     /* AF_INET addresses first */
 997
 998     for (rp = res; rp != NULL; rp = rp->ai_next) {
 999
1000         if (rp->ai_family != AF_INET) {
1001             continue;
1002         }
1003
1004         sin = ngx_pcalloc(pool, rp->ai_addrlen);
1005         if (sin == NULL) {
1006             goto failed;
1007         }
1008
1009         ngx_memcpy(sin, rp->ai_addr, rp->ai_addrlen);
1010
1011         sin->sin_port = port;
1012
1013         u->addrs[i].sockaddr = (struct sockaddr *) sin;
1014         u->addrs[i].socklen = rp->ai_addrlen;
1015
1016         len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
1017
1018         p = ngx_pnalloc(pool, len);
1019         if (p == NULL) {
1020             goto failed;
1021         }
1022
1023         len = ngx_sock_ntop((struct sockaddr *) sin, p, len, 1);
1024
1025         u->addrs[i].name.len = len;
1026         u->addrs[i].name.data = p;
1027
1028         i++;
1029     }
1030
1031     for (rp = res; rp != NULL; rp = rp->ai_next) {
1032
1033         if (rp->ai_family != AF_INET6) {
1034             continue;
1035         }
1036
1037         sin6 = ngx_pcalloc(pool, rp->ai_addrlen);
1038         if (sin6 == NULL) {
1039             goto failed;
1040         }
1041
1042         ngx_memcpy(sin6, rp->ai_addr, rp->ai_addrlen);
1043
1044         sin6->sin6_port = port;
1045
1046         u->addrs[i].sockaddr = (struct sockaddr *) sin6;
1047         u->addrs[i].socklen = rp->ai_addrlen;
1048
1049         len = NGX_INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;
1050
1051         p = ngx_pnalloc(pool, len);
1052         if (p == NULL) {
1053             goto failed;
1054         }
1055
1056         len = ngx_sock_ntop((struct sockaddr *) sin6, p, len, 1);
1057
1058         u->addrs[i].name.len = len;
1059         u->addrs[i].name.data = p;
1060
1061         i++;
1062     }
1063
1064     freeaddrinfo(res);
1065     return NGX_OK;
1066
1067 failed:
1068
1069     freeaddrinfo(res);
1070     return NGX_ERROR;
1071 }
1072
1073 #else /* !NGX_HAVE_GETADDRINFO || !NGX_HAVE_INET6 */
1074
1075 ngx_int_t
1076 ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
1077 {
1078     u_char              *p, *host;
1079     size_t               len;
1080     in_port_t            port;
1081     in_addr_t            in_addr;
1082     ngx_uint_t           i;
1083     struct hostent      *h;
1084     struct sockaddr_in  *sin;
1085
1086     /* AF_INET only */
1087
1088     port = htons(u->port);
1089
1090     in_addr = ngx_inet_addr(u->host.data, u->host.len);
1091
1092     if (in_addr == INADDR_NONE) {
1093         host = ngx_alloc(u->host.len + 1, pool->log);
1094         if (host == NULL) {
1095             return NGX_ERROR;
1096         }
1097
1098         (void) ngx_cpystrn(host, u->host.data, u->host.len + 1);
1099
1100         h = gethostbyname((char *) host);
1101
1102         ngx_free(host);
1103
1104         if (h == NULL || h->h_addr_list[0] == NULL) {
1105             u->err = "host not found";
1106             return NGX_ERROR;
1107         }
1108
1109         for (i = 0; h->h_addr_list[i] != NULL; i++) { /* void */ }
1110
1111         /* MP: ngx_shared_palloc() */
1112
1113         u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_addr_t));
1114         if (u->addrs == NULL) {
1115             return NGX_ERROR;
1116         }
1117
1118         u->naddrs = i;
1119
1120         for (i = 0; i < u->naddrs; i++) {
1121
1122             sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
1123             if (sin == NULL) {
1124                 return NGX_ERROR;
1125             }
1126
1127             sin->sin_family = AF_INET;
1128             sin->sin_port = port;
1129             sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);
1130
1131             u->addrs[i].sockaddr = (struct sockaddr *) sin;
1132             u->addrs[i].socklen = sizeof(struct sockaddr_in);
1133
1134             len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
1135
1136             p = ngx_pnalloc(pool, len);
1137             if (p == NULL) {
1138                 return NGX_ERROR;
1139             }
1140
1141             len = ngx_sock_ntop((struct sockaddr *) sin, p, len, 1);
1142
1143             u->addrs[i].name.len = len;
1144             u->addrs[i].name.data = p;
1145         }
1146
1147     } else {
1148
1149         /* MP: ngx_shared_palloc() */
1150
1151         u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
1152         if (u->addrs == NULL) {
1153             return NGX_ERROR;
1154         }
1155
1156         sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
1157         if (sin == NULL) {
1158             return NGX_ERROR;
1159         }
1160
1161         u->naddrs = 1;
1162
1163         sin->sin_family = AF_INET;
1164         sin->sin_port = port;
1165         sin->sin_addr.s_addr = in_addr;
1166
1167         u->addrs[0].sockaddr = (struct sockaddr *) sin;
1168         u->addrs[0].socklen = sizeof(struct sockaddr_in);
1169
1170         p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
1171         if (p == NULL) {
1172             return NGX_ERROR;
1173         }
1174
1175         u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
1176                                            &u->host, ntohs(port)) - p;
1177         u->addrs[0].name.data = p;
1178     }
1179
1180     return NGX_OK;
1181 }
1182
1183 #endif /* NGX_HAVE_GETADDRINFO && NGX_HAVE_INET6 */