nginx/src/core/ngx_inet.c

   1
   2 /*
   3  * Copyright (C) Igor Sysoev
   4  */
   5
   6
   7 #include <ngx_config.h>
   8 #include <ngx_core.h>
   9
  10
  11 #if (NGX_HAVE_INET6)
  12 static size_t ngx_inet6_ntop(u_char *p, u_char *text, size_t len);
  13 #endif
  14 static ngx_int_t ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u);
  15 static ngx_int_t ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u);
  16 static ngx_int_t ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u);
  17
  18
  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;
  25
  26     addr = 0;
  27     octet = 0;
  28     n = 0;
  29
  30     for (p = text; p < text + len; p++) {
  31
  32         c = *p;
  33
  34         if (c >= '0' && c <= '9') {
  35             octet = octet * 10 + (c - '0');
  36             continue;
  37         }
  38
  39         if (c == '.' && octet < 256) {
  40             addr = (addr << 8) + octet;
  41             octet = 0;
  42             n++;
  43             continue;
  44         }
  45
  46         return INADDR_NONE;
  47     }
  48
  49     if (n != 3) {
  50         return INADDR_NONE;
  51     }
  52
  53     if (octet < 256) {
  54         addr = (addr << 8) + octet;
  55         return htonl(addr);
  56     }
  57
  58     return INADDR_NONE;
  59 }
  60
  61
  62 size_t
  63 ngx_sock_ntop(struct sockaddr *sa, u_char *text, size_t len, ngx_uint_t port)
  64 {
  65     u_char               *p;
  66     struct sockaddr_in   *sin;
  67 #if (NGX_HAVE_INET6)
  68     size_t                n;
  69     struct sockaddr_in6  *sin6;
  70 #endif
  71
  72     switch (sa->sa_family) {
  73
  74     case AF_INET:
  75
  76         sin = (struct sockaddr_in *) sa;
  77         p = (u_char *) &sin->sin_addr;
  78
  79         if (port) {
  80             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud:%d",
  81                              p[0], p[1], p[2], p[3], ntohs(sin->sin_port));
  82         } else {
  83             p = ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
  84                              p[0], p[1], p[2], p[3]);
  85         }
  86
  87         return (p - text);
  88
  89 #if (NGX_HAVE_INET6)
  90
  91     case AF_INET6:
  92
  93         sin6 = (struct sockaddr_in6 *) sa;
  94
  95         n = 0;
  96
  97         if (port) {
  98             text[n++] = '[';
  99         }
 100
 101         n = ngx_inet6_ntop((u_char *) &sin6->sin6_addr, &text[n], len);
 102
 103         if (port) {
 104             n = ngx_sprintf(&text[1 + n], "]:%d",
 105                             ntohs(sin6->sin6_port)) - text;
 106         }
 107
 108         return n;
 109 #endif
 110
 111     default:
 112         return 0;
 113     }
 114 }
 115
 116
 117 size_t
 118 ngx_inet_ntop(int family, void *addr, u_char *text, size_t len)
 119 {
 120     u_char  *p;
 121
 122     switch (family) {
 123
 124     case AF_INET:
 125
 126         p = addr;
 127
 128         return ngx_snprintf(text, len, "%ud.%ud.%ud.%ud",
 129                             p[0], p[1], p[2], p[3])
 130                - text;
 131
 132 #if (NGX_HAVE_INET6)
 133
 134     case AF_INET6:
 135         return ngx_inet6_ntop(addr, text, len);
 136
 137 #endif
 138
 139     default:
 140         return 0;
 141     }
 142 }
 143
 144
 145 #if (NGX_HAVE_INET6)
 146
 147 static size_t
 148 ngx_inet6_ntop(u_char *p, u_char *text, size_t len)
 149 {
 150     u_char      *dst;
 151     size_t       max, n;
 152     ngx_uint_t   i, zero, last;
 153
 154     if (len < NGX_INET6_ADDRSTRLEN) {
 155         return 0;
 156     }
 157
 158     zero = (ngx_uint_t) -1;
 159     last = (ngx_uint_t) -1;
 160     max = 1;
 161     n = 0;
 162
 163     for (i = 0; i < 16; i += 2) {
 164
 165         if (p[i] || p[i + 1]) {
 166
 167             if (max < n) {
 168                 zero = last;
 169                 max = n;
 170             }
 171
 172             n = 0;
 173             continue;
 174         }
 175
 176         if (n++ == 0) {
 177             last = i;
 178         }
 179     }
 180
 181     if (max < n) {
 182         zero = last;
 183         max = n;
 184     }
 185
 186     dst = text;
 187     n = 16;
 188
 189     if (zero == 0) {
 190
 191         if ((max == 5 && p[10] == 0xff && p[11] == 0xff)
 192             || (max == 6)
 193             || (max == 7 && p[14] != 0 && p[15] != 1))
 194         {
 195             n = 12;
 196         }
 197
 198         *dst++ = ':';
 199     }
 200
 201     for (i = 0; i < n; i += 2) {
 202
 203         if (i == zero) {
 204             *dst++ = ':';
 205             i += (max - 1) * 2;
 206             continue;
 207         }
 208
 209         dst = ngx_sprintf(dst, "%uxi", p[i] * 256 + p[i + 1]);
 210
 211         if (i < 14) {
 212             *dst++ = ':';
 213         }
 214     }
 215
 216     if (n == 12) {
 217         dst = ngx_sprintf(dst, "%ud.%ud.%ud.%ud", p[12], p[13], p[14], p[15]);
 218     }
 219
 220     return dst - text;
 221 }
 222
 223 #endif
 224
 225
 226 /* AF_INET only */
 227
 228 ngx_int_t
 229 ngx_ptocidr(ngx_str_t *text, void *cidr)
 230 {
 231     u_char           *addr, *mask, *last;
 232     ngx_int_t         shift;
 233     ngx_inet_cidr_t  *in_cidr;
 234
 235     in_cidr = cidr;
 236     addr = text->data;
 237     last = addr + text->len;
 238
 239     mask = ngx_strlchr(addr, last, '/');
 240
 241     in_cidr->addr = ngx_inet_addr(addr, (mask ? mask : last) - addr);
 242
 243     if (in_cidr->addr == INADDR_NONE) {
 244         return NGX_ERROR;
 245     }
 246
 247     if (mask == NULL) {
 248         in_cidr->mask = 0xffffffff;
 249         return NGX_OK;
 250     }
 251
 252     mask++;
 253
 254     shift = ngx_atoi(mask, last - mask);
 255     if (shift == NGX_ERROR) {
 256         return NGX_ERROR;
 257     }
 258
 259     if (shift == 0) {
 260
 261         /* the x86 compilers use the shl instruction that shifts by modulo 32 */
 262
 263         in_cidr->mask = 0;
 264
 265         if (in_cidr->addr == 0) {
 266             return NGX_OK;
 267         }
 268
 269         return NGX_DONE;
 270     }
 271
 272     in_cidr->mask = htonl((ngx_uint_t) (0 - (1 << (32 - shift))));
 273
 274     if (in_cidr->addr == (in_cidr->addr & in_cidr->mask)) {
 275         return NGX_OK;
 276     }
 277
 278     in_cidr->addr &= in_cidr->mask;
 279
 280     return NGX_DONE;
 281 }
 282
 283
 284 ngx_int_t
 285 ngx_parse_url(ngx_pool_t *pool, ngx_url_t *u)
 286 {
 287     u_char  *p;
 288
 289     p = u->url.data;
 290
 291     if (ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0) {
 292         return ngx_parse_unix_domain_url(pool, u);
 293     }
 294
 295     if ((p[0] == ':' || p[0] == '/') && !u->listen) {
 296         u->err = "invalid host";
 297         return NGX_ERROR;
 298     }
 299
 300     if (p[0] == '[') {
 301         return ngx_parse_inet6_url(pool, u);
 302     }
 303
 304     return ngx_parse_inet_url(pool, u);
 305 }
 306
 307
 308 static ngx_int_t
 309 ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u)
 310 {
 311 #if (NGX_HAVE_UNIX_DOMAIN)
 312     u_char              *path, *uri, *last;
 313     size_t               len;
 314     struct sockaddr_un  *saun;
 315
 316     len = u->url.len;
 317     path = u->url.data;
 318
 319     path += 5;
 320     len -= 5;
 321
 322     if (u->uri_part) {
 323
 324         last = path + len;
 325         uri = ngx_strlchr(path, last, ':');
 326
 327         if (uri) {
 328             len = uri - path;
 329             uri++;
 330             u->uri.len = last - uri;
 331             u->uri.data = uri;
 332         }
 333     }
 334
 335     if (len == 0) {
 336         u->err = "no path in the unix domain socket";
 337         return NGX_ERROR;
 338     }
 339
 340     u->host.len = len++;
 341     u->host.data = path;
 342
 343     if (len > sizeof(saun->sun_path)) {
 344         u->err = "too long path in the unix domain socket";
 345         return NGX_ERROR;
 346     }
 347
 348     u->socklen = sizeof(struct sockaddr_un);
 349     saun = (struct sockaddr_un *) &u->sockaddr;
 350     saun->sun_family = AF_UNIX;
 351     (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);
 352
 353     u->addrs = ngx_pcalloc(pool, sizeof(ngx_peer_addr_t));
 354     if (u->addrs == NULL) {
 355         return NGX_ERROR;
 356     }
 357
 358     saun = ngx_pcalloc(pool, sizeof(struct sockaddr_un));
 359     if (saun == NULL) {
 360         return NGX_ERROR;
 361     }
 362
 363     u->family = AF_UNIX;
 364     u->naddrs = 1;
 365
 366     saun->sun_family = AF_UNIX;
 367     (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);
 368
 369     u->addrs[0].sockaddr = (struct sockaddr *) saun;
 370     u->addrs[0].socklen = sizeof(struct sockaddr_un);
 371     u->addrs[0].name.len = len + 4;
 372     u->addrs[0].name.data = u->url.data;
 373
 374     return NGX_OK;
 375
 376 #else
 377
 378     u->err = "the unix domain sockets are not supported on this platform";
 379
 380     return NGX_ERROR;
 381
 382 #endif
 383 }
 384
 385
 386 static ngx_int_t
 387 ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
 388 {
 389     u_char              *p, *host, *port, *last, *uri, *args;
 390     size_t               len;
 391     ngx_int_t            n;
 392     struct hostent      *h;
 393     struct sockaddr_in  *sin;
 394
 395     u->socklen = sizeof(struct sockaddr_in);
 396     sin = (struct sockaddr_in *) &u->sockaddr;
 397     sin->sin_family = AF_INET;
 398
 399     u->family = AF_INET;
 400
 401     host = u->url.data;
 402
 403     last = host + u->url.len;
 404
 405     port = ngx_strlchr(host, last, ':');
 406
 407     uri = ngx_strlchr(host, last, '/');
 408
 409     args = ngx_strlchr(host, last, '?');
 410
 411     if (args) {
 412         if (uri == NULL) {
 413             uri = args;
 414
 415         } else if (args < uri) {
 416             uri = args;
 417         }
 418     }
 419
 420     if (uri) {
 421         if (u->listen || !u->uri_part) {
 422             u->err = "invalid host";
 423             return NGX_ERROR;
 424         }
 425
 426         u->uri.len = last - uri;
 427         u->uri.data = uri;
 428
 429         last = uri;
 430
 431         if (uri < port) {
 432             port = NULL;
 433         }
 434     }
 435
 436     if (port) {
 437         port++;
 438
 439         len = last - port;
 440
 441         if (len == 0) {
 442             u->err = "invalid port";
 443             return NGX_ERROR;
 444         }
 445
 446         n = ngx_atoi(port, len);
 447
 448         if (n < 1 || n > 65536) {
 449             u->err = "invalid port";
 450             return NGX_ERROR;
 451         }
 452
 453         u->port = (in_port_t) n;
 454         sin->sin_port = htons((in_port_t) n);
 455
 456         u->port_text.len = len;
 457         u->port_text.data = port;
 458
 459         last = port - 1;
 460
 461     } else {
 462         if (uri == NULL) {
 463
 464             if (u->listen) {
 465
 466                 /* test value as port only */
 467
 468                 n = ngx_atoi(host, last - host);
 469
 470                 if (n != NGX_ERROR) {
 471
 472                     if (n < 1 || n > 65536) {
 473                         u->err = "invalid port";
 474                         return NGX_ERROR;
 475                     }
 476
 477                     u->port = (in_port_t) n;
 478                     sin->sin_port = htons((in_port_t) n);
 479
 480                     u->port_text.len = last - host;
 481                     u->port_text.data = host;
 482
 483                     u->wildcard = 1;
 484
 485                     return NGX_OK;
 486                 }
 487             }
 488         }
 489
 490         u->no_port = 1;
 491     }
 492
 493     len = last - host;
 494
 495     if (len == 0) {
 496         u->err = "no host";
 497         return NGX_ERROR;
 498     }
 499
 500     if (len == 1 && *host == '*') {
 501         len = 0;
 502     }
 503
 504     u->host.len = len;
 505     u->host.data = host;
 506
 507     if (u->no_resolve) {
 508         return NGX_OK;
 509     }
 510
 511     if (len++) {
 512
 513         p = ngx_alloc(len, pool->log);
 514         if (p == NULL) {
 515             return NGX_ERROR;
 516         }
 517
 518         (void) ngx_cpystrn(p, host, len);
 519
 520         u->addr.in_addr = inet_addr((const char *) p);
 521         sin->sin_addr.s_addr = inet_addr((const char *) p);
 522
 523         if (sin->sin_addr.s_addr == INADDR_NONE) {
 524             h = gethostbyname((const char *) p);
 525
 526             if (h == NULL || h->h_addr_list[0] == NULL) {
 527                 ngx_free(p);
 528                 u->err = "host not found";
 529                 return NGX_ERROR;
 530             }
 531
 532             u->addr.in_addr = *(in_addr_t *) (h->h_addr_list[0]);
 533             sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[0]);
 534         }
 535
 536         if (sin->sin_addr.s_addr == INADDR_ANY) {
 537             u->wildcard = 1;
 538         }
 539
 540         ngx_free(p);
 541
 542     } else {
 543         u->addr.in_addr = INADDR_ANY;
 544         sin->sin_addr.s_addr = INADDR_ANY;
 545         u->wildcard = 1;
 546     }
 547
 548     if (u->no_port) {
 549         u->port = u->default_port;
 550         sin->sin_port = htons(u->default_port);
 551     }
 552
 553     if (u->listen) {
 554         return NGX_OK;
 555     }
 556
 557     if (ngx_inet_resolve_host(pool, u) != NGX_OK) {
 558         return NGX_ERROR;
 559     }
 560
 561     return NGX_OK;
 562 }
 563
 564
 565 static ngx_int_t
 566 ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
 567 {
 568 #if (NGX_HAVE_INET6)
 569     int                   rc;
 570     u_char               *p, *host, *port, *last, *uri;
 571     size_t                len;
 572     ngx_int_t             n;
 573     struct sockaddr_in6  *sin6;
 574
 575     u->socklen = sizeof(struct sockaddr_in6);
 576     sin6 = (struct sockaddr_in6 *) &u->sockaddr;
 577     sin6->sin6_family = AF_INET6;
 578
 579     host = u->url.data + 1;
 580
 581     last = u->url.data + u->url.len;
 582
 583     p = ngx_strlchr(host, last, ']');
 584
 585     if (p == NULL) {
 586         u->err = "invalid host";
 587         return NGX_ERROR;
 588     }
 589
 590     if (last - p) {
 591
 592         port = p + 1;
 593
 594         uri = ngx_strlchr(port, last, '/');
 595
 596         if (uri) {
 597             if (u->listen || !u->uri_part) {
 598                 u->err = "invalid host";
 599                 return NGX_ERROR;
 600             }
 601
 602             u->uri.len = last - uri;
 603             u->uri.data = uri;
 604         }
 605
 606         if (*port == ':') {
 607             port++;
 608
 609             len = last - port;
 610
 611             if (len == 0) {
 612                 u->err = "invalid port";
 613                 return NGX_ERROR;
 614             }
 615
 616             n = ngx_atoi(port, len);
 617
 618             if (n < 1 || n > 65536) {
 619                 u->err = "invalid port";
 620                 return NGX_ERROR;
 621             }
 622
 623             u->port = (in_port_t) n;
 624             sin6->sin6_port = htons((in_port_t) n);
 625
 626             u->port_text.len = len;
 627             u->port_text.data = port;
 628
 629         } else {
 630             u->no_port = 1;
 631         }
 632     }
 633
 634     len = p - host;
 635
 636     if (len == 0) {
 637         u->err = "no host";
 638         return NGX_ERROR;
 639     }
 640
 641     u->host.len = len++;
 642     u->host.data = host;
 643
 644     p = ngx_alloc(len, pool->log);
 645     if (p == NULL) {
 646         return NGX_ERROR;
 647     }
 648
 649     (void) ngx_cpystrn(p, host, len);
 650
 651     rc = inet_pton(AF_INET6, (const char *) p, &sin6->sin6_addr);
 652
 653     ngx_free(p);
 654
 655     if (rc == 0) {
 656         u->err = "invalid IPv6 address";
 657         return NGX_ERROR;
 658     }
 659
 660     if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
 661         u->wildcard = 1;
 662     }
 663
 664     u->family = AF_INET6;
 665
 666     if (u->no_resolve) {
 667         return NGX_OK;
 668     }
 669
 670     if (u->no_port) {
 671         u->port = u->default_port;
 672         sin6->sin6_port = htons(u->default_port);
 673     }
 674
 675     return NGX_OK;
 676
 677 #else
 678
 679     u->err = "the INET6 sockets are not supported on this platform";
 680
 681     return NGX_ERROR;
 682
 683 #endif
 684 }
 685
 686
 687 ngx_int_t
 688 ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
 689 {
 690     u_char              *p, *host;
 691     size_t               len;
 692     in_port_t            port;
 693     in_addr_t            in_addr;
 694     ngx_uint_t           i;
 695     struct hostent      *h;
 696     struct sockaddr_in  *sin;
 697
 698     host = ngx_alloc(u->host.len + 1, pool->log);
 699     if (host == NULL) {
 700         return NGX_ERROR;
 701     }
 702
 703     (void) ngx_cpystrn(host, u->host.data, u->host.len + 1);
 704
 705     /* AF_INET only */
 706
 707     port = htons(u->port);
 708
 709     in_addr = inet_addr((char *) host);
 710
 711     if (in_addr == INADDR_NONE) {
 712         h = gethostbyname((char *) host);
 713
 714         ngx_free(host);
 715
 716         if (h == NULL || h->h_addr_list[0] == NULL) {
 717             u->err = "host not found";
 718             return NGX_ERROR;
 719         }
 720
 721         if (u->one_addr == 0) {
 722             for (i = 0; h->h_addr_list[i] != NULL; i++) { /* void */ }
 723
 724         } else {
 725             i = 1;
 726         }
 727
 728         /* MP: ngx_shared_palloc() */
 729
 730         u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_peer_addr_t));
 731         if (u->addrs == NULL) {
 732             return NGX_ERROR;
 733         }
 734
 735         u->naddrs = i;
 736
 737         for (i = 0; h->h_addr_list[i] != NULL; i++) {
 738
 739             sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
 740             if (sin == NULL) {
 741                 return NGX_ERROR;
 742             }
 743
 744             sin->sin_family = AF_INET;
 745             sin->sin_port = port;
 746             sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);
 747
 748             u->addrs[i].sockaddr = (struct sockaddr *) sin;
 749             u->addrs[i].socklen = sizeof(struct sockaddr_in);
 750
 751             len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
 752
 753             p = ngx_pnalloc(pool, len);
 754             if (p == NULL) {
 755                 return NGX_ERROR;
 756             }
 757
 758             len = ngx_sock_ntop((struct sockaddr *) sin, p, len, 1);
 759
 760             u->addrs[i].name.len = len;
 761             u->addrs[i].name.data = p;
 762         }
 763
 764     } else {
 765
 766         ngx_free(host);
 767
 768         /* MP: ngx_shared_palloc() */
 769
 770         u->addrs = ngx_pcalloc(pool, sizeof(ngx_peer_addr_t));
 771         if (u->addrs == NULL) {
 772             return NGX_ERROR;
 773         }
 774
 775         sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
 776         if (sin == NULL) {
 777             return NGX_ERROR;
 778         }
 779
 780         u->naddrs = 1;
 781
 782         sin->sin_family = AF_INET;
 783         sin->sin_port = port;
 784         sin->sin_addr.s_addr = in_addr;
 785
 786         u->addrs[0].sockaddr = (struct sockaddr *) sin;
 787         u->addrs[0].socklen = sizeof(struct sockaddr_in);
 788
 789         p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
 790         if (p == NULL) {
 791             return NGX_ERROR;
 792         }
 793
 794         u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
 795                                            &u->host, ntohs(port)) - p;
 796         u->addrs[0].name.data = p;
 797     }
 798
 799     return NGX_OK;
 800 }