2846813d3f3958e3fc0f8152da1c6031239255ae
[sfrench/samba-autobuild/.git] / source4 / lib / socket / netif.c
1 /* 
2    Unix SMB/CIFS implementation.
3    return a list of network interfaces
4    Copyright (C) Andrew Tridgell 1998
5    Copyright (C) Jeremy Allison 2007
6    Copyright (C) Jelmer Vernooij 2007
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22
23 /* working out the interfaces for a OS is an incredibly non-portable
24    thing. We have several possible implementations below, and autoconf
25    tries each of them to see what works
26
27    Note that this file does _not_ include includes.h. That is so this code
28    can be called directly from the autoconf tests. That also means
29    this code cannot use any of the normal Samba debug stuff or defines.
30    This is standalone code.
31
32 */
33
34 #include "includes.h"
35 #include "system/network.h"
36 #include "netif.h"
37 #include "lib/util/tsort.h"
38
39 /****************************************************************************
40  Create a struct sockaddr_storage with the netmask bits set to 1.
41 ****************************************************************************/
42
43 bool make_netmask(struct sockaddr_storage *pss_out,
44                         const struct sockaddr_storage *pss_in,
45                         unsigned long masklen)
46 {
47         *pss_out = *pss_in;
48         /* Now apply masklen bits of mask. */
49 #if defined(HAVE_IPV6)
50         if (pss_in->ss_family == AF_INET6) {
51                 char *p = (char *)&((struct sockaddr_in6 *)pss_out)->sin6_addr;
52                 unsigned int i;
53
54                 if (masklen > 128) {
55                         return false;
56                 }
57                 for (i = 0; masklen >= 8; masklen -= 8, i++) {
58                         *p++ = 0xff;
59                 }
60                 /* Deal with the partial byte. */
61                 *p++ &= (0xff & ~(0xff>>masklen));
62                 i++;
63                 for (;i < sizeof(struct in6_addr); i++) {
64                         *p++ = '\0';
65                 }
66                 return true;
67         }
68 #endif
69         if (pss_in->ss_family == AF_INET) {
70                 if (masklen > 32) {
71                         return false;
72                 }
73                 ((struct sockaddr_in *)pss_out)->sin_addr.s_addr =
74                         htonl(((0xFFFFFFFFL >> masklen) ^ 0xFFFFFFFFL));
75                 return true;
76         }
77         return false;
78 }
79
80 /****************************************************************************
81  Create a struct sockaddr_storage set to the broadcast or network adress from
82  an incoming sockaddr_storage.
83 ****************************************************************************/
84
85 static void make_bcast_or_net(struct sockaddr_storage *pss_out,
86                         const struct sockaddr_storage *pss_in,
87                         const struct sockaddr_storage *nmask,
88                         bool make_bcast_p)
89 {
90         unsigned int i = 0, len = 0;
91         char *pmask = NULL;
92         char *p = NULL;
93         *pss_out = *pss_in;
94
95         /* Set all zero netmask bits to 1. */
96 #if defined(HAVE_IPV6)
97         if (pss_in->ss_family == AF_INET6) {
98                 p = (char *)&((struct sockaddr_in6 *)pss_out)->sin6_addr;
99                 pmask = discard_const_p(char, &((struct sockaddr_in6 *)nmask)->sin6_addr);
100                 len = 16;
101         }
102 #endif
103         if (pss_in->ss_family == AF_INET) {
104                 p = (char *)&((struct sockaddr_in *)pss_out)->sin_addr;
105                 pmask = discard_const_p(char, &((struct sockaddr_in *)nmask)->sin_addr);
106                 len = 4;
107         }
108
109         for (i = 0; i < len; i++, p++, pmask++) {
110                 if (make_bcast_p) {
111                         *p = (*p & *pmask) | (*pmask ^ 0xff);
112                 } else {
113                         /* make_net */
114                         *p = (*p & *pmask);
115                 }
116         }
117 }
118
119 void make_bcast(struct sockaddr_storage *pss_out,
120                         const struct sockaddr_storage *pss_in,
121                         const struct sockaddr_storage *nmask)
122 {
123         make_bcast_or_net(pss_out, pss_in, nmask, true);
124 }
125
126 void make_net(struct sockaddr_storage *pss_out,
127                         const struct sockaddr_storage *pss_in,
128                         const struct sockaddr_storage *nmask)
129 {
130         make_bcast_or_net(pss_out, pss_in, nmask, false);
131 }
132
133
134 /****************************************************************************
135  Try the "standard" getifaddrs/freeifaddrs interfaces.
136  Also gets IPv6 interfaces.
137 ****************************************************************************/
138
139 /****************************************************************************
140  Get the netmask address for a local interface.
141 ****************************************************************************/
142
143 static int _get_interfaces(TALLOC_CTX *mem_ctx, struct iface_struct **pifaces)
144 {
145         struct iface_struct *ifaces;
146         struct ifaddrs *iflist = NULL;
147         struct ifaddrs *ifptr = NULL;
148         int count;
149         int total = 0;
150         size_t copy_size;
151
152         if (getifaddrs(&iflist) < 0) {
153                 return -1;
154         }
155
156         count = 0;
157         for (ifptr = iflist; ifptr != NULL; ifptr = ifptr->ifa_next) {
158                 if (!ifptr->ifa_addr || !ifptr->ifa_netmask) {
159                         continue;
160                 }
161                 if (!(ifptr->ifa_flags & IFF_UP)) {
162                         continue;
163                 }
164                 count += 1;
165         }
166
167         ifaces = talloc_array(mem_ctx, struct iface_struct, count);
168         if (ifaces == NULL) {
169                 errno = ENOMEM;
170                 return -1;
171         }
172
173         /* Loop through interfaces, looking for given IP address */
174         for (ifptr = iflist; ifptr != NULL; ifptr = ifptr->ifa_next) {
175
176                 if (!ifptr->ifa_addr || !ifptr->ifa_netmask) {
177                         continue;
178                 }
179
180                 /* Check the interface is up. */
181                 if (!(ifptr->ifa_flags & IFF_UP)) {
182                         continue;
183                 }
184
185                 memset(&ifaces[total], '\0', sizeof(ifaces[total]));
186
187                 copy_size = sizeof(struct sockaddr_in);
188
189                 ifaces[total].flags = ifptr->ifa_flags;
190
191 #if defined(HAVE_IPV6)
192                 if (ifptr->ifa_addr->sa_family == AF_INET6) {
193                         copy_size = sizeof(struct sockaddr_in6);
194                 }
195 #endif
196
197                 memcpy(&ifaces[total].ip, ifptr->ifa_addr, copy_size);
198                 memcpy(&ifaces[total].netmask, ifptr->ifa_netmask, copy_size);
199
200                 if (ifaces[total].flags & (IFF_BROADCAST|IFF_LOOPBACK)) {
201                         make_bcast(&ifaces[total].bcast,
202                                 &ifaces[total].ip,
203                                 &ifaces[total].netmask);
204                 } else if ((ifaces[total].flags & IFF_POINTOPOINT) &&
205                                ifptr->ifa_dstaddr ) {
206                         memcpy(&ifaces[total].bcast,
207                                 ifptr->ifa_dstaddr,
208                                 copy_size);
209                 } else {
210                         continue;
211                 }
212
213                 strlcpy(ifaces[total].name, ifptr->ifa_name,
214                         sizeof(ifaces[total].name));
215                 total++;
216         }
217
218         freeifaddrs(iflist);
219
220         *pifaces = ifaces;
221         return total;
222 }
223
224 static int iface_comp(struct iface_struct *i1, struct iface_struct *i2)
225 {
226         int r;
227
228 #if defined(HAVE_IPV6)
229         /*
230          * If we have IPv6 - sort these interfaces lower
231          * than any IPv4 ones.
232          */
233         if (i1->ip.ss_family == AF_INET6 &&
234                         i2->ip.ss_family == AF_INET) {
235                 return -1;
236         } else if (i1->ip.ss_family == AF_INET &&
237                         i2->ip.ss_family == AF_INET6) {
238                 return 1;
239         }
240
241         if (i1->ip.ss_family == AF_INET6) {
242                 struct sockaddr_in6 *s1 = (struct sockaddr_in6 *)&i1->ip;
243                 struct sockaddr_in6 *s2 = (struct sockaddr_in6 *)&i2->ip;
244
245                 r = memcmp(&s1->sin6_addr,
246                                 &s2->sin6_addr,
247                                 sizeof(struct in6_addr));
248                 if (r) {
249                         return r;
250                 }
251
252                 s1 = (struct sockaddr_in6 *)&i1->netmask;
253                 s2 = (struct sockaddr_in6 *)&i2->netmask;
254
255                 r = memcmp(&s1->sin6_addr,
256                                 &s2->sin6_addr,
257                                 sizeof(struct in6_addr));
258                 if (r) {
259                         return r;
260                 }
261         }
262 #endif
263
264         /* AIX uses __ss_family instead of ss_family inside of
265            sockaddr_storage. Instead of trying to figure out which field to
266            use, we can just cast it to a sockaddr.
267          */
268
269         if (((struct sockaddr *)&i1->ip)->sa_family == AF_INET) {
270                 struct sockaddr_in *s1 = (struct sockaddr_in *)&i1->ip;
271                 struct sockaddr_in *s2 = (struct sockaddr_in *)&i2->ip;
272
273                 r = ntohl(s1->sin_addr.s_addr) -
274                         ntohl(s2->sin_addr.s_addr);
275                 if (r) {
276                         return r;
277                 }
278
279                 s1 = (struct sockaddr_in *)&i1->netmask;
280                 s2 = (struct sockaddr_in *)&i2->netmask;
281
282                 return ntohl(s1->sin_addr.s_addr) -
283                         ntohl(s2->sin_addr.s_addr);
284         }
285         return 0;
286 }
287
288 /* this wrapper is used to remove duplicates from the interface list generated
289    above */
290 int get_interfaces(TALLOC_CTX *mem_ctx, struct iface_struct **pifaces)
291 {
292         struct iface_struct *ifaces;
293         int total, i, j;
294
295         total = _get_interfaces(mem_ctx, &ifaces);
296         if (total <= 0) return total;
297
298         /* now we need to remove duplicates */
299         TYPESAFE_QSORT(ifaces, total, iface_comp);
300
301         for (i=1;i<total;) {
302                 if (iface_comp(&ifaces[i-1], &ifaces[i]) == 0) {
303                         for (j=i-1;j<total-1;j++) {
304                                 ifaces[j] = ifaces[j+1];
305                         }
306                         total--;
307                 } else {
308                         i++;
309                 }
310         }
311
312         *pifaces = ifaces;
313         return total;
314 }