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 >= '' && c <= '9') {
35 octet = octet * 10 + (c - '');
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, ngx_cidr_t *cidr)
230 {
231 u_char *addr, *mask, *last;
232 ngx_int_t shift;
233
234 addr = text->data;
235 last = addr + text->len;
236
237 mask = ngx_strlchr(addr, last, '/');
238
239 cidr->u.in.addr = ngx_inet_addr(addr, (mask ? mask : last) - addr);
240
241 if (cidr->u.in.addr == INADDR_NONE) {
242 return NGX_ERROR;
243 }
244
245 if (mask == NULL) {
246 cidr->family = AF_INET;
247 cidr->u.in.mask = 0xffffffff;
248 return NGX_OK;
249 }
250
251 mask++;
252
253 shift = ngx_atoi(mask, last - mask);
254 if (shift == NGX_ERROR) {
255 return NGX_ERROR;
256 }
257
258 cidr->family = AF_INET;
259
260 if (shift == 0) {
261
262 /* the x86 compilers use the shl instruction that shifts by modulo 32 */
263
264 cidr->u.in.mask = 0;
265
266 if (cidr->u.in.addr == 0) {
267 return NGX_OK;
268 }
269
270 return NGX_DONE;
271 }
272
273 cidr->u.in.mask = htonl((ngx_uint_t) (0 - (1 << (32 - shift))));
274
275 if (cidr->u.in.addr == (cidr->u.in.addr & cidr->u.in.mask)) {
276 return NGX_OK;
277 }
278
279 cidr->u.in.addr &= cidr->u.in.mask;
280
281 return NGX_DONE;
282 }
283
284
285 ngx_int_t
286 ngx_parse_url(ngx_pool_t *pool, ngx_url_t *u)
287 {
288 u_char *p;
289
290 p = u->url.data;
291
292 if (ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0) {
293 return ngx_parse_unix_domain_url(pool, u);
294 }
295
296 if ((p[0] == ':' || p[0] == '/') && !u->listen) {
297 u->err = "invalid host";
298 return NGX_ERROR;
299 }
300
301 if (p[0] == '[') {
302 return ngx_parse_inet6_url(pool, u);
303 }
304
305 return ngx_parse_inet_url(pool, u);
306 }
307
308
309 static ngx_int_t
310 ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u)
311 {
312 #if (NGX_HAVE_UNIX_DOMAIN)
313 u_char *path, *uri, *last;
314 size_t len;
315 struct sockaddr_un *saun;
316
317 len = u->url.len;
318 path = u->url.data;
319
320 path += 5;
321 len -= 5;
322
323 if (u->uri_part) {
324
325 last = path + len;
326 uri = ngx_strlchr(path, last, ':');
327
328 if (uri) {
329 len = uri - path;
330 uri++;
331 u->uri.len = last - uri;
332 u->uri.data = uri;
333 }
334 }
335
336 if (len == 0) {
337 u->err = "no path in the unix domain socket";
338 return NGX_ERROR;
339 }
340
341 u->host.len = len++;
342 u->host.data = path;
343
344 if (len > sizeof(saun->sun_path)) {
345 u->err = "too long path in the unix domain socket";
346 return NGX_ERROR;
347 }
348
349 u->socklen = sizeof(struct sockaddr_un);
350 saun = (struct sockaddr_un *) &u->sockaddr;
351 saun->sun_family = AF_UNIX;
352 (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);
353
354 u->addrs = ngx_pcalloc(pool, sizeof(ngx_peer_addr_t));
355 if (u->addrs == NULL) {
356 return NGX_ERROR;
357 }
358
359 saun = ngx_pcalloc(pool, sizeof(struct sockaddr_un));
360 if (saun == NULL) {
361 return NGX_ERROR;
362 }
363
364 u->family = AF_UNIX;
365 u->naddrs = 1;
366
367 saun->sun_family = AF_UNIX;
368 (void) ngx_cpystrn((u_char *) saun->sun_path, path, len);
369
370 u->addrs[0].sockaddr = (struct sockaddr *) saun;
371 u->addrs[0].socklen = sizeof(struct sockaddr_un);
372 u->addrs[0].name.len = len + 4;
373 u->addrs[0].name.data = u->url.data;
374
375 return NGX_OK;
376
377 #else
378
379 u->err = "the unix domain sockets are not supported on this platform";
380
381 return NGX_ERROR;
382
383 #endif
384 }
385
386
387 static ngx_int_t
388 ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
389 {
390 u_char *p, *host, *port, *last, *uri, *args;
391 size_t len;
392 ngx_int_t n;
393 struct hostent *h;
394 struct sockaddr_in *sin;
395
396 u->socklen = sizeof(struct sockaddr_in);
397 sin = (struct sockaddr_in *) &u->sockaddr;
398 sin->sin_family = AF_INET;
399
400 u->family = AF_INET;
401
402 host = u->url.data;
403
404 last = host + u->url.len;
405
406 port = ngx_strlchr(host, last, ':');
407
408 uri = ngx_strlchr(host, last, '/');
409
410 args = ngx_strlchr(host, last, '?');
411
412 if (args) {
413 if (uri == NULL) {
414 uri = args;
415
416 } else if (args < uri) {
417 uri = args;
418 }
419 }
420
421 if (uri) {
422 if (u->listen || !u->uri_part) {
423 u->err = "invalid host";
424 return NGX_ERROR;
425 }
426
427 u->uri.len = last - uri;
428 u->uri.data = uri;
429
430 last = uri;
431
432 if (uri < port) {
433 port = NULL;
434 }
435 }
436
437 if (port) {
438 port++;
439
440 len = last - port;
441
442 if (len == 0) {
443 u->err = "invalid port";
444 return NGX_ERROR;
445 }
446
447 n = ngx_atoi(port, len);
448
449 if (n < 1 || n > 65536) {
450 u->err = "invalid port";
451 return NGX_ERROR;
452 }
453
454 u->port = (in_port_t) n;
455 sin->sin_port = htons((in_port_t) n);
456
457 u->port_text.len = len;
458 u->port_text.data = port;
459
460 last = port - 1;
461
462 } else {
463 if (uri == NULL) {
464
465 if (u->listen) {
466
467 /* test value as port only */
468
469 n = ngx_atoi(host, last - host);
470
471 if (n != NGX_ERROR) {
472
473 if (n < 1 || n > 65536) {
474 u->err = "invalid port";
475 return NGX_ERROR;
476 }
477
478 u->port = (in_port_t) n;
479 sin->sin_port = htons((in_port_t) n);
480
481 u->port_text.len = last - host;
482 u->port_text.data = host;
483
484 u->wildcard = 1;
485
486 return NGX_OK;
487 }
488 }
489 }
490
491 u->no_port = 1;
492 }
493
494 len = last - host;
495
496 if (len == 0) {
497 u->err = "no host";
498 return NGX_ERROR;
499 }
500
501 if (len == 1 && *host == '*') {
502 len = 0;
503 }
504
505 u->host.len = len;
506 u->host.data = host;
507
508 if (u->no_resolve) {
509 return NGX_OK;
510 }
511
512 if (len++) {
513
514 p = ngx_alloc(len, pool->log);
515 if (p == NULL) {
516 return NGX_ERROR;
517 }
518
519 (void) ngx_cpystrn(p, host, len);
520
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 sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[0]);
533 }
534
535 if (sin->sin_addr.s_addr == INADDR_ANY) {
536 u->wildcard = 1;
537 }
538
539 ngx_free(p);
540
541 } else {
542 sin->sin_addr.s_addr = INADDR_ANY;
543 u->wildcard = 1;
544 }
545
546 if (u->no_port) {
547 u->port = u->default_port;
548 sin->sin_port = htons(u->default_port);
549 }
550
551 if (u->listen) {
552 return NGX_OK;
553 }
554
555 if (ngx_inet_resolve_host(pool, u) != NGX_OK) {
556 return NGX_ERROR;
557 }
558
559 return NGX_OK;
560 }
561
562
563 static ngx_int_t
564 ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
565 {
566 #if (NGX_HAVE_INET6)
567 int rc;
568 u_char *p, *host, *port, *last, *uri;
569 size_t len;
570 ngx_int_t n;
571 struct sockaddr_in6 *sin6;
572
573 u->socklen = sizeof(struct sockaddr_in6);
574 sin6 = (struct sockaddr_in6 *) &u->sockaddr;
575 sin6->sin6_family = AF_INET6;
576
577 host = u->url.data + 1;
578
579 last = u->url.data + u->url.len;
580
581 p = ngx_strlchr(host, last, ']');
582
583 if (p == NULL) {
584 u->err = "invalid host";
585 return NGX_ERROR;
586 }
587
588 if (last - p) {
589
590 port = p + 1;
591
592 uri = ngx_strlchr(port, last, '/');
593
594 if (uri) {
595 if (u->listen || !u->uri_part) {
596 u->err = "invalid host";
597 return NGX_ERROR;
598 }
599
600 u->uri.len = last - uri;
601 u->uri.data = uri;
602 }
603
604 if (*port == ':') {
605 port++;
606
607 len = last - port;
608
609 if (len == 0) {
610 u->err = "invalid port";
611 return NGX_ERROR;
612 }
613
614 n = ngx_atoi(port, len);
615
616 if (n < 1 || n > 65536) {
617 u->err = "invalid port";
618 return NGX_ERROR;
619 }
620
621 u->port = (in_port_t) n;
622 sin6->sin6_port = htons((in_port_t) n);
623
624 u->port_text.len = len;
625 u->port_text.data = port;
626
627 } else {
628 u->no_port = 1;
629 }
630 }
631
632 len = p - host;
633
634 if (len == 0) {
635 u->err = "no host";
636 return NGX_ERROR;
637 }
638
639 u->host.len = len++;
640 u->host.data = host;
641
642 p = ngx_alloc(len, pool->log);
643 if (p == NULL) {
644 return NGX_ERROR;
645 }
646
647 (void) ngx_cpystrn(p, host, len);
648
649 #if (NGX_WIN32)
650
651 rc = WSAStringToAddress((char *) p, AF_INET6, NULL,
652 (SOCKADDR *) sin6, &u->socklen);
653 rc = !rc;
654
655 if (u->port) {
656 sin6->sin6_port = htons(u->port);
657 }
658
659 #else
660
661 rc = inet_pton(AF_INET6, (const char *) p, &sin6->sin6_addr);
662
663 #endif
664
665 ngx_free(p);
666
667 if (rc == 0) {
668 u->err = "invalid IPv6 address";
669 return NGX_ERROR;
670 }
671
672 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
673 u->wildcard = 1;
674 }
675
676 u->family = AF_INET6;
677
678 if (u->no_resolve) {
679 return NGX_OK;
680 }
681
682 if (u->no_port) {
683 u->port = u->default_port;
684 sin6->sin6_port = htons(u->default_port);
685 }
686
687 return NGX_OK;
688
689 #else
690
691 u->err = "the INET6 sockets are not supported on this platform";
692
693 return NGX_ERROR;
694
695 #endif
696 }
697
698
699 ngx_int_t
700 ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
701 {
702 u_char *p, *host;
703 size_t len;
704 in_port_t port;
705 in_addr_t in_addr;
706 ngx_uint_t i;
707 struct hostent *h;
708 struct sockaddr_in *sin;
709
710 host = ngx_alloc(u->host.len + 1, pool->log);
711 if (host == NULL) {
712 return NGX_ERROR;
713 }
714
715 (void) ngx_cpystrn(host, u->host.data, u->host.len + 1);
716
717 /* AF_INET only */
718
719 port = htons(u->port);
720
721 in_addr = inet_addr((char *) host);
722
723 if (in_addr == INADDR_NONE) {
724 h = gethostbyname((char *) host);
725
726 ngx_free(host);
727
728 if (h == NULL || h->h_addr_list[0] == NULL) {
729 u->err = "host not found";
730 return NGX_ERROR;
731 }
732
733 if (u->one_addr == 0) {
734 for (i = 0; h->h_addr_list[i] != NULL; i++) { /* void */ }
735
736 } else {
737 i = 1;
738 }
739
740 /* MP: ngx_shared_palloc() */
741
742 u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_peer_addr_t));
743 if (u->addrs == NULL) {
744 return NGX_ERROR;
745 }
746
747 u->naddrs = i;
748
749 for (i = 0; h->h_addr_list[i] != NULL; i++) {
750
751 sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
752 if (sin == NULL) {
753 return NGX_ERROR;
754 }
755
756 sin->sin_family = AF_INET;
757 sin->sin_port = port;
758 sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);
759
760 u->addrs[i].sockaddr = (struct sockaddr *) sin;
761 u->addrs[i].socklen = sizeof(struct sockaddr_in);
762
763 len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
764
765 p = ngx_pnalloc(pool, len);
766 if (p == NULL) {
767 return NGX_ERROR;
768 }
769
770 len = ngx_sock_ntop((struct sockaddr *) sin, p, len, 1);
771
772 u->addrs[i].name.len = len;
773 u->addrs[i].name.data = p;
774 }
775
776 } else {
777
778 ngx_free(host);
779
780 /* MP: ngx_shared_palloc() */
781
782 u->addrs = ngx_pcalloc(pool, sizeof(ngx_peer_addr_t));
783 if (u->addrs == NULL) {
784 return NGX_ERROR;
785 }
786
787 sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
788 if (sin == NULL) {
789 return NGX_ERROR;
790 }
791
792 u->naddrs = 1;
793
794 sin->sin_family = AF_INET;
795 sin->sin_port = port;
796 sin->sin_addr.s_addr = in_addr;
797
798 u->addrs[0].sockaddr = (struct sockaddr *) sin;
799 u->addrs[0].socklen = sizeof(struct sockaddr_in);
800
801 p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
802 if (p == NULL) {
803 return NGX_ERROR;
804 }
805
806 u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
807 &u->host, ntohs(port)) - p;
808 u->addrs[0].name.data = p;
809 }
810
811 return NGX_OK;
812 }
813
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.