s3: Fix a typo
[sfrench/samba-autobuild/.git] / lib / util / util_net.c
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 #undef strcasecmp
31
32 /*******************************************************************
33  Set an address to INADDR_ANY.
34 ******************************************************************/
35
36 void zero_sockaddr(struct sockaddr_storage *pss)
37 {
38         memset(pss, '\0', sizeof(*pss));
39         /* Ensure we're at least a valid sockaddr-storage. */
40         pss->ss_family = AF_INET;
41 }
42
43 /**
44  * Wrap getaddrinfo...
45  */
46 bool interpret_string_addr_internal(struct addrinfo **ppres,
47                                         const char *str, int flags)
48 {
49         int ret;
50         struct addrinfo hints;
51
52         memset(&hints, '\0', sizeof(hints));
53         /* By default make sure it supports TCP. */
54         hints.ai_socktype = SOCK_STREAM;
55         hints.ai_flags = flags;
56
57         /* Linux man page on getaddrinfo() says port will be
58            uninitialized when service string in NULL */
59
60         ret = getaddrinfo(str, NULL,
61                         &hints,
62                         ppres);
63
64         if (ret) {
65                 DEBUG(3,("interpret_string_addr_internal: getaddrinfo failed "
66                         "for name %s [%s]\n",
67                         str,
68                         gai_strerror(ret) ));
69                 return false;
70         }
71         return true;
72 }
73
74 /*******************************************************************
75  Map a text hostname or IP address (IPv4 or IPv6) into a
76  struct sockaddr_storage. Takes a flag which allows it to
77  prefer an IPv4 address (needed for DC's).
78 ******************************************************************/
79
80 static bool interpret_string_addr_pref(struct sockaddr_storage *pss,
81                 const char *str,
82                 int flags,
83                 bool prefer_ipv4)
84 {
85         struct addrinfo *res = NULL;
86 #if defined(HAVE_IPV6)
87         char addr[INET6_ADDRSTRLEN];
88         unsigned int scope_id = 0;
89
90         if (strchr_m(str, ':')) {
91                 char *p = strchr_m(str, '%');
92
93                 /*
94                  * Cope with link-local.
95                  * This is IP:v6:addr%ifname.
96                  */
97
98                 if (p && (p > str) && ((scope_id = if_nametoindex(p+1)) != 0)) {
99                         strlcpy(addr, str,
100                                 MIN(PTR_DIFF(p,str)+1,
101                                         sizeof(addr)));
102                         str = addr;
103                 }
104         }
105 #endif
106
107         zero_sockaddr(pss);
108
109         if (!interpret_string_addr_internal(&res, str, flags|AI_ADDRCONFIG)) {
110                 return false;
111         }
112         if (!res) {
113                 return false;
114         }
115
116         if (prefer_ipv4) {
117                 struct addrinfo *p;
118
119                 for (p = res; p; p = p->ai_next) {
120                         if (p->ai_family == AF_INET) {
121                                 memcpy(pss, p->ai_addr, p->ai_addrlen);
122                                 break;
123                         }
124                 }
125                 if (p == NULL) {
126                         /* Copy the first sockaddr. */
127                         memcpy(pss, res->ai_addr, res->ai_addrlen);
128                 }
129         } else {
130                 /* Copy the first sockaddr. */
131                 memcpy(pss, res->ai_addr, res->ai_addrlen);
132         }
133
134 #if defined(HAVE_IPV6)
135         if (pss->ss_family == AF_INET6 && scope_id) {
136                 struct sockaddr_in6 *ps6 = (struct sockaddr_in6 *)pss;
137                 if (IN6_IS_ADDR_LINKLOCAL(&ps6->sin6_addr) &&
138                                 ps6->sin6_scope_id == 0) {
139                         ps6->sin6_scope_id = scope_id;
140                 }
141         }
142 #endif
143
144         freeaddrinfo(res);
145         return true;
146 }
147
148 /*******************************************************************
149  Map a text hostname or IP address (IPv4 or IPv6) into a
150  struct sockaddr_storage. Address agnostic version.
151 ******************************************************************/
152
153 bool interpret_string_addr(struct sockaddr_storage *pss,
154                 const char *str,
155                 int flags)
156 {
157         return interpret_string_addr_pref(pss,
158                                         str,
159                                         flags,
160                                         false);
161 }
162
163 /*******************************************************************
164  Map a text hostname or IP address (IPv4 or IPv6) into a
165  struct sockaddr_storage. Version that prefers IPv4.
166 ******************************************************************/
167
168 bool interpret_string_addr_prefer_ipv4(struct sockaddr_storage *pss,
169                 const char *str,
170                 int flags)
171 {
172         return interpret_string_addr_pref(pss,
173                                         str,
174                                         flags,
175                                         true);
176 }
177
178 /**
179  * Interpret an internet address or name into an IP address in 4 byte form.
180  * RETURNS IN NETWORK BYTE ORDER (big endian).
181  */
182
183 uint32_t interpret_addr(const char *str)
184 {
185         uint32_t ret;
186
187         /* If it's in the form of an IP address then
188          * get the lib to interpret it */
189         if (is_ipaddress_v4(str)) {
190                 struct in_addr dest;
191
192                 if (inet_pton(AF_INET, str, &dest) <= 0) {
193                         /* Error - this shouldn't happen ! */
194                         DEBUG(0,("interpret_addr: inet_pton failed "
195                                 "host %s\n",
196                                 str));
197                         return 0;
198                 }
199                 ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
200         } else {
201                 /* Otherwise assume it's a network name of some sort and use
202                         getadddrinfo. */
203                 struct addrinfo *res = NULL;
204                 struct addrinfo *res_list = NULL;
205                 if (!interpret_string_addr_internal(&res_list,
206                                         str,
207                                         AI_ADDRCONFIG)) {
208                         DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
209                         return 0;
210                 }
211
212                 /* Find the first IPv4 address. */
213                 for (res = res_list; res; res = res->ai_next) {
214                         if (res->ai_family != AF_INET) {
215                                 continue;
216                         }
217                         if (res->ai_addr == NULL) {
218                                 continue;
219                         }
220                         break;
221                 }
222                 if(res == NULL) {
223                         DEBUG(3,("interpret_addr: host address is "
224                                 "invalid for host %s\n",str));
225                         if (res_list) {
226                                 freeaddrinfo(res_list);
227                         }
228                         return 0;
229                 }
230                 memcpy((char *)&ret,
231                         &((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
232                         sizeof(ret));
233                 if (res_list) {
234                         freeaddrinfo(res_list);
235                 }
236         }
237
238         /* This is so bogus - all callers need fixing... JRA. */
239         if (ret == (uint32_t)-1) {
240                 return 0;
241         }
242
243         return ret;
244 }
245
246 /**
247  A convenient addition to interpret_addr().
248 **/
249 _PUBLIC_ struct in_addr interpret_addr2(const char *str)
250 {
251         struct in_addr ret;
252         uint32_t a = interpret_addr(str);
253         ret.s_addr = a;
254         return ret;
255 }
256
257 /**
258  Check if an IP is the 0.0.0.0.
259 **/
260
261 _PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
262 {
263         return ip.s_addr == 0;
264 }
265
266 /**
267  Are two IPs on the same subnet?
268 **/
269
270 _PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
271 {
272         uint32_t net1,net2,nmask;
273
274         nmask = ntohl(mask.s_addr);
275         net1  = ntohl(ip1.s_addr);
276         net2  = ntohl(ip2.s_addr);
277             
278         return((net1 & nmask) == (net2 & nmask));
279 }
280
281 /**
282  * Return true if a string could be an IPv4 address.
283  */
284
285 bool is_ipaddress_v4(const char *str)
286 {
287         int ret = -1;
288         struct in_addr dest;
289
290         ret = inet_pton(AF_INET, str, &dest);
291         if (ret > 0) {
292                 return true;
293         }
294         return false;
295 }
296
297 /**
298  * Return true if a string could be an IPv4 or IPv6 address.
299  */
300
301 bool is_ipaddress(const char *str)
302 {
303 #if defined(HAVE_IPV6)
304         int ret = -1;
305
306         if (strchr_m(str, ':')) {
307                 char addr[INET6_ADDRSTRLEN];
308                 struct in6_addr dest6;
309                 const char *sp = str;
310                 char *p = strchr_m(str, '%');
311
312                 /*
313                  * Cope with link-local.
314                  * This is IP:v6:addr%ifname.
315                  */
316
317                 if (p && (p > str) && (if_nametoindex(p+1) != 0)) {
318                         strlcpy(addr, str,
319                                 MIN(PTR_DIFF(p,str)+1,
320                                         sizeof(addr)));
321                         sp = addr;
322                 }
323                 ret = inet_pton(AF_INET6, sp, &dest6);
324                 if (ret > 0) {
325                         return true;
326                 }
327         }
328 #endif
329         return is_ipaddress_v4(str);
330 }
331
332 /**
333  * Is a sockaddr a broadcast address ?
334  */
335
336 bool is_broadcast_addr(const struct sockaddr *pss)
337 {
338 #if defined(HAVE_IPV6)
339         if (pss->sa_family == AF_INET6) {
340                 const struct in6_addr *sin6 =
341                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
342                 return IN6_IS_ADDR_MULTICAST(sin6);
343         }
344 #endif
345         if (pss->sa_family == AF_INET) {
346                 uint32_t addr =
347                 ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
348                 return addr == INADDR_BROADCAST;
349         }
350         return false;
351 }
352
353 /**
354  * Check if an IPv7 is 127.0.0.1
355  */
356 bool is_loopback_ip_v4(struct in_addr ip)
357 {
358         struct in_addr a;
359         a.s_addr = htonl(INADDR_LOOPBACK);
360         return(ip.s_addr == a.s_addr);
361 }
362
363 /**
364  * Check if a struct sockaddr is the loopback address.
365  */
366 bool is_loopback_addr(const struct sockaddr *pss)
367 {
368 #if defined(HAVE_IPV6)
369         if (pss->sa_family == AF_INET6) {
370                 const struct in6_addr *pin6 =
371                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
372                 return IN6_IS_ADDR_LOOPBACK(pin6);
373         }
374 #endif
375         if (pss->sa_family == AF_INET) {
376                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
377                 return is_loopback_ip_v4(*pin);
378         }
379         return false;
380 }
381
382 /**
383  * Check if a struct sockaddr has an unspecified address.
384  */
385 bool is_zero_addr(const struct sockaddr *pss)
386 {
387 #if defined(HAVE_IPV6)
388         if (pss->sa_family == AF_INET6) {
389                 const struct in6_addr *pin6 =
390                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
391                 return IN6_IS_ADDR_UNSPECIFIED(pin6);
392         }
393 #endif
394         if (pss->sa_family == AF_INET) {
395                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
396                 return is_zero_ip_v4(*pin);
397         }
398         return false;
399 }
400
401 /**
402  * Set an IP to 0.0.0.0.
403  */
404 void zero_ip_v4(struct in_addr *ip)
405 {
406         memset(ip, '\0', sizeof(struct in_addr));
407 }
408
409 /**
410  * Convert an IPv4 struct in_addr to a struct sockaddr_storage.
411  */
412 void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
413                 struct in_addr ip)
414 {
415         struct sockaddr_in *sa = (struct sockaddr_in *)ss;
416         memset(ss, '\0', sizeof(*ss));
417         sa->sin_family = AF_INET;
418         sa->sin_addr = ip;
419 }
420
421 #if defined(HAVE_IPV6)
422 /**
423  * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
424  */
425 void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
426                 struct in6_addr ip)
427 {
428         struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
429         memset(ss, '\0', sizeof(*ss));
430         sa->sin6_family = AF_INET6;
431         sa->sin6_addr = ip;
432 }
433 #endif
434
435 /**
436  * Are two IPs on the same subnet?
437  */
438 bool same_net(const struct sockaddr *ip1,
439                 const struct sockaddr *ip2,
440                 const struct sockaddr *mask)
441 {
442         if (ip1->sa_family != ip2->sa_family) {
443                 /* Never on the same net. */
444                 return false;
445         }
446
447 #if defined(HAVE_IPV6)
448         if (ip1->sa_family == AF_INET6) {
449                 struct sockaddr_in6 ip1_6 = *(const struct sockaddr_in6 *)ip1;
450                 struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
451                 struct sockaddr_in6 mask_6 = *(const struct sockaddr_in6 *)mask;
452                 char *p1 = (char *)&ip1_6.sin6_addr;
453                 char *p2 = (char *)&ip2_6.sin6_addr;
454                 char *m = (char *)&mask_6.sin6_addr;
455                 int i;
456
457                 for (i = 0; i < sizeof(struct in6_addr); i++) {
458                         *p1++ &= *m;
459                         *p2++ &= *m;
460                         m++;
461                 }
462                 return (memcmp(&ip1_6.sin6_addr,
463                                 &ip2_6.sin6_addr,
464                                 sizeof(struct in6_addr)) == 0);
465         }
466 #endif
467         if (ip1->sa_family == AF_INET) {
468                 return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
469                                 ((const struct sockaddr_in *)ip2)->sin_addr,
470                                 ((const struct sockaddr_in *)mask)->sin_addr);
471         }
472         return false;
473 }
474
475 /**
476  * Are two sockaddr 's the same family and address ? Ignore port etc.
477  */
478
479 bool sockaddr_equal(const struct sockaddr *ip1,
480                 const struct sockaddr *ip2)
481 {
482         if (ip1->sa_family != ip2->sa_family) {
483                 /* Never the same. */
484                 return false;
485         }
486
487 #if defined(HAVE_IPV6)
488         if (ip1->sa_family == AF_INET6) {
489                 return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
490                                 &((const struct sockaddr_in6 *)ip2)->sin6_addr,
491                                 sizeof(struct in6_addr)) == 0);
492         }
493 #endif
494         if (ip1->sa_family == AF_INET) {
495                 return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
496                                 &((const struct sockaddr_in *)ip2)->sin_addr,
497                                 sizeof(struct in_addr)) == 0);
498         }
499         return false;
500 }
501
502 /**
503  * Is an IP address the INADDR_ANY or in6addr_any value ?
504  */
505 bool is_address_any(const struct sockaddr *psa)
506 {
507 #if defined(HAVE_IPV6)
508         if (psa->sa_family == AF_INET6) {
509                 const struct sockaddr_in6 *si6 = (const struct sockaddr_in6 *)psa;
510                 if (memcmp(&in6addr_any,
511                                 &si6->sin6_addr,
512                                 sizeof(in6addr_any)) == 0) {
513                         return true;
514                 }
515                 return false;
516         }
517 #endif
518         if (psa->sa_family == AF_INET) {
519                 const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
520                 if (si->sin_addr.s_addr == INADDR_ANY) {
521                         return true;
522                 }
523                 return false;
524         }
525         return false;
526 }
527
528 void set_sockaddr_port(struct sockaddr *psa, uint16_t port)
529 {
530 #if defined(HAVE_IPV6)
531         if (psa->sa_family == AF_INET6) {
532                 ((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
533         }
534 #endif
535         if (psa->sa_family == AF_INET) {
536                 ((struct sockaddr_in *)psa)->sin_port = htons(port);
537         }
538 }
539
540