diff options
Diffstat (limited to 'src/lib/krb5/os/localaddr.c')
| -rw-r--r-- | src/lib/krb5/os/localaddr.c | 233 |
1 files changed, 208 insertions, 25 deletions
diff --git a/src/lib/krb5/os/localaddr.c b/src/lib/krb5/os/localaddr.c index 9079500..aaeade6 100644 --- a/src/lib/krb5/os/localaddr.c +++ b/src/lib/krb5/os/localaddr.c @@ -1,7 +1,7 @@ /* * lib/krb5/os/localaddr.c * - * Copyright 1990,1991 by the Massachusetts Institute of Technology. + * Copyright 1990,1991,2000 by the Massachusetts Institute of Technology. * All Rights Reserved. * * Export of this software from the United States of America may @@ -39,6 +39,7 @@ #include <sys/ioctl.h> #include <sys/time.h> #include <errno.h> +#include <stddef.h> /* * The SIOCGIF* ioctls require a socket. @@ -248,6 +249,45 @@ add_addr (void *P_data, struct sockaddr *a) #define ifreq_size(i) sizeof(struct ifreq) #endif /* HAVE_SA_LEN*/ +/* SIOCGIFCONF: + + The behavior of this ioctl varies across systems. + + NetBSD 1.5-alpha: The returned ifc_len is the desired amount of + space, always. The returned list may be truncated if there isn't + enough room; no overrun. + + Solaris 2.7: Return EINVAL if the buffer space is too small, + including ifc_len==0. (Not sure if this is "too small for a single + entry" or "too small for the entire list"; my Sun has only one + interface.) Solaris is the only system I've found so far that + actually returns an error. + + AIX 4.3.3: Sometimes the returned ifc_len is bigger than the + supplied one, but it may not be big enough for *all* the + interfaces. Sometimes it's smaller than the supplied value, even + if the returned list is truncated. The list is filled in with as + many entries as will fit; no overrun. + + Linux 2.2.12 (RH 6.1 dist, x86): The buffer is filled in with as + many entries as will fit, and the size used is returned in ifc_len. + The list is truncated if needed, with no indication. + + IRIX 6.5: The buffer is filled in with as many entries as will fit + in N-1 bytes, and the size used is returned in ifc_len. Providing + exactly the desired number of bytes is inadequate; the buffer must + be *bigger* than needed. (E.g., 32->0, 33->32.) The returned + ifc_len is always less than the supplied one. + + Digital UNIX 4.0F: If input ifc_len is zero, return an ifc_len + that's big enough to include all entries. (Actually, on our + system, it appears to be larger than that by 32.) If input ifc_len + is nonzero, fill in as many entries as will fit, and set ifc_len + accordingly. + + Using this ioctl is going to be messy. Let's just hope that + getifaddrs() catches on quickly.... */ + static int foreach_localaddr (data, pass1fn, betweenfn, pass2fn) void *data; @@ -255,13 +295,17 @@ foreach_localaddr (data, pass1fn, betweenfn, pass2fn) int (*betweenfn) (void *); int (*pass2fn) (void *, struct sockaddr *); { - struct ifreq *ifr, ifreq; + struct ifreq *ifr, ifreq, *ifr2; struct ifconf ifc; - int s, code, n, i; + int s, code, n, i, j; int est_if_count = 8, est_ifreq_size; char *buf = 0; size_t current_buf_size = 0; - + int fail = 0; +#ifdef SIOCGSIZIFCONF + int ifconfsize = -1; +#endif + s = socket (USE_AF, USE_TYPE, USE_PROTO); if (s < 0) return SOCKET_ERRNO; @@ -269,8 +313,17 @@ foreach_localaddr (data, pass1fn, betweenfn, pass2fn) /* At least on NetBSD, an ifreq can hold an IPv4 address, but isn't big enough for an IPv6 or ethernet address. So add a little more space. */ - est_ifreq_size = sizeof (struct ifreq) + 8; - current_buf_size = est_ifreq_size * est_if_count; + est_ifreq_size = sizeof (struct ifreq) + 16; +#ifdef SIOCGSIZIFCONF + code = ioctl (s, SIOCGSIZIFCONF, &ifconfsize); + if (!code) { + current_buf_size = ifconfsize; + est_if_count = ifconfsize / est_ifreq_size; + } +#endif + if (current_buf_size == 0) { + current_buf_size = est_ifreq_size * est_if_count; + } buf = malloc (current_buf_size); ask_again: @@ -284,12 +337,35 @@ foreach_localaddr (data, pass1fn, betweenfn, pass2fn) closesocket (s); return retval; } - /* Test that the buffer was big enough that another ifreq could've + /* BSD 4.4 and similar systems truncate the address list if the + supplied buffer isn't big enough. + + Test that the buffer was big enough that another ifreq could've fit easily, if the OS wanted to provide one. That seems to be the only indication we get, complicated by the fact that the associated address may make the required storage a little bigger than the size of an ifreq. */ - if (current_buf_size - ifc.ifc_len < sizeof (struct ifreq) + 40) { +#define SLOP (sizeof (struct ifreq) + 128) + if ((current_buf_size - ifc.ifc_len < sizeof (struct ifreq) + SLOP + /* On AIX 4.3.3, ifc.ifc_len may be set to a larger size than + provided under some circumstances. On my test system, a + supplied value of 32..112 gets me 112, but with no data + filled in even at 112. But larger input ifc_len values get + me larger output values, so it's not necessarily the full + desired output buffer size. And as near as I can tell, the + ifc_len output has little to do with the offset of the last + byte in the buffer actually modified, except that both + input and output ifc_len values are higher (i.e., no buffer + overrun takes place in my testing). */ + || current_buf_size < ifc.ifc_len) + /* But let's let SIOCGSIZIFCONF dominate, unless we discover + it's broken somewhere. */ +#ifdef SIOCGSIZIFCONF + && ifconfsize <= 0 +#endif + /* And we need *some* sort of bounds. */ + && current_buf_size <= 100000 + ) { int new_size; char *newbuf; @@ -307,31 +383,62 @@ foreach_localaddr (data, pass1fn, betweenfn, pass2fn) } n = ifc.ifc_len; - + if (n > current_buf_size) + n = current_buf_size; + + /* Note: Apparently some systems put the size (used or wanted?) + into the start of the buffer, just none that I'm actually + using. Fix this when there's such a test system available. + The Samba mailing list archives mention that NTP looks for the + size on these systems: *-fujitsu-uxp* *-ncr-sysv4* + *-univel-sysv*. [raeburn:20010201T2226-05] */ for (i = 0; i < n; i+= ifreq_size(*ifr) ) { ifr = (struct ifreq *)((caddr_t) ifc.ifc_buf+i); strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof (ifreq.ifr_name)); - if (ioctl (s, SIOCGIFFLAGS, (char *)&ifreq) < 0 -#ifdef IFF_LOOPBACK - /* None of the current callers want loopback addresses. */ - || (ifreq.ifr_flags & IFF_LOOPBACK) -#endif - /* Ignore interfaces that are down. */ - || !(ifreq.ifr_flags & IFF_UP)) { + if (ioctl (s, SIOCGIFFLAGS, (char *)&ifreq) < 0) { + skip: /* mark for next pass */ ifr->ifr_name[0] = 0; continue; } +#ifdef IFF_LOOPBACK + /* None of the current callers want loopback addresses. */ + if (ifreq.ifr_flags & IFF_LOOPBACK) + goto skip; +#endif + /* Ignore interfaces that are down. */ + if (!(ifreq.ifr_flags & IFF_UP)) + goto skip; + + /* Make sure we didn't process this address already. */ + for (j = 0; j < i; j += ifreq_size(*ifr2)) { + ifr2 = (struct ifreq *)((caddr_t) ifc.ifc_buf+j); + if (ifr2->ifr_name[0] == 0) + continue; + if (ifr2->ifr_addr.sa_family == ifr->ifr_addr.sa_family + && ifreq_size (*ifr) == ifreq_size (*ifr2) + /* Compare address info. If this isn't good enough -- + i.e., if random padding bytes turn out to differ + when the addresses are the same -- then we'll have + to do it on a per address family basis. */ + && !memcmp (&ifr2->ifr_addr.sa_data, &ifr->ifr_addr.sa_data, + (ifreq_size (*ifr) + - offsetof (struct ifreq, ifr_addr.sa_data)))) + goto skip; + } + if ((*pass1fn) (data, &ifr->ifr_addr)) { - abort (); + fail = 1; + goto punt; } } if (betweenfn && (*betweenfn)(data)) { - abort (); + fail = 1; + goto punt; } if (pass2fn) @@ -343,13 +450,15 @@ foreach_localaddr (data, pass1fn, betweenfn, pass2fn) continue; if ((*pass2fn) (data, &ifr->ifr_addr)) { - abort (); + fail = 1; + goto punt; } } + punt: closesocket(s); free (buf); - return 0; + return fail; } @@ -376,10 +485,9 @@ krb5_os_localaddr(context, addr) return r; } + data.cur_idx++; /* null termination */ if (data.mem_err) return ENOMEM; - else if (data.cur_idx == 0) - abort (); else if (data.cur_idx == data.count) *addr = data.addr_temp; else { @@ -396,14 +504,13 @@ krb5_os_localaddr(context, addr) return 0; } -#else /* Windows/Mac version */ +#elif defined(_MSDOS) || defined(_WIN32) /* Windows version */ /* * Hold on to your lunch! Backup kludge method of obtaining your * local IP address, courtesy of Windows Socket Network Programming, * by Robert Quinn */ -#if defined(_MSDOS) || defined(_WIN32) static struct hostent *local_addr_fallback_kludge() { static struct hostent host; @@ -442,7 +549,6 @@ static struct hostent *local_addr_fallback_kludge() return &host; } -#endif /* No ioctls in winsock so we just assume there is only one networking * card per machine, so gethostent is good enough. @@ -473,6 +579,8 @@ krb5_os_localaddr (krb5_context context, krb5_address ***addr) { hostrec = local_addr_fallback_kludge(); if (!hostrec) return err; + else + err = 0; /* otherwise we will die at cleanup */ } for (count = 0; hostrec->h_addr_list[count]; count++); @@ -526,4 +634,79 @@ krb5_os_localaddr (krb5_context context, krb5_address ***addr) { return(err); } + +#else + +/* Mac OS 9 version */ +KRB5_DLLIMP krb5_error_code KRB5_CALLCONV +krb5_os_localaddr (krb5_context context, krb5_address ***addr) +{ + // First, build the new list + krb5_address ** addresses = NULL; + SInt32 interfaceCount; + SInt32 interfaceIndex; + InetInterfaceInfo info; + krb5_error_code err = 0; + + // Loop over the addressed once so we know how many there are + for (interfaceCount = 0; err == noErr; interfaceCount++) { + err = OTInetGetInterfaceInfo (&info, interfaceCount); + } + + // Allocate storage for the address list + addresses = (krb5_address **) malloc( sizeof (krb5_address *) * (interfaceCount + 1)); + if (addresses == NULL) { + err = ENOMEM; + goto cleanup; + } + + // Set the pointers to NULL so we will have a termination pointer + memset (addresses, 0, sizeof (krb5_address *) * (interfaceCount + 1)); + + // Look up the addresses and store them in the list + for (interfaceIndex = 0; interfaceIndex < interfaceCount; interfaceIndex++) { + err = OTInetGetInterfaceInfo (&info, interfaceIndex); + if (err != noErr) { + err = 0; + break; + } + + addresses[interfaceIndex] = (krb5_address *) malloc (sizeof (krb5_address)); + if (addresses[interfaceIndex] == NULL) { + err = ENOMEM; + goto cleanup; + } + + addresses[interfaceIndex]->magic = KV5M_ADDRESS; + addresses[interfaceIndex]->addrtype = AF_INET; + addresses[interfaceIndex]->length = INADDRSZ; + addresses[interfaceIndex]->contents = (unsigned char *) malloc (addresses[interfaceIndex]->length); + if (addresses[interfaceIndex]->contents == NULL) { + err = ENOMEM; + goto cleanup; + } + + memcpy(addresses[interfaceIndex]->contents, &info.fAddress, addresses[interfaceIndex]->length); + } + +cleanup: + if (err) { + if (addresses != NULL) { + for (interfaceIndex = 0; interfaceIndex < interfaceCount; interfaceIndex++) { + if (addresses[interfaceIndex] != NULL) { + if (addresses[interfaceIndex]->contents != NULL) { + free (addresses[interfaceIndex]->contents); + } + free (addresses[interfaceIndex]); + } + } + free(addresses); + } + } else { + *addr = addresses; + } + + return(err); + +} #endif |