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 #include <ngx_event.h>
  10 #include <ngx_event_connect.h>
  11
  12
  13 /*
  14  * ngx_sock_ntop() and ngx_inet_ntop() may be implemented as
  15  * "ngx_sprintf(text, "%ud.%ud.%ud.%ud", p[0], p[1], p[2], p[3])", however,
  16  * they had been implemented long before the ngx_sprintf() had appeared
  17  * and they are faster by 1.5-2.5 times, so it is worth to keep them.
  18  *
  19  * By the way, the implementation using ngx_sprintf() is faster by 2.5-3 times
  20  * than using FreeBSD libc's snprintf().
  21  */
  22
  23
  24 static ngx_inline size_t
  25 ngx_sprint_uchar(u_char *text, u_char c, size_t len)
  26 {
  27     size_t      n;
  28     ngx_uint_t  c1, c2;
  29
  30     n = 0;
  31
  32     if (len == n) {
  33         return n;
  34     }
  35
  36     c1 = c / 100;
  37
  38     if (c1) {
  39         *text++ = (u_char) (c1 + '0');
  40         n++;
  41
  42         if (len == n) {
  43             return n;
  44         }
  45     }
  46
  47     c2 = (c % 100) / 10;
  48
  49     if (c1 || c2) {
  50         *text++ = (u_char) (c2 + '0');
  51         n++;
  52
  53         if (len == n) {
  54             return n;
  55         }
  56     }
  57
  58     c2 = c % 10;
  59
  60     *text++ = (u_char) (c2 + '0');
  61     n++;
  62
  63     return n;
  64 }
  65
  66
  67 /* AF_INET only */
  68
  69 size_t
  70 ngx_sock_ntop(int family, struct sockaddr *sa, u_char *text, size_t len)
  71 {
  72     u_char              *p;
  73     size_t               n;
  74     ngx_uint_t           i;
  75     struct sockaddr_in  *sin;
  76
  77     if (len == 0) {
  78         return 0;
  79     }
  80
  81     if (family != AF_INET) {
  82         return 0;
  83     }
  84
  85     sin = (struct sockaddr_in *) sa;
  86     p = (u_char *) &sin->sin_addr;
  87
  88     if (len > INET_ADDRSTRLEN) {
  89         len = INET_ADDRSTRLEN;
  90     }
  91
  92     n = ngx_sprint_uchar(text, p[0], len);
  93
  94     i = 1;
  95
  96     do {
  97         if (len == n) {
  98             text[n - 1] = '\0';
  99             return n;
 100         }
 101
 102         text[n++] = '.';
 103
 104         if (len == n) {
 105             text[n - 1] = '\0';
 106             return n;
 107         }
 108
 109         n += ngx_sprint_uchar(&text[n], p[i++], len - n);
 110
 111     } while (i < 4);
 112
 113     if (len == n) {
 114         text[n] = '\0';
 115         return n;
 116     }
 117
 118     text[n] = '\0';
 119
 120     return n;
 121 }
 122
 123 size_t
 124 ngx_inet_ntop(int family, void *addr, u_char *text, size_t len)
 125 {
 126     u_char      *p;
 127     size_t       n;
 128     ngx_uint_t   i;
 129
 130     if (len == 0) {
 131         return 0;
 132     }
 133
 134     if (family != AF_INET) {
 135         return 0;
 136     }
 137
 138     p = (u_char *) addr;
 139
 140     if (len > INET_ADDRSTRLEN) {
 141         len = INET_ADDRSTRLEN;
 142     }
 143
 144     n = ngx_sprint_uchar(text, p[0], len);
 145
 146     i = 1;
 147
 148     do {
 149         if (len == n) {
 150             text[n - 1] = '\0';
 151             return n;
 152         }
 153
 154         text[n++] = '.';
 155
 156         if (len == n) {
 157             text[n - 1] = '\0';
 158             return n;
 159         }
 160
 161         n += ngx_sprint_uchar(&text[n], p[i++], len - n);
 162
 163     } while (i < 4);
 164
 165     if (len == n) {
 166         text[n] = '\0';
 167         return n;
 168     }
 169
 170     text[n] = '\0';
 171
 172     return n;
 173 }
 174
 175
 176 /* AF_INET only */
 177
 178 ngx_int_t
 179 ngx_ptocidr(ngx_str_t *text, void *cidr)
 180 {
 181     ngx_int_t         m;
 182     ngx_uint_t        i;
 183     ngx_inet_cidr_t  *in_cidr;
 184
 185     in_cidr = cidr;
 186
 187     for (i = 0; i < text->len; i++) {
 188         if (text->data[i] == '/') {
 189             break;
 190         }
 191     }
 192
 193     if (i == text->len) {
 194         return NGX_ERROR;
 195     }
 196
 197     text->data[i] = '\0';
 198     in_cidr->addr = inet_addr((char *) text->data);
 199     text->data[i] = '/';
 200     if (in_cidr->addr == INADDR_NONE) {
 201         return NGX_ERROR;
 202     }
 203
 204     m = ngx_atoi(&text->data[i + 1], text->len - (i + 1));
 205     if (m == NGX_ERROR) {
 206         return NGX_ERROR;
 207     }
 208
 209     if (m == 0) {
 210
 211         /* the x86 compilers use the shl instruction that shifts by modulo 32 */
 212
 213         in_cidr->mask = 0;
 214         return NGX_OK;
 215     }
 216
 217     in_cidr->mask = htonl((ngx_uint_t) (0 - (1 << (32 - m))));
 218
 219     return NGX_OK;
 220 }
 221
 222
 223 ngx_int_t
 224 ngx_parse_url(ngx_conf_t *cf, ngx_url_t *u)
 225 {
 226     u_char              *p, *host;
 227     size_t               len;
 228     ngx_int_t            port;
 229     ngx_uint_t           i;
 230     struct hostent      *h;
 231 #if (NGX_HAVE_UNIX_DOMAIN)
 232     struct sockaddr_un  *saun;
 233 #endif
 234
 235     len = u->url.len;
 236     p = u->url.data;
 237
 238     if (ngx_strncasecmp(p, "unix:", 5) == 0) {
 239
 240 #if (NGX_HAVE_UNIX_DOMAIN)
 241
 242         u->type = NGX_PARSE_URL_UNIX;
 243
 244         p += 5;
 245         len -= 5;
 246
 247         u->uri.len = len;
 248         u->uri.data = p;
 249
 250         if (u->uri_part) {
 251             for (i = 0; i < len; i++) {
 252
 253                 if (p[i] == ':') {
 254                     len = i;
 255
 256                     u->uri.len -= len + 1;
 257                     u->uri.data += len + 1;
 258
 259                     break;
 260                 }
 261             }
 262         }
 263
 264         if (len == 0) {
 265             u->err = "no path in the unix domain socket";
 266             return NGX_ERROR;
 267         }
 268
 269         if (len + 1 > sizeof(saun->sun_path)) {
 270             u->err = "too long path in the unix domain socket";
 271             return NGX_ERROR;
 272         }
 273
 274         u->peers = ngx_pcalloc(cf->pool, sizeof(ngx_peers_t));
 275         if (u->peers == NULL) {
 276             return NGX_ERROR;
 277         }
 278
 279         saun = ngx_pcalloc(cf->pool, sizeof(struct sockaddr_un));
 280         if (saun == NULL) {
 281             return NGX_ERROR;
 282         }
 283
 284         u->peers->number = 1;
 285
 286         saun->sun_family = AF_UNIX;
 287         (void) ngx_cpystrn((u_char *) saun->sun_path, p, len + 1);
 288
 289         u->peers->peer[0].sockaddr = (struct sockaddr *) saun;
 290         u->peers->peer[0].socklen = sizeof(struct sockaddr_un);
 291         u->peers->peer[0].name.len = len + 5;
 292         u->peers->peer[0].name.data = u->url.data;
 293         u->peers->peer[0].uri_separator = ":";
 294
 295         u->host_header.len = sizeof("localhost") - 1;
 296         u->host_header.data = (u_char *) "localhost";
 297
 298         return NGX_OK;
 299
 300 #else
 301         u->err = "the unix domain sockets are not supported on this platform";
 302
 303         return NGX_ERROR;
 304
 305 #endif
 306     }
 307
 308     if ((p[0] == ':' || p[0] == '/') && !u->listen) {
 309         u->err = "invalid host";
 310         return NGX_ERROR;
 311     }
 312
 313     u->type = NGX_PARSE_URL_INET;
 314
 315     u->host.data = p;
 316     u->host_header.len = len;
 317     u->host_header.data = p;
 318
 319     for (i = 0; i < len; i++) {
 320
 321         if (p[i] == ':') {
 322             u->port.data = &p[i + 1];
 323             u->host.len = i;
 324
 325             if (!u->uri_part) {
 326                 u->port.len = &p[len] - u->port.data;
 327                 break;
 328             }
 329         }
 330
 331         if (p[i] == '/') {
 332             u->uri.len = len - i;
 333             u->uri.data = &p[i];
 334             u->host_header.len = i;
 335
 336             if (u->host.len == 0) {
 337                 u->host.len = i;
 338             }
 339
 340             if (u->port.data == NULL) {
 341                 u->default_port = 1;
 342                 goto port;
 343             }
 344
 345             u->port.len = &p[i] - u->port.data;
 346
 347             if (u->port.len == 0) {
 348                 u->err = "invalid port";
 349                 return NGX_ERROR;
 350             }
 351
 352             break;
 353         }
 354     }
 355
 356     if (u->port.data) {
 357
 358         if (u->port.len == 0) {
 359             u->port.len = &p[i] - u->port.data;
 360
 361             if (u->port.len == 0) {
 362                 u->err = "invalid port";
 363                 return NGX_ERROR;
 364             }
 365         }
 366
 367         port = ngx_atoi(u->port.data, u->port.len);
 368
 369         if (port == NGX_ERROR || port < 1 || port > 65536) {
 370             u->err = "invalid port";
 371             return NGX_ERROR;
 372         }
 373
 374     } else {
 375         port = ngx_atoi(p, len);
 376
 377         if (port == NGX_ERROR) {
 378             u->default_port = 1;
 379             u->host.len = len;
 380
 381             goto port;
 382         }
 383
 384         u->port.len = len;
 385         u->port.data = p;
 386         u->wildcard = 1;
 387     }
 388
 389     u->portn = (in_port_t) port;
 390
 391 port:
 392
 393     if (u->listen) {
 394         if (u->portn == 0) {
 395             if (u->default_portn == 0) {
 396                 u->err = "no port";
 397                 return NGX_ERROR;
 398             }
 399
 400             u->portn = u->default_portn;
 401         }
 402
 403         if (u->host.len == 1 && u->host.data[0] == '*') {
 404             u->host.len = 0;
 405         }
 406
 407         /* AF_INET only */
 408
 409         if (u->host.len) {
 410
 411            host = ngx_palloc(cf->temp_pool, u->host.len + 1);
 412            if (host == NULL) {
 413                return NGX_ERROR;
 414            }
 415
 416            (void) ngx_cpystrn(host, u->host.data, u->host.len + 1);
 417
 418             u->addr.in_addr = inet_addr((const char *) host);
 419
 420             if (u->addr.in_addr == INADDR_NONE) {
 421                 h = gethostbyname((const char *) host);
 422
 423                 if (h == NULL || h->h_addr_list[0] == NULL) {
 424                     u->err = "host not found";
 425                     return NGX_ERROR;
 426                 }
 427
 428                 u->addr.in_addr = *(in_addr_t *)(h->h_addr_list[0]);
 429             }
 430
 431         } else {
 432             u->addr.in_addr = INADDR_ANY;
 433         }
 434
 435         return NGX_OK;
 436     }
 437
 438     if (u->default_port) {
 439
 440         if (u->upstream) {
 441             return NGX_OK;
 442         }
 443
 444         if (u->default_portn == 0) {
 445             u->err = "no port";
 446             return NGX_ERROR;
 447         }
 448
 449         u->portn = u->default_portn;
 450
 451         u->port.data = ngx_palloc(cf->pool, sizeof("65536") - 1);
 452         if (u->port.data == NULL) {
 453             return NGX_ERROR;
 454         }
 455
 456         u->port.len = ngx_sprintf(u->port.data, "%d", u->portn) - u->port.data;
 457
 458     } else if (u->portn) {
 459         if (u->portn == u->default_portn) {
 460             u->default_port = 1;
 461         }
 462
 463     } else {
 464         u->err = "no port";
 465         return NGX_ERROR;
 466     }
 467
 468     if (u->host.len == 0) {
 469         u->err = "no host";
 470         return NGX_ERROR;
 471     }
 472
 473     u->peers = ngx_inet_resolve_peer(cf, &u->host, u->portn);
 474
 475     if (u->peers == NULL) {
 476         return NGX_ERROR;
 477     }
 478
 479     if (u->peers == NGX_CONF_ERROR) {
 480         u->err = "host not found";
 481         return NGX_ERROR;
 482     }
 483
 484     return NGX_OK;
 485 }
 486
 487
 488 ngx_peers_t *
 489 ngx_inet_resolve_peer(ngx_conf_t *cf, ngx_str_t *name, in_port_t port)
 490 {
 491     u_char              *host;
 492     size_t               len;
 493     in_addr_t            in_addr;
 494     ngx_uint_t           i;
 495     ngx_peers_t         *peers;
 496     struct hostent      *h;
 497     struct sockaddr_in  *sin;
 498
 499     host = ngx_palloc(cf->temp_pool, name->len + 1);
 500     if (host == NULL) {
 501         return NULL;
 502     }
 503
 504     (void) ngx_cpystrn(host, name->data, name->len + 1);
 505
 506     /* AF_INET only */
 507
 508     in_addr = inet_addr((char *) host);
 509
 510     if (in_addr == INADDR_NONE) {
 511         h = gethostbyname((char *) host);
 512
 513         if (h == NULL || h->h_addr_list[0] == NULL) {
 514             return NGX_CONF_ERROR;
 515         }
 516
 517         for (i = 0; h->h_addr_list[i] != NULL; i++) { /* void */ }
 518
 519         /* MP: ngx_shared_palloc() */
 520
 521         peers = ngx_pcalloc(cf->pool,
 522                             sizeof(ngx_peers_t) + sizeof(ngx_peer_t) * (i - 1));
 523         if (peers == NULL) {
 524             return NULL;
 525         }
 526
 527         peers->number = i;
 528
 529         for (i = 0; h->h_addr_list[i] != NULL; i++) {
 530
 531             sin = ngx_pcalloc(cf->pool, sizeof(struct sockaddr_in));
 532             if (sin == NULL) {
 533                 return NULL;
 534             }
 535
 536             sin->sin_family = AF_INET;
 537             sin->sin_port = htons(port);
 538             sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);
 539
 540             peers->peer[i].sockaddr = (struct sockaddr *) sin;
 541             peers->peer[i].socklen = sizeof(struct sockaddr_in);
 542
 543             len = INET_ADDRSTRLEN - 1 + 1 + sizeof(":65536") - 1;
 544
 545             peers->peer[i].name.data = ngx_palloc(cf->pool, len);
 546             if (peers->peer[i].name.data == NULL) {
 547                 return NULL;
 548             }
 549
 550             len = ngx_sock_ntop(AF_INET, (struct sockaddr *) sin,
 551                                 peers->peer[i].name.data, len);
 552
 553             peers->peer[i].name.len =
 554                                     ngx_sprintf(&peers->peer[i].name.data[len],
 555                                                 ":%d", port)
 556                                       - peers->peer[i].name.data;
 557
 558             peers->peer[i].uri_separator = "";
 559
 560             peers->peer[i].weight = NGX_CONF_UNSET_UINT;
 561             peers->peer[i].max_fails = NGX_CONF_UNSET_UINT;
 562             peers->peer[i].fail_timeout = NGX_CONF_UNSET;
 563         }
 564
 565     } else {
 566
 567         /* MP: ngx_shared_palloc() */
 568
 569         peers = ngx_pcalloc(cf->pool, sizeof(ngx_peers_t));
 570         if (peers == NULL) {
 571             return NULL;
 572         }
 573
 574         sin = ngx_pcalloc(cf->pool, sizeof(struct sockaddr_in));
 575         if (sin == NULL) {
 576             return NULL;
 577         }
 578
 579         peers->number = 1;
 580
 581         sin->sin_family = AF_INET;
 582         sin->sin_port = htons(port);
 583         sin->sin_addr.s_addr = in_addr;
 584
 585         peers->peer[0].sockaddr = (struct sockaddr *) sin;
 586         peers->peer[0].socklen = sizeof(struct sockaddr_in);
 587
 588         peers->peer[0].name.data = ngx_palloc(cf->pool,
 589                                               name->len + sizeof(":65536") - 1);
 590         if (peers->peer[0].name.data == NULL) {
 591             return NULL;
 592         }
 593
 594         peers->peer[0].name.len = ngx_sprintf(peers->peer[0].name.data, "%V:%d",
 595                                               name, port)
 596                                   - peers->peer[0].name.data;
 597
 598         peers->peer[0].uri_separator = "";
 599     }
 600
 601     return peers;
 602 }