2c9c9eced90abadb76b850dc1c68e1df4b98b3fd
[openafs.git] / src / rx / rx_getaddr.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #ifndef AFS_DJGPP_ENV
17 #ifndef KERNEL
18 #ifndef AFS_NT40_ENV
19 #include <sys/types.h>
20 #include <sys/socket.h>
21 #include <sys/time.h>
22 #include <net/if.h>
23 #include <netinet/in.h>
24 #include <sys/ioctl.h>
25 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
26 #include <sys/sysctl.h>
27 #include <net/route.h>
28 #include <net/if_dl.h>
29 #endif
30
31 /*
32  * By including this, we get any system dependencies. In particular,
33  * the pthreads for solaris requires the socket call to be mapped.
34  */
35 #include "rx.h"
36 #include "rx_globals.h"
37 #endif /* AFS_NT40_ENV */
38 #else /* KERNEL */
39 #ifdef UKERNEL
40 #include "rx/rx_kcommon.h"
41 #else /* UKERNEL */
42 #include "rx/rx.h"
43 #endif /* UKERNEL */
44 #endif /* KERNEL */
45
46 #define NIFS            512
47
48 #ifdef KERNEL
49 /* only used for generating random noise */
50
51 afs_int32 rxi_tempAddr = 0;     /* default attempt */
52
53 /* set the advisory noise */
54 void
55 rxi_setaddr(afs_int32 x)
56 {
57     rxi_tempAddr = x;
58 }
59
60 /* get approx to net addr */
61 afs_int32
62 rxi_getaddr(void)
63 {
64     return rxi_tempAddr;
65 }
66
67 #endif /* KERNEL */
68
69 #ifndef KERNEL
70
71 /* to satisfy those who call setaddr */
72 void
73 rxi_setaddr(afs_int32 x)
74 {
75 }
76
77 #endif /* !KERNEL */
78
79
80 #if !defined(AFS_NT40_ENV)
81 /* For NT, rxi_getaddr has moved to rx_user.c. rxi_GetIfInfo is called by
82  * rx_Init which sets up the list of addresses for us.
83  */
84
85 #ifndef KERNEL
86
87 /* Return our internet address as a long in network byte order.  Returns zero
88  * if it can't find one.
89  */
90 afs_int32
91 rxi_getaddr(void)
92 {
93     afs_int32 buffer[1024];
94     int count;
95
96     count = rx_getAllAddr(buffer, 1024);
97     if (count > 0)
98         return buffer[0];       /* returns the first address */
99     else
100         return count;
101 }
102
103 #endif /* !KERNEL */
104
105 #if !defined(KERNEL) || defined(UKERNEL)
106
107 #ifndef MAX
108 #define MAX(A,B) (((A)<(B)) ? (B) : (A))
109 #endif
110
111 #ifdef UKERNEL
112 #undef ioctl
113 #undef socket
114 #endif /* UKERNEL */
115
116 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
117 #define ROUNDUP(a) \
118         ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
119 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
120
121 static void
122 rt_xaddrs(caddr_t cp, caddr_t cplim, struct rt_addrinfo *rtinfo)
123 {
124     struct sockaddr *sa;
125     int i;
126
127     memset(rtinfo->rti_info, 0, sizeof(rtinfo->rti_info));
128     for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
129         if ((rtinfo->rti_addrs & (1 << i)) == 0)
130             continue;
131         rtinfo->rti_info[i] = sa = (struct sockaddr *)cp;
132         ADVANCE(cp, sa);
133     }
134 }
135 #endif
136
137
138 /* this function returns the total number of interface addresses 
139 ** the buffer has to be passed in by the caller
140 */
141 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
142 int
143 rx_getAllAddr(afs_int32 buffer[], int maxSize)
144 {
145     size_t needed;
146     int mib[6];
147     struct if_msghdr *ifm, *nextifm;
148     struct ifa_msghdr *ifam;
149     struct sockaddr_dl *sdl;
150     struct rt_addrinfo info;
151     char *buf, *lim, *next;
152     int count = 0, addrcount = 0;
153
154     mib[0] = CTL_NET;
155     mib[1] = PF_ROUTE;
156     mib[2] = 0;
157     mib[3] = AF_INET;           /* address family */
158     mib[4] = NET_RT_IFLIST;
159     mib[5] = 0;
160     if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
161         return 0;
162     if ((buf = malloc(needed)) == NULL)
163         return 0;
164     if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
165         free(buf);
166         return 0;
167     }
168     lim = buf + needed;
169     next = buf;
170     while (next < lim) {
171         ifm = (struct if_msghdr *)next;
172         if (ifm->ifm_type != RTM_IFINFO) {
173             dpf(("out of sync parsing NET_RT_IFLIST\n"));
174             free(buf);
175             return 0;
176         }
177         sdl = (struct sockaddr_dl *)(ifm + 1);
178         next += ifm->ifm_msglen;
179         ifam = NULL;
180         addrcount = 0;
181         while (next < lim) {
182             nextifm = (struct if_msghdr *)next;
183             if (nextifm->ifm_type != RTM_NEWADDR)
184                 break;
185             if (ifam == NULL)
186                 ifam = (struct ifa_msghdr *)nextifm;
187             addrcount++;
188             next += nextifm->ifm_msglen;
189         }
190         if ((ifm->ifm_flags & IFF_UP) == 0)
191             continue;           /* not up */
192         if (ifm->ifm_flags & IFF_LOOPBACK) {
193             continue;           /* skip aliased loopbacks as well. */
194         }
195         while (addrcount > 0) {
196             struct sockaddr_in *a;
197
198             info.rti_addrs = ifam->ifam_addrs;
199
200             /* Expand the compacted addresses */
201             rt_xaddrs((char *)(ifam + 1), ifam->ifam_msglen + (char *)ifam,
202                       &info);
203             if (info.rti_info[RTAX_IFA]->sa_family != AF_INET)
204                 continue;
205             a = info.rti_info[RTAX_IFA];
206
207             if (count >= maxSize)       /* no more space */
208                 dpf(("Too many interfaces..ignoring 0x%x\n",
209                        a->sin_addr.s_addr));
210             else
211                 buffer[count++] = a->sin_addr.s_addr;
212             addrcount--;
213             ifam = (struct ifa_msghdr *)((char *)ifam + ifam->ifam_msglen);
214         }
215     }
216     free(buf);
217     return count;
218 }
219
220 int
221 rxi_getAllAddrMaskMtu(afs_int32 addrBuffer[], afs_int32 maskBuffer[],
222                       afs_int32 mtuBuffer[], int maxSize)
223 {
224     int s;
225
226     size_t needed;
227     int mib[6];
228     struct if_msghdr *ifm, *nextifm;
229     struct ifa_msghdr *ifam;
230     struct sockaddr_dl *sdl;
231     struct rt_addrinfo info;
232     char *buf, *lim, *next;
233     int count = 0, addrcount = 0;
234
235     mib[0] = CTL_NET;
236     mib[1] = PF_ROUTE;
237     mib[2] = 0;
238     mib[3] = AF_INET;           /* address family */
239     mib[4] = NET_RT_IFLIST;
240     mib[5] = 0;
241     if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
242         return 0;
243     if ((buf = malloc(needed)) == NULL)
244         return 0;
245     if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
246         free(buf);
247         return 0;
248     }
249     s = socket(PF_INET, SOCK_DGRAM, 0);
250     if (s < 0)
251         return 0;
252     lim = buf + needed;
253     next = buf;
254     while (next < lim) {
255         ifm = (struct if_msghdr *)next;
256         if (ifm->ifm_type != RTM_IFINFO) {
257             dpf(("out of sync parsing NET_RT_IFLIST\n"));
258             free(buf);
259             return 0;
260         }
261         sdl = (struct sockaddr_dl *)(ifm + 1);
262         next += ifm->ifm_msglen;
263         ifam = NULL;
264         addrcount = 0;
265         while (next < lim) {
266             nextifm = (struct if_msghdr *)next;
267             if (nextifm->ifm_type != RTM_NEWADDR)
268                 break;
269             if (ifam == NULL)
270                 ifam = (struct ifa_msghdr *)nextifm;
271             addrcount++;
272             next += nextifm->ifm_msglen;
273         }
274         if ((ifm->ifm_flags & IFF_UP) == 0)
275             continue;           /* not up */
276         while (addrcount > 0) {
277             struct sockaddr_in *a;
278
279             info.rti_addrs = ifam->ifam_addrs;
280
281             /* Expand the compacted addresses */
282             rt_xaddrs((char *)(ifam + 1), ifam->ifam_msglen + (char *)ifam,
283                       &info);
284             if (info.rti_info[RTAX_IFA]->sa_family != AF_INET)
285                 continue;
286             a = info.rti_info[RTAX_IFA];
287
288             if (a->sin_addr.s_addr != htonl(0x7f000001) ) {
289                 if (count >= maxSize) { /* no more space */
290                     dpf(("Too many interfaces..ignoring 0x%x\n",
291                            a->sin_addr.s_addr));
292                 } else {
293                     struct ifreq ifr;
294                     
295                     addrBuffer[count] = a->sin_addr.s_addr;
296                     a = info.rti_info[RTAX_NETMASK];
297                     if (a)
298                         maskBuffer[count] = a->sin_addr.s_addr;
299                     else
300                         maskBuffer[count] = htonl(0xffffffff);
301                     memset(&ifr, sizeof(ifr), 0);
302                     ifr.ifr_addr.sa_family = AF_INET;
303                     strncpy(ifr.ifr_name, sdl->sdl_data, sdl->sdl_nlen);
304                     if (ioctl(s, SIOCGIFMTU, (caddr_t) & ifr) < 0)
305                         mtuBuffer[count] = htonl(1500);
306                     else
307                         mtuBuffer[count] = htonl(ifr.ifr_mtu);
308                     count++;
309                 }
310             }
311             addrcount--;
312             ifam = (struct ifa_msghdr *)((char *)ifam + ifam->ifam_msglen);
313         }
314     }
315     free(buf);
316     return count;
317 }
318 #else
319 static int
320 rx_getAllAddr_internal(afs_int32 buffer[], int maxSize, int loopbacks)
321 {
322     int s;
323     int i, len, count = 0;
324     struct ifconf ifc;
325     struct ifreq ifs[NIFS], *ifr;
326     struct sockaddr_in *a;
327 #if    defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
328     char *cp, *cplim, *cpnext;  /* used only for AIX 41 */
329 #endif
330
331     s = socket(AF_INET, SOCK_DGRAM, 0);
332     if (s < 0)
333         return 0;
334     ifc.ifc_len = sizeof(ifs);
335     ifc.ifc_buf = (caddr_t) ifs;
336     i = ioctl(s, SIOCGIFCONF, &ifc);
337     if (i < 0)
338         return 0;
339     len = ifc.ifc_len / sizeof(struct ifreq);
340     if (len > NIFS)
341         len = NIFS;
342 #if    defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
343     if (ifc.ifc_len > sizeof(ifs))      /* safety check */
344         ifc.ifc_len = sizeof(ifs);
345     for (cp = (char *)ifc.ifc_buf, cplim = ifc.ifc_buf + ifc.ifc_len;
346          cp < cplim;
347 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
348          cp += _SIZEOF_ADDR_IFREQ(*ifr)
349 #else
350 #ifdef AFS_AIX51_ENV
351          cp = cpnext
352 #else
353          cp += sizeof(ifr->ifr_name) + MAX(a->sin_len, sizeof(*a))
354 #endif
355 #endif
356         ) 
357 #else
358     for (i = 0; i < len; ++i) 
359 #endif
360     {
361 #if    defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
362         ifr = (struct ifreq *)cp;
363 #else
364         ifr = &ifs[i];
365 #endif
366         a = (struct sockaddr_in *)&ifr->ifr_addr;
367 #ifdef AFS_AIX51_ENV
368         cpnext = cp + sizeof(ifr->ifr_name) + MAX(a->sin_len, sizeof(*a));
369 #endif
370         if (a->sin_family != AF_INET)
371             continue;
372         if (ioctl(s, SIOCGIFFLAGS, ifr) < 0) {
373             perror("SIOCGIFFLAGS");
374             continue;           /* ignore this address */
375         }
376         if (a->sin_addr.s_addr != 0) {
377             if (!loopbacks) {
378                 if (a->sin_addr.s_addr == htonl(0x7f000001)) 
379                     continue;   /* skip loopback address as well. */
380             } else {
381                 if (ifr->ifr_flags & IFF_LOOPBACK) 
382                     continue;   /* skip aliased loopbacks as well. */
383             }
384             if (count >= maxSize)       /* no more space */
385                 dpf(("Too many interfaces..ignoring 0x%x\n",
386                        a->sin_addr.s_addr));
387             else
388                 buffer[count++] = a->sin_addr.s_addr;
389         }
390     }
391     close(s);
392     return count;
393 }
394
395 int
396 rx_getAllAddr(afs_int32 buffer[], int maxSize)
397 {
398     return rx_getAllAddr_internal(buffer, maxSize, 0);
399 }
400
401 /* this function returns the total number of interface addresses
402  * the buffer has to be passed in by the caller. It also returns
403  * the interface mask. If AFS_USERSPACE_IP_ADDR is defined, it
404  * gets the mask which is then passed into the kernel and is used
405  * by afsi_SetServerIPRank().
406  */
407 int
408 rxi_getAllAddrMaskMtu(afs_int32 addrBuffer[], afs_int32 maskBuffer[],
409                       afs_int32 mtuBuffer[], int maxSize)
410 {
411     int s;
412     int i, len, count = 0;
413     struct ifconf ifc;
414     struct ifreq ifs[NIFS], *ifr;
415     struct sockaddr_in *a;
416 #if     defined(AFS_AIX41_ENV) || defined(AFS_USR_AIX_ENV)
417     char *cp, *cplim;           /* used only for AIX 41 */
418 #endif
419
420 #if !defined(AFS_USERSPACE_IP_ADDR)
421     count = rx_getAllAddr_internal(addrBuffer, 1024, 1);
422     for (i = 0; i < count; i++) {
423         maskBuffer[i] = htonl(0xffffffff);
424         mtuBuffer[i] = htonl(1500);
425     }
426     return count;
427 #else /* AFS_USERSPACE_IP_ADDR */
428     s = socket(AF_INET, SOCK_DGRAM, 0);
429     if (s < 0)
430         return 0;
431
432     ifc.ifc_len = sizeof(ifs);
433     ifc.ifc_buf = (caddr_t) ifs;
434     i = ioctl(s, SIOCGIFCONF, &ifc);
435     if (i < 0) {
436         close(s);
437         return 0;
438     }
439     len = ifc.ifc_len / sizeof(struct ifreq);
440     if (len > NIFS)
441         len = NIFS;
442
443 #if     defined(AFS_AIX41_ENV) || defined(AFS_USR_AIX_ENV)
444     if (ifc.ifc_len > sizeof(ifs))      /* safety check */
445         ifc.ifc_len = sizeof(ifs);
446     for (cp = (char *)ifc.ifc_buf, cplim = ifc.ifc_buf + ifc.ifc_len;
447          cp < cplim;
448          cp += sizeof(ifr->ifr_name) + MAX(a->sin_len, sizeof(*a))) {
449         ifr = (struct ifreq *)cp;
450 #else
451     for (i = 0; i < len; ++i) {
452         ifr = &ifs[i];
453 #endif
454         a = (struct sockaddr_in *)&ifr->ifr_addr;
455         if (a->sin_addr.s_addr != 0 && a->sin_family == AF_INET) {
456
457             if (ioctl(s, SIOCGIFFLAGS, ifr) < 0) {
458                 perror("SIOCGIFFLAGS");
459                 continue;       /* ignore this address */
460             }
461
462             if (a->sin_addr.s_addr == htonl(0x7f000001) )
463                 continue;   /* skip loopback address as well. */
464
465             if (count >= maxSize) {     /* no more space */
466                 dpf(("Too many interfaces..ignoring 0x%x\n",
467                        a->sin_addr.s_addr));
468                 continue;
469             }
470
471             addrBuffer[count] = a->sin_addr.s_addr;
472
473             if (ioctl(s, SIOCGIFNETMASK, (caddr_t) ifr) < 0) {
474                 perror("SIOCGIFNETMASK");
475                 maskBuffer[count] = htonl(0xffffffff);
476             } else {
477                 maskBuffer[count] = (((struct sockaddr_in *)
478                                       (&ifr->ifr_addr))->sin_addr).s_addr;
479             }
480
481             mtuBuffer[count] = htonl(1500);
482 #ifdef SIOCGIFMTU
483             if (ioctl(s, SIOCGIFMTU, (caddr_t) ifr) < 0) {
484                 perror("SIOCGIFMTU");
485             } else {
486                 mtuBuffer[count] = htonl(ifr->ifr_metric);
487             }
488 #endif /* SIOCGIFMTU */
489 #ifdef SIOCRIPMTU
490             if (ioctl(s, SIOCRIPMTU, (caddr_t) ifr) < 0) {
491                 perror("SIOCRIPMTU");
492             } else {
493                 mtuBuffer[count] = htonl(ifr->ifr_metric);
494             }
495 #endif /* SIOCRIPMTU */
496
497             count++;
498         }
499     }
500     close(s);
501     return count;
502 #endif /* AFS_USERSPACE_IP_ADDR */
503 }
504 #endif
505
506 #endif /* ! AFS_NT40_ENV */
507 #endif /* !KERNEL || UKERNEL */
508
509 #endif /* !AFS_DJGPP_ENV */