source: trunk/server/lib/util/util_net.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 16.8 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
5 Copyright (C) Andrew Tridgell 1992-1998
6 Copyright (C) Jeremy Allison 1992-2007
7 Copyright (C) Simo Sorce 2001
8 Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2003.
9 Copyright (C) James J Myers 2003
10 Copyright (C) Tim Potter 2000-2001
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
24*/
25
26#include "includes.h"
27#include "system/network.h"
28#include "system/locale.h"
29#include "system/filesys.h"
30#include "lib/util/util_net.h"
31#undef strcasecmp
32
33/*******************************************************************
34 Set an address to INADDR_ANY.
35******************************************************************/
36
37void zero_sockaddr(struct sockaddr_storage *pss)
38{
39 ZERO_STRUCTP(pss);
40 /* Ensure we're at least a valid sockaddr-storage. */
41 pss->ss_family = AF_INET;
42}
43
44/**
45 * Wrap getaddrinfo...
46 */
47bool interpret_string_addr_internal(struct addrinfo **ppres,
48 const char *str, int flags)
49{
50 int ret;
51 struct addrinfo hints;
52
53 ZERO_STRUCT(hints);
54
55 /* By default make sure it supports TCP. */
56 hints.ai_socktype = SOCK_STREAM;
57 hints.ai_flags = flags;
58
59 /* Linux man page on getaddrinfo() says port will be
60 uninitialized when service string is NULL */
61
62 ret = getaddrinfo(str, NULL,
63 &hints,
64 ppres);
65
66 if (ret) {
67 DEBUG(3,("interpret_string_addr_internal: getaddrinfo failed "
68 "for name %s [%s]\n",
69 str,
70 gai_strerror(ret) ));
71 return false;
72 }
73 return true;
74}
75
76/*******************************************************************
77 Map a text hostname or IP address (IPv4 or IPv6) into a
78 struct sockaddr_storage. Takes a flag which allows it to
79 prefer an IPv4 address (needed for DC's).
80******************************************************************/
81
82static bool interpret_string_addr_pref(struct sockaddr_storage *pss,
83 const char *str,
84 int flags,
85 bool prefer_ipv4)
86{
87 struct addrinfo *res = NULL;
88#if defined(HAVE_IPV6)
89 char addr[INET6_ADDRSTRLEN];
90 unsigned int scope_id = 0;
91
92 if (strchr_m(str, ':')) {
93 char *p = strchr_m(str, '%');
94
95 /*
96 * Cope with link-local.
97 * This is IP:v6:addr%ifname.
98 */
99
100 if (p && (p > str) && ((scope_id = if_nametoindex(p+1)) != 0)) {
101 strlcpy(addr, str,
102 MIN(PTR_DIFF(p,str)+1,
103 sizeof(addr)));
104 str = addr;
105 }
106 }
107#endif
108
109 zero_sockaddr(pss);
110
111 if (!interpret_string_addr_internal(&res, str, flags|AI_ADDRCONFIG)) {
112 return false;
113 }
114 if (!res) {
115 return false;
116 }
117
118 if (prefer_ipv4) {
119 struct addrinfo *p;
120
121 for (p = res; p; p = p->ai_next) {
122 if (p->ai_family == AF_INET) {
123 memcpy(pss, p->ai_addr, p->ai_addrlen);
124 break;
125 }
126 }
127 if (p == NULL) {
128 /* Copy the first sockaddr. */
129 memcpy(pss, res->ai_addr, res->ai_addrlen);
130 }
131 } else {
132 /* Copy the first sockaddr. */
133 memcpy(pss, res->ai_addr, res->ai_addrlen);
134 }
135
136#if defined(HAVE_IPV6)
137 if (pss->ss_family == AF_INET6 && scope_id) {
138 struct sockaddr_in6 *ps6 = (struct sockaddr_in6 *)pss;
139 if (IN6_IS_ADDR_LINKLOCAL(&ps6->sin6_addr) &&
140 ps6->sin6_scope_id == 0) {
141 ps6->sin6_scope_id = scope_id;
142 }
143 }
144#endif
145
146 freeaddrinfo(res);
147 return true;
148}
149
150/*******************************************************************
151 Map a text hostname or IP address (IPv4 or IPv6) into a
152 struct sockaddr_storage. Address agnostic version.
153******************************************************************/
154
155bool interpret_string_addr(struct sockaddr_storage *pss,
156 const char *str,
157 int flags)
158{
159 return interpret_string_addr_pref(pss,
160 str,
161 flags,
162 false);
163}
164
165/*******************************************************************
166 Map a text hostname or IP address (IPv4 or IPv6) into a
167 struct sockaddr_storage. Version that prefers IPv4.
168******************************************************************/
169
170bool interpret_string_addr_prefer_ipv4(struct sockaddr_storage *pss,
171 const char *str,
172 int flags)
173{
174 return interpret_string_addr_pref(pss,
175 str,
176 flags,
177 true);
178}
179
180/**
181 * Interpret an internet address or name into an IP address in 4 byte form.
182 * RETURNS IN NETWORK BYTE ORDER (big endian).
183 */
184
185uint32_t interpret_addr(const char *str)
186{
187 uint32_t ret;
188
189 /* If it's in the form of an IP address then
190 * get the lib to interpret it */
191 if (is_ipaddress_v4(str)) {
192 struct in_addr dest;
193
194 if (inet_pton(AF_INET, str, &dest) <= 0) {
195 /* Error - this shouldn't happen ! */
196 DEBUG(0,("interpret_addr: inet_pton failed "
197 "host %s\n",
198 str));
199 return 0;
200 }
201 ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
202 } else {
203 /* Otherwise assume it's a network name of some sort and use
204 getadddrinfo. */
205 struct addrinfo *res = NULL;
206 struct addrinfo *res_list = NULL;
207 if (!interpret_string_addr_internal(&res_list,
208 str,
209 AI_ADDRCONFIG)) {
210 DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
211 return 0;
212 }
213
214 /* Find the first IPv4 address. */
215 for (res = res_list; res; res = res->ai_next) {
216 if (res->ai_family != AF_INET) {
217 continue;
218 }
219 if (res->ai_addr == NULL) {
220 continue;
221 }
222 break;
223 }
224 if(res == NULL) {
225 DEBUG(3,("interpret_addr: host address is "
226 "invalid for host %s\n",str));
227 if (res_list) {
228 freeaddrinfo(res_list);
229 }
230 return 0;
231 }
232 memcpy((char *)&ret,
233 &((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
234 sizeof(ret));
235 if (res_list) {
236 freeaddrinfo(res_list);
237 }
238 }
239
240 /* This is so bogus - all callers need fixing... JRA. */
241 if (ret == (uint32_t)-1) {
242 return 0;
243 }
244
245 return ret;
246}
247
248/**
249 A convenient addition to interpret_addr().
250**/
251_PUBLIC_ struct in_addr interpret_addr2(const char *str)
252{
253 struct in_addr ret;
254 uint32_t a = interpret_addr(str);
255 ret.s_addr = a;
256 return ret;
257}
258
259/**
260 Check if an IP is the 0.0.0.0.
261**/
262
263_PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
264{
265 return ip.s_addr == 0;
266}
267
268/**
269 Are two IPs on the same subnet?
270**/
271
272_PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
273{
274 uint32_t net1,net2,nmask;
275
276 nmask = ntohl(mask.s_addr);
277 net1 = ntohl(ip1.s_addr);
278 net2 = ntohl(ip2.s_addr);
279
280 return((net1 & nmask) == (net2 & nmask));
281}
282
283/**
284 * Return true if a string could be an IPv4 address.
285 */
286
287bool is_ipaddress_v4(const char *str)
288{
289 int ret = -1;
290 struct in_addr dest;
291
292 ret = inet_pton(AF_INET, str, &dest);
293 if (ret > 0) {
294 return true;
295 }
296 return false;
297}
298
299/**
300 * Return true if a string could be an IPv4 or IPv6 address.
301 */
302
303bool is_ipaddress(const char *str)
304{
305#if defined(HAVE_IPV6)
306 int ret = -1;
307
308 if (strchr_m(str, ':')) {
309 char addr[INET6_ADDRSTRLEN];
310 struct in6_addr dest6;
311 const char *sp = str;
312 char *p = strchr_m(str, '%');
313
314 /*
315 * Cope with link-local.
316 * This is IP:v6:addr%ifname.
317 */
318
319 if (p && (p > str) && (if_nametoindex(p+1) != 0)) {
320 strlcpy(addr, str,
321 MIN(PTR_DIFF(p,str)+1,
322 sizeof(addr)));
323 sp = addr;
324 }
325 ret = inet_pton(AF_INET6, sp, &dest6);
326 if (ret > 0) {
327 return true;
328 }
329 }
330#endif
331 return is_ipaddress_v4(str);
332}
333
334/**
335 * Is a sockaddr a broadcast address ?
336 */
337
338bool is_broadcast_addr(const struct sockaddr *pss)
339{
340#if defined(HAVE_IPV6)
341 if (pss->sa_family == AF_INET6) {
342 const struct in6_addr *sin6 =
343 &((const struct sockaddr_in6 *)pss)->sin6_addr;
344 return IN6_IS_ADDR_MULTICAST(sin6);
345 }
346#endif
347 if (pss->sa_family == AF_INET) {
348 uint32_t addr =
349 ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
350 return addr == INADDR_BROADCAST;
351 }
352 return false;
353}
354
355/**
356 * Check if an IPv7 is 127.0.0.1
357 */
358bool is_loopback_ip_v4(struct in_addr ip)
359{
360 struct in_addr a;
361 a.s_addr = htonl(INADDR_LOOPBACK);
362 return(ip.s_addr == a.s_addr);
363}
364
365/**
366 * Check if a struct sockaddr is the loopback address.
367 */
368bool is_loopback_addr(const struct sockaddr *pss)
369{
370#if defined(HAVE_IPV6)
371 if (pss->sa_family == AF_INET6) {
372 const struct in6_addr *pin6 =
373 &((const struct sockaddr_in6 *)pss)->sin6_addr;
374 return IN6_IS_ADDR_LOOPBACK(pin6);
375 }
376#endif
377 if (pss->sa_family == AF_INET) {
378 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
379 return is_loopback_ip_v4(*pin);
380 }
381 return false;
382}
383
384/**
385 * Check if a struct sockaddr has an unspecified address.
386 */
387bool is_zero_addr(const struct sockaddr_storage *pss)
388{
389#if defined(HAVE_IPV6)
390 if (pss->ss_family == AF_INET6) {
391 const struct in6_addr *pin6 =
392 &((const struct sockaddr_in6 *)pss)->sin6_addr;
393 return IN6_IS_ADDR_UNSPECIFIED(pin6);
394 }
395#endif
396 if (pss->ss_family == AF_INET) {
397 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
398 return is_zero_ip_v4(*pin);
399 }
400 return false;
401}
402
403/**
404 * Set an IP to 0.0.0.0.
405 */
406void zero_ip_v4(struct in_addr *ip)
407{
408 memset(ip, '\0', sizeof(struct in_addr));
409}
410
411/**
412 * Convert an IPv4 struct in_addr to a struct sockaddr_storage.
413 */
414void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
415 struct in_addr ip)
416{
417 struct sockaddr_in *sa = (struct sockaddr_in *)ss;
418 memset(ss, '\0', sizeof(*ss));
419 sa->sin_family = AF_INET;
420 sa->sin_addr = ip;
421}
422
423#if defined(HAVE_IPV6)
424/**
425 * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
426 */
427void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
428 struct in6_addr ip)
429{
430 struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
431 memset(ss, '\0', sizeof(*ss));
432 sa->sin6_family = AF_INET6;
433 sa->sin6_addr = ip;
434}
435#endif
436
437/**
438 * Are two IPs on the same subnet?
439 */
440bool same_net(const struct sockaddr *ip1,
441 const struct sockaddr *ip2,
442 const struct sockaddr *mask)
443{
444 if (ip1->sa_family != ip2->sa_family) {
445 /* Never on the same net. */
446 return false;
447 }
448
449#if defined(HAVE_IPV6)
450 if (ip1->sa_family == AF_INET6) {
451 struct sockaddr_in6 ip1_6 = *(const struct sockaddr_in6 *)ip1;
452 struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
453 struct sockaddr_in6 mask_6 = *(const struct sockaddr_in6 *)mask;
454 char *p1 = (char *)&ip1_6.sin6_addr;
455 char *p2 = (char *)&ip2_6.sin6_addr;
456 char *m = (char *)&mask_6.sin6_addr;
457 int i;
458
459 for (i = 0; i < sizeof(struct in6_addr); i++) {
460 *p1++ &= *m;
461 *p2++ &= *m;
462 m++;
463 }
464 return (memcmp(&ip1_6.sin6_addr,
465 &ip2_6.sin6_addr,
466 sizeof(struct in6_addr)) == 0);
467 }
468#endif
469 if (ip1->sa_family == AF_INET) {
470 return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
471 ((const struct sockaddr_in *)ip2)->sin_addr,
472 ((const struct sockaddr_in *)mask)->sin_addr);
473 }
474 return false;
475}
476
477/**
478 * Are two sockaddr 's the same family and address ? Ignore port etc.
479 */
480
481bool sockaddr_equal(const struct sockaddr *ip1,
482 const struct sockaddr *ip2)
483{
484 if (ip1->sa_family != ip2->sa_family) {
485 /* Never the same. */
486 return false;
487 }
488
489#if defined(HAVE_IPV6)
490 if (ip1->sa_family == AF_INET6) {
491 return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
492 &((const struct sockaddr_in6 *)ip2)->sin6_addr,
493 sizeof(struct in6_addr)) == 0);
494 }
495#endif
496 if (ip1->sa_family == AF_INET) {
497 return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
498 &((const struct sockaddr_in *)ip2)->sin_addr,
499 sizeof(struct in_addr)) == 0);
500 }
501 return false;
502}
503
504/**
505 * Is an IP address the INADDR_ANY or in6addr_any value ?
506 */
507bool is_address_any(const struct sockaddr *psa)
508{
509#if defined(HAVE_IPV6)
510 if (psa->sa_family == AF_INET6) {
511 const struct sockaddr_in6 *si6 = (const struct sockaddr_in6 *)psa;
512 if (memcmp(&in6addr_any,
513 &si6->sin6_addr,
514 sizeof(in6addr_any)) == 0) {
515 return true;
516 }
517 return false;
518 }
519#endif
520 if (psa->sa_family == AF_INET) {
521 const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
522 if (si->sin_addr.s_addr == INADDR_ANY) {
523 return true;
524 }
525 return false;
526 }
527 return false;
528}
529
530void set_sockaddr_port(struct sockaddr *psa, uint16_t port)
531{
532#if defined(HAVE_IPV6)
533 if (psa->sa_family == AF_INET6) {
534 ((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
535 }
536#endif
537 if (psa->sa_family == AF_INET) {
538 ((struct sockaddr_in *)psa)->sin_port = htons(port);
539 }
540}
541
542
543/****************************************************************************
544 Get a port number in host byte order from a sockaddr_storage.
545****************************************************************************/
546
547uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
548{
549 uint16_t port = 0;
550
551 if (pss->ss_family != AF_INET) {
552#if defined(HAVE_IPV6)
553 /* IPv6 */
554 const struct sockaddr_in6 *sa6 =
555 (const struct sockaddr_in6 *)pss;
556 port = ntohs(sa6->sin6_port);
557#endif
558 } else {
559 const struct sockaddr_in *sa =
560 (const struct sockaddr_in *)pss;
561 port = ntohs(sa->sin_port);
562 }
563 return port;
564}
565
566/****************************************************************************
567 Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
568****************************************************************************/
569
570char *print_sockaddr_len(char *dest,
571 size_t destlen,
572 const struct sockaddr *psa,
573 socklen_t psalen)
574{
575 if (destlen > 0) {
576 dest[0] = '\0';
577 }
578 (void)sys_getnameinfo(psa,
579 psalen,
580 dest, destlen,
581 NULL, 0,
582 NI_NUMERICHOST);
583 return dest;
584}
585
586/****************************************************************************
587 Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
588****************************************************************************/
589
590char *print_sockaddr(char *dest,
591 size_t destlen,
592 const struct sockaddr_storage *psa)
593{
594 return print_sockaddr_len(dest, destlen, (struct sockaddr *)psa,
595 sizeof(struct sockaddr_storage));
596}
597
598/****************************************************************************
599 Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
600****************************************************************************/
601
602char *print_canonical_sockaddr(TALLOC_CTX *ctx,
603 const struct sockaddr_storage *pss)
604{
605 char addr[INET6_ADDRSTRLEN];
606 char *dest = NULL;
607 int ret;
608
609 /* Linux getnameinfo() man pages says port is unitialized if
610 service name is NULL. */
611
612 ret = sys_getnameinfo((const struct sockaddr *)pss,
613 sizeof(struct sockaddr_storage),
614 addr, sizeof(addr),
615 NULL, 0,
616 NI_NUMERICHOST);
617 if (ret != 0) {
618 return NULL;
619 }
620
621 if (pss->ss_family != AF_INET) {
622#if defined(HAVE_IPV6)
623 dest = talloc_asprintf(ctx, "[%s]", addr);
624#else
625 return NULL;
626#endif
627 } else {
628 dest = talloc_asprintf(ctx, "%s", addr);
629 }
630
631 return dest;
632}
633
634/****************************************************************************
635 Return the port number we've bound to on a socket.
636****************************************************************************/
637
638int get_socket_port(int fd)
639{
640 struct sockaddr_storage sa;
641 socklen_t length = sizeof(sa);
642
643 if (fd == -1) {
644 return -1;
645 }
646
647 if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
648 int level = (errno == ENOTCONN) ? 2 : 0;
649 DEBUG(level, ("getsockname failed. Error was %s\n",
650 strerror(errno)));
651 return -1;
652 }
653
654#if defined(HAVE_IPV6)
655 if (sa.ss_family == AF_INET6) {
656 return ntohs(((struct sockaddr_in6 *)&sa)->sin6_port);
657 }
658#endif
659 if (sa.ss_family == AF_INET) {
660 return ntohs(((struct sockaddr_in *)&sa)->sin_port);
661 }
662 return -1;
663}
664
665/****************************************************************************
666 Return the string of an IP address (IPv4 or IPv6).
667****************************************************************************/
668
669static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
670{
671 struct sockaddr_storage sa;
672 socklen_t length = sizeof(sa);
673
674 /* Ok, returning a hard coded IPv4 address
675 * is bogus, but it's just as bogus as a
676 * zero IPv6 address. No good choice here.
677 */
678
679 strlcpy(addr_buf, "0.0.0.0", addr_len);
680
681 if (fd == -1) {
682 return addr_buf;
683 }
684
685 if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
686 DEBUG(0,("getsockname failed. Error was %s\n",
687 strerror(errno) ));
688 return addr_buf;
689 }
690
691 return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
692}
693
694const char *client_socket_addr(int fd, char *addr, size_t addr_len)
695{
696 return get_socket_addr(fd, addr, addr_len);
697}
Note: See TracBrowser for help on using the repository browser.