From ce4c78512fccda58e75c4846ced1c3a4e10d7454 Mon Sep 17 00:00:00 2001 From: Raimo Niskanen Date: Thu, 14 Oct 2010 16:56:43 +0200 Subject: Implement inet:getifaddrs/0 on Windows --- erts/emulator/drivers/common/inet_drv.c | 686 ++++++++++++++++++++++++++++++-- 1 file changed, 653 insertions(+), 33 deletions(-) (limited to 'erts/emulator/drivers/common/inet_drv.c') diff --git a/erts/emulator/drivers/common/inet_drv.c b/erts/emulator/drivers/common/inet_drv.c index 4ee0e968d7..70439ba3f4 100644 --- a/erts/emulator/drivers/common/inet_drv.c +++ b/erts/emulator/drivers/common/inet_drv.c @@ -88,6 +88,7 @@ #include #endif #include +#include #include /* NEED VC 6.0 !!! */ @@ -3864,7 +3865,6 @@ static char* sockaddr_to_buf(struct sockaddr* addr, char* ptr, char* end) return ptr; error: return NULL; - } static char* buf_to_sockaddr(char* ptr, char* end, struct sockaddr* addr) @@ -3891,6 +3891,19 @@ static char* buf_to_sockaddr(char* ptr, char* end, struct sockaddr* addr) } +#if defined (IFF_POINTOPOINT) +#define IFGET_FLAGS(cflags) IFGET_FLAGS_P2P(cflags, IFF_POINTOPOINT) +#elif defined IFF_POINTTOPOINT +#define IFGET_FLAGS(cflags) IFGET_FLAGS_P2P(cflags, IFF_POINTTOPOINT) +#endif + +#define IFGET_FLAGS_P2P(cflags, iff_ptp) \ + ((((cflags) & IFF_UP) ? INET_IFF_UP : 0) | \ + (((cflags) & IFF_BROADCAST) ? INET_IFF_BROADCAST : 0) | \ + (((cflags) & IFF_LOOPBACK) ? INET_IFF_LOOPBACK : 0) | \ + (((cflags) & iff_ptp) ? INET_IFF_POINTTOPOINT : 0) | \ + (((cflags) & IFF_UP) ? INET_IFF_RUNNING : 0) | /* emulate running ? */ \ + (((cflags) & IFF_MULTICAST) ? INET_IFF_MULTICAST : 0)) #if defined(__WIN32__) && defined(SIO_GET_INTERFACE_LIST) @@ -4125,14 +4138,6 @@ static int inet_ctl_getiflist(inet_descriptor* desc, char** rbuf, int rsize) #define IFHWADDRLEN 6 #endif -#define IFGET_FLAGS(cflags) \ - ((((cflags) & IFF_UP) ? INET_IFF_UP : 0) | \ - (((cflags) & IFF_BROADCAST) ? INET_IFF_BROADCAST : 0) | \ - (((cflags) & IFF_LOOPBACK) ? INET_IFF_LOOPBACK : 0) | \ - (((cflags) & IFF_POINTOPOINT) ? INET_IFF_POINTTOPOINT : 0) | \ - (((cflags) & IFF_UP) ? INET_IFF_RUNNING : 0) | /* emulate running ? */ \ - (((cflags) & IFF_MULTICAST) ? INET_IFF_MULTICAST : 0)) - static int inet_ctl_ifget(inet_descriptor* desc, char* buf, int len, char** rbuf, int rsize) { @@ -4456,7 +4461,619 @@ static int inet_ctl_ifset(inet_descriptor* desc, char* buf, int len, -#if defined(HAVE_GETIFADDRS) +static int utf8_len(const char *c, int m) { + int l; + for (l = 0; m; c++, l++, m--) { + if (*c == '\0') break; + if ((*c & 0x7f) != *c) l++; + } + return l; +} + +static void utf8_encode(const char *c, int m, char *p) { + for (; m; c++, m--) { + if (*c == '\0') break; + if ((*c & 0x7f) != *c) { + *p++ = (char) (0xC0 | (0x03 & (*c >> 6))); + *p++ = (char) (0x80 | (0x3F & *c)); + } else { + *p++ = (char) *c; + } + } +} + +#if defined(__WIN32__) + +#if 0 +static void print_addr(char *f, char *g, char *h, char *b, int len) { + unsigned char *p = (unsigned char *)b; + for (; len > 0; len--, p++) { + erts_printf(len == 1 ? h : len & 1 ? g : f, *p); + } +} + +static void print_ipv4_address(char *b) { + print_addr("%d.","%d.","%d", b, 4); +} + +static void print_hwaddr(char *b, int len) { + print_addr("%02x:","%02x:","%02x", b, len); +} + +static void print_sockaddr(struct sockaddr *sa_p) { + if (sa_p->sa_family == AF_INET) { + struct sockaddr_in *sin_p = + (struct sockaddr_in *) sa_p; + print_ipv4_address((char *) &sin_p->sin_addr); + } else if(sa_p->sa_family == AF_INET6) { + struct sockaddr_in6 *sin6_p = + (struct sockaddr_in6 *) sa_p; + print_addr("%02x","%02x:","%02x", (char *) &sin6_p->sin6_addr, 16); + } +} + +static void print_flags(MIB_IFROW *ifrow_p) { + /* Interface flags */ + switch (ifrow_p->dwType) { + case IF_TYPE_ETHERNET_CSMACD: + /* Fake broadcast and multicast flag */ + erts_printf("broadcast multicast "); + break; + case IF_TYPE_SOFTWARE_LOOPBACK: + erts_printf("loopback "); + break; + } + if (ifrow_p->dwAdminStatus) { + erts_printf("up "); + switch (ifrow_p->dwOperStatus) { + case IF_OPER_STATUS_CONNECTING: + erts_printf("pointtopoint "); + break; + case IF_OPER_STATUS_CONNECTED: + erts_printf("running pointtopoint "); + break; + case IF_OPER_STATUS_OPERATIONAL: + erts_printf("running "); + break; + } + } +} +#endif + +static void set_netmask_bytes(char *c, int len, int pref_len) { + int i, m; + for (i = 0, m = pref_len >> 3; i < m && i < len; i++) c[i] = '\xFF'; + if (i < len) c[i++] = 0xFF << (8 - (pref_len & 7)); + for (; i < len; i++) c[i] = '\0'; +} + + +int eq_masked_bytes(char *a, char *b, int pref_len) { + int i, m; + for (i = 0, m = pref_len >> 3; i < m; i++) { + if (a[i] != b[i]) return 0; + } + m = pref_len & 7; + if (m) { + m = 0xFF & (0xFF << (8 - m)); + if ((a[i] & m) != (b[i] & m)) return 0; + } + return !0; +} + +#if 0 +static void set_netmask(struct sockaddr *sa_p, int pref_len) { + switch (sa_p->sa_family) { + case AF_INET: { + struct sockaddr_in *sin_p = (struct sockaddr_in *) sa_p; + set_netmask_bytes((char *) &sin_p->sin_addr, 4, pref_len); + break; + } + case AF_INET6: { + struct sockaddr_in6 *sin6_p = (struct sockaddr_in6 *) sa_p; + set_netmask_bytes((char *) &sin6_p->sin6_addr, 16, pref_len); + break; + } + } +} +#endif + +static int inet_ctl_getifaddrs(inet_descriptor* desc_p, + char **rbuf_pp, int rsize) +{ + int i; + DWORD ret, n; + IP_INTERFACE_INFO *info_p; + MIB_IPADDRTABLE *ip_addrs_p; + IP_ADAPTER_ADDRESSES *ip_adaddrs_p, *ia_p; + + char *buf_p; + char *buf_alloc_p; + int buf_size =512; +# define BUF_ENSURE(Size) \ + do { \ + int NEED_, GOT_ = buf_p - buf_alloc_p; \ + NEED_ = GOT_ + (Size); \ + if (NEED_ > buf_size) { \ + buf_size = NEED_ + 512; \ + buf_alloc_p = REALLOC(buf_alloc_p, buf_size); \ + buf_p = buf_alloc_p + GOT_; \ + } \ + } while(0) +# define SOCKADDR_TO_BUF(opt, sa) \ + do { \ + if (sa) { \ + char *P_; \ + *buf_p++ = (opt); \ + while (! (P_ = sockaddr_to_buf((sa), buf_p, \ + buf_alloc_p+buf_size))) { \ + int GOT_ = buf_p - buf_alloc_p; \ + buf_size += 512; \ + buf_alloc_p = REALLOC(buf_alloc_p, buf_size); \ + buf_p = buf_alloc_p + GOT_; \ + } \ + if (P_ == buf_p) { \ + buf_p--; \ + } else { \ + buf_p = P_; \ + } \ + } \ + } while (0) + + { + /* Try GetAdaptersAddresses, if it is available */ + unsigned long ip_adaddrs_size = 16 * 1024; + ULONG family = AF_UNSPEC; + ULONG flags = + GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_ANYCAST | + GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME | + GAA_FLAG_SKIP_MULTICAST; + ULONG (WINAPI *fpGetAdaptersAddresses) + (ULONG, ULONG, PVOID, PIP_ADAPTER_ADDRESSES, PULONG); + HMODULE iphlpapi = GetModuleHandle("iphlpapi"); + /*iphlpapi = NULL*/; + fpGetAdaptersAddresses = (void *) + (iphlpapi ? + GetProcAddress(iphlpapi, "GetAdaptersAddresses") : + NULL); + if (fpGetAdaptersAddresses) { + ip_adaddrs_p = ALLOC(ip_adaddrs_size); + for (i = 17; i; i--) { + ret = fpGetAdaptersAddresses( + family, flags, NULL, ip_adaddrs_p, &ip_adaddrs_size); + ip_adaddrs_p = REALLOC(ip_adaddrs_p, ip_adaddrs_size); + if (ret == NO_ERROR) break; + if (ret == ERROR_BUFFER_OVERFLOW) continue; + i = 0; + } + if (! i) { + FREE(ip_adaddrs_p); + ip_adaddrs_p = NULL; + } + } else ip_adaddrs_p = NULL; + } + + { + /* Load the IP_INTERFACE_INFO table (only IPv4 interfaces), + * reliable source of interface names on XP + */ + unsigned long info_size = 4 * 1024; + info_p = ALLOC(info_size); + for (i = 17; i; i--) { + ret = GetInterfaceInfo(info_p, &info_size); + info_p = REALLOC(info_p, info_size); + if (ret == NO_ERROR) break; + if (ret == ERROR_INSUFFICIENT_BUFFER) continue; + i = 0; + } + if (! i) { + FREE(info_p); + info_p = NULL; + } + } + + if (! ip_adaddrs_p) { + /* If GetAdaptersAddresses gave nothing we fall back to + * MIB_IPADDRTABLE (only IPv4 interfaces) + */ + unsigned long ip_addrs_size = 16 * sizeof(*ip_addrs_p); + ip_addrs_p = ALLOC(ip_addrs_size); + for (i = 17; i; i--) { + ret = GetIpAddrTable(ip_addrs_p, &ip_addrs_size, FALSE); + ip_addrs_p = REALLOC(ip_addrs_p, ip_addrs_size); + if (ret == NO_ERROR) break; + if (ret == ERROR_INSUFFICIENT_BUFFER) continue; + i = 0; + } + if (! i) { + if (info_p) FREE(info_p); + FREE(ip_addrs_p); + return ctl_reply(INET_REP_OK, NULL, 0, rbuf_pp, rsize); + } + } else ip_addrs_p = NULL; + +#if 0 + /* Debug printout of what GetAdaptersAddresses returned */ + if (ip_adaddrs_p) { + IP_ADAPTER_ADDRESSES *p = ip_adaddrs_p; + printf("* GetAdaptersAddresses:\n"); + for (; p; p = p->Next) { + IP_ADAPTER_UNICAST_ADDRESS *iaua_p; + IP_ADAPTER_ANYCAST_ADDRESS *iaaa_p; + IP_ADAPTER_PREFIX *iap_p; + MIB_IFROW ifrow; + erts_printf("AdapterName: %s\n", p->AdapterName); + if (p->Flags & IP_ADAPTER_NO_MULTICAST) { + erts_printf("AdapterFlags: -multicast\n"); + } + for (iaua_p = p->FirstUnicastAddress; + iaua_p; + iaua_p = iaua_p->Next) { + erts_printf("UnicastAddress: "); + print_sockaddr(iaua_p->Address.lpSockaddr); + erts_printf("\n"); + } + for (iaaa_p = p->FirstAnycastAddress; + iaaa_p; + iaaa_p = iaaa_p->Next) { + erts_printf("AnycastAddress: "); + print_sockaddr(iaaa_p->Address.lpSockaddr); + erts_printf("\n"); + } + for (iap_p = p->FirstPrefix; + iap_p; + iap_p = iap_p->Next) { + erts_printf("AddressPrefix: "); + print_sockaddr(iap_p->Address.lpSockaddr); + erts_printf("/%lu\n", iap_p->PrefixLength); + } + erts_printf("PhysicalAddress: "); + print_hwaddr(p->PhysicalAddress, p->PhysicalAddressLength); + erts_printf("\n"); + if (p->IfIndex) { + erts_printf( + "IPv4AdapterIndex: %lu\n", (unsigned long) p->IfIndex); + sys_memzero(&ifrow, sizeof(ifrow)); + ifrow.dwIndex = p->IfIndex; + if (GetIfEntry(&ifrow) == NO_ERROR) { + printf("InterfaceName: %ws\n", ifrow.wszName); + printf("InterfaceFlags: "); + print_flags(&ifrow); + erts_printf("\n"); + } + } + if (p->Ipv6IfIndex) { + erts_printf( + "IPv6AdapterIndex: %lu\n", (unsigned long) p->Ipv6IfIndex); + sys_memzero(&ifrow, sizeof(ifrow)); + ifrow.dwIndex = p->Ipv6IfIndex; + if (GetIfEntry(&ifrow) == NO_ERROR) { + printf("InterfaceName: %ws\n", ifrow.wszName); + printf("InterfaceFlags: "); + print_flags(&ifrow); + erts_printf("\n"); + } + } + } + } +#endif + +#if 0 + /* Debug printout of what GetInterfaceInfo returned */ + if (info_p) { + printf("* GetInterfaceInfo:\n"); + for (i = 0; i < info_p->NumAdapters; i++) { + printf("AdapterIndex[%d]: %ld\n", i, info_p->Adapter[i].Index); + printf("AdapterName[%d]: %lws\n", i, info_p->Adapter[i].Name); + } + } +#endif + + buf_p = buf_alloc_p = ALLOC(buf_size); + *buf_p++ = INET_REP_OK; + + /* Iterate over MIB_IPADDRTABLE or IP_ADAPTER_ADDRESSES */ + for (ia_p = NULL, ip_addrs_p ? ((void *)(i = 0)) : (ia_p = ip_adaddrs_p); + ip_addrs_p ? (i < ip_addrs_p->dwNumEntries) : (ia_p != NULL); + ip_addrs_p ? ((void *)(i++)) : (ia_p = ia_p->Next)) { + MIB_IPADDRROW *ipaddrrow_p = NULL; + DWORD flags = INET_IFF_MULTICAST; + DWORD index = 0; + WCHAR *wname_p = NULL; + MIB_IFROW ifrow; + + if (ip_addrs_p) { + ipaddrrow_p = ip_addrs_p->table + i; + index = ipaddrrow_p->dwIndex; + } else { + index = ia_p->IfIndex; + if (ia_p->Flags & IP_ADAPTER_NO_MULTICAST) { + flags &= ~INET_IFF_MULTICAST; + } + } +index: + if (! index) goto done; + sys_memzero(&ifrow, sizeof(ifrow)); + ifrow.dwIndex = index; + if (GetIfEntry(&ifrow) != NO_ERROR) break; +/* printf("Index[%d]: %ld\n", i, (long) ifrow.dwIndex);*/ + /* Find the interface name - first try MIB_IFROW.wzname */ + if (ifrow.wszName[0] != 0) { + wname_p = ifrow.wszName; + } else { + /* Then try IP_ADAPTER_INDEX_MAP.Name (only IPv4 adapters) */ + int j; + for (j = 0; j < info_p->NumAdapters; j++) { + if (info_p->Adapter[j].Index == (ULONG) ifrow.dwIndex) { + if (info_p->Adapter[j].Name[0] != 0) { + wname_p = info_p->Adapter[j].Name; + } + break; + } + } + } + if (wname_p) { + int len; +/* printf("InterfaceName [%d]: %ws\n", i, ifrow.wszName);*/ + /* Convert interface name to UTF-8 */ + len = + WideCharToMultiByte( + CP_UTF8, 0, wname_p, -1, NULL, 0, NULL, NULL); + if (! len) break; + BUF_ENSURE(len); + WideCharToMultiByte( + CP_UTF8, 0, wname_p, -1, buf_p, len, NULL, NULL); + buf_p += len; + } else { + /* Found no name - + * use "MIB_IFROW.dwIndex: MIB_IFROW.bDescr" as name instead */ + int l; + l = utf8_len(ifrow.bDescr, ifrow.dwDescrLen); +/* printf("Adapter Name[%d]: ", i);*/ + BUF_ENSURE(9 + l+1); + buf_p += + erts_sprintf( + buf_p, "%lu: ", (unsigned long) ifrow.dwIndex); + utf8_encode(ifrow.bDescr, ifrow.dwDescrLen, buf_p); + buf_p += l; + *buf_p++ = '\0'; + } + /* Interface flags, often make up broadcast and multicast flags */ + switch (ifrow.dwType) { + case IF_TYPE_ETHERNET_CSMACD: + flags |= INET_IFF_BROADCAST; + break; + case IF_TYPE_SOFTWARE_LOOPBACK: + flags |= INET_IFF_LOOPBACK; + flags &= ~INET_IFF_MULTICAST; + break; + default: + flags &= ~INET_IFF_MULTICAST; + break; + } + if (ifrow.dwAdminStatus) { + flags |= INET_IFF_UP; + switch (ifrow.dwOperStatus) { + case IF_OPER_STATUS_CONNECTING: + flags |= INET_IFF_POINTTOPOINT; + break; + case IF_OPER_STATUS_CONNECTED: + flags |= INET_IFF_RUNNING | INET_IFF_POINTTOPOINT; + break; + case IF_OPER_STATUS_OPERATIONAL: + flags |= INET_IFF_RUNNING; + break; + } + } + BUF_ENSURE(1 + 4); + *buf_p++ = INET_IFOPT_FLAGS; + put_int32(flags, buf_p); buf_p += 4; + if (ipaddrrow_p) { + /* Legacy implementation through GetIpAddrTable */ + struct sockaddr_in sin; + /* IP Address */ + sys_memzero(&sin, sizeof(sin)); + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = ipaddrrow_p->dwAddr; +/* erts_printf("IP Address: "); + * print_sockaddr((struct sockaddr *) &sin); + * erts_printf("\n");*/ + BUF_ENSURE(1); + /* Netmask */ + SOCKADDR_TO_BUF(INET_IFOPT_ADDR, (struct sockaddr *) &sin); + sin.sin_addr.s_addr = ipaddrrow_p->dwMask; +/* erts_printf("IP Mask: "); + * print_sockaddr((struct sockaddr *) &sin); + * erts_printf("\n");*/ + BUF_ENSURE(1); + SOCKADDR_TO_BUF(INET_IFOPT_NETMASK, (struct sockaddr *) &sin); + if (flags & INET_IFF_BROADCAST) { + /* Broadcast address - fake it*/ + sin.sin_addr.s_addr = ipaddrrow_p->dwAddr; + sin.sin_addr.s_addr |= ~ipaddrrow_p->dwMask; +/* erts_printf("IP Broadcast: "); + * print_sockaddr((struct sockaddr *) &sin); + * erts_printf("\n");*/ + BUF_ENSURE(1); + SOCKADDR_TO_BUF( + INET_IFOPT_BROADADDR, (struct sockaddr *) &sin); + } + } else { + IP_ADAPTER_UNICAST_ADDRESS *p; + /* IP Address(es) */ + for (p = ia_p->FirstUnicastAddress; + p; + p = p->Next) + { + IP_ADAPTER_PREFIX *q; + ULONG shortest_length; + struct sockaddr *shortest_p, *sa_p = p->Address.lpSockaddr; +/* erts_printf("UnicastAddress: "); + * print_sockaddr(sa_p); + * erts_printf("\n");*/ + BUF_ENSURE(1); + SOCKADDR_TO_BUF(INET_IFOPT_ADDR, sa_p); + shortest_p = NULL; + shortest_length = 0; + for (q = ia_p->FirstPrefix; + q; + q = q->Next) { + struct sockaddr *sp_p = q->Address.lpSockaddr; + if (sa_p->sa_family != sp_p->sa_family) continue; + switch (sa_p->sa_family) { + case AF_INET: { + struct sockaddr_in sin; + DWORD sa, sp, mask; + sa = ntohl((DWORD) + ((struct sockaddr_in *) + sa_p)->sin_addr.s_addr); + sp = ntohl((DWORD) + ((struct sockaddr_in *) + sp_p)->sin_addr.s_addr); + mask = 0xFFFFFFFF << (32 - q->PrefixLength); + if ((sa & mask) != (sp & mask)) continue; + if ((! shortest_p) + || q->PrefixLength < shortest_length) { + shortest_p = sp_p; + shortest_length = q->PrefixLength; + } + } break; + case AF_INET6: { + struct sockaddr_in6 sin6; + if (!eq_masked_bytes((char *) + &((struct sockaddr_in6 *) + sa_p)->sin6_addr, + (char *) + &((struct sockaddr_in6 *) + sp_p)->sin6_addr, + q->PrefixLength)) { + continue; + } + if ((! shortest_p) + || q->PrefixLength < shortest_length) { + shortest_p = sp_p; + shortest_length = q->PrefixLength; + } + } break; + } + } + if (! shortest_p) { + /* Found no shortest prefix */ + shortest_p = sa_p; + switch (shortest_p->sa_family) { + case AF_INET: { + /* Fall back to old classfull network addresses */ +/* erts_printf("! shortest_p: "); + * print_sockaddr(shortest_p); + * erts_printf("\n");*/ + DWORD addr = ntohl(((struct sockaddr_in *)shortest_p) + ->sin_addr.s_addr); + if (! (addr & 0x800000)) { + /* Class A */ + shortest_length = 8; + } else if (! (addr & 0x400000)) { + /* Class B */ + shortest_length = 16; + } else if (! (addr & 0x200000)) { + /* Class C */ + shortest_length = 24; + } else { + shortest_length = 32; + } + } break; + case AF_INET6: { + /* Just play it safe */ + shortest_length = 128; + } break; + } + } else { +/* erts_printf("shortest_p: "); + * print_sockaddr(shortest_p); + * erts_printf("\n");*/ + } + switch (shortest_p->sa_family) { + case AF_INET: { + struct sockaddr_in sin; + DWORD mask = 0xFFFFFFFF << (32 - shortest_length); + sys_memzero(&sin, sizeof(sin)); + sin.sin_family = shortest_p->sa_family; + sin.sin_addr.s_addr = htonl(mask); +/* erts_printf("IP Mask: "); + * print_sockaddr((struct sockaddr *) &sin); + * erts_printf("\n");*/ + BUF_ENSURE(1); + SOCKADDR_TO_BUF(INET_IFOPT_NETMASK, + (struct sockaddr *) &sin); + if (flags & INET_IFF_BROADCAST) { + DWORD sp = + ntohl((DWORD) + ((struct sockaddr_in *)shortest_p) + -> sin_addr.s_addr); + sin.sin_addr.s_addr = htonl(sp | ~mask); +/* erts_printf("IP Broadcast: "); + * print_sockaddr((struct sockaddr *) &sin); + * erts_printf("\n");*/ + BUF_ENSURE(1); + SOCKADDR_TO_BUF(INET_IFOPT_BROADADDR, + (struct sockaddr *) &sin); + } + } break; + case AF_INET6: { + struct sockaddr_in6 sin6; + sys_memzero(&sin6, sizeof(sin6)); + sin6.sin6_family = shortest_p->sa_family; + set_netmask_bytes((char *) &sin6.sin6_addr, + 16, + shortest_length); +/* erts_printf("IP Mask: "); + * print_sockaddr((struct sockaddr *) &sin6); + * erts_printf("\n");*/ + BUF_ENSURE(1); + SOCKADDR_TO_BUF(INET_IFOPT_NETMASK, + (struct sockaddr *) &sin6); + } break; + } + } + } + if (ifrow.dwPhysAddrLen) { + /* Hardware Address */ +/* printf("Physical Addr:"); + * print_hwaddr(ifrow.bPhysAddr, ifrow.dwPhysAddrLen); + * erts_printf("\n");*/ + BUF_ENSURE(1 + 2 + ifrow.dwPhysAddrLen); + *buf_p++ = INET_IFOPT_HWADDR; + put_int16(ifrow.dwPhysAddrLen, buf_p); buf_p += 2; + sys_memcpy(buf_p, ifrow.bPhysAddr, ifrow.dwPhysAddrLen); + buf_p += ifrow.dwPhysAddrLen; + } + +done: + /* That is all for this interface */ + BUF_ENSURE(1); + *buf_p++ = '\0'; + if (ia_p && + ia_p->Ipv6IfIndex && + ia_p->Ipv6IfIndex != index) + { + /* Oops, there was an other interface for IPv6. Possible? XXX */ + index = ia_p->Ipv6IfIndex; + goto index; + } + } + + if (ip_adaddrs_p) FREE(ip_adaddrs_p); + if (info_p) FREE(info_p); + if (ip_addrs_p) FREE(ip_addrs_p); + + buf_size = buf_p - buf_alloc_p; + buf_alloc_p = REALLOC(buf_alloc_p, buf_size); + /* buf_p is now unreliable */ + *rbuf_pp = buf_alloc_p; + return buf_size; +# undef BUF_ENSURE +} + +#elif defined(HAVE_GETIFADDRS) static int inet_ctl_getifaddrs(inet_descriptor* desc_p, char **rbuf_pp, int rsize) @@ -4470,31 +5087,32 @@ static int inet_ctl_getifaddrs(inet_descriptor* desc_p, buf_size = 512; buf_alloc_p = ALLOC(buf_size); buf_p = buf_alloc_p; -# define BUF_ENSURE(Size) \ - do { \ - int need, got = buf_p - buf_alloc_p; \ - need = got + (Size); \ - if (need > buf_size) { \ - buf_size = need + 512; \ - buf_alloc_p = REALLOC(buf_alloc_p, buf_size); \ - buf_p = buf_alloc_p + got; \ - } \ - } while(0) +# define BUF_ENSURE(Size) \ + do { \ + int NEED_, GOT_ = buf_p - buf_alloc_p; \ + NEED_ = GOT_ + (Size); \ + if (NEED_ > buf_size) { \ + buf_size = NEED_ + 512; \ + buf_alloc_p = REALLOC(buf_alloc_p, buf_size); \ + buf_p = buf_alloc_p + GOT_; \ + } \ + } while (0) # define SOCKADDR_TO_BUF(opt, sa) \ do { \ if (sa) { \ - char *p; \ + char *P_; \ *buf_p++ = (opt); \ - while (! (p = sockaddr_to_buf((sa), buf_p, \ - buf_alloc_p+buf_size))) { \ - int got = buf_p - buf_alloc_p; \ - buf_alloc_p = REALLOC(buf_alloc_p, buf_size+512); \ - buf_p = buf_alloc_p + got; \ + while (! (P_ = sockaddr_to_buf((sa), buf_p, \ + buf_alloc_p+buf_size))) { \ + int GOT_ = buf_p - buf_alloc_p; \ + buf_size += 512; \ + buf_alloc_p = REALLOC(buf_alloc_p, buf_size); \ + buf_p = buf_alloc_p + GOT_; \ } \ - if (p == buf_p) { \ + if (P_ == buf_p) { \ buf_p--; \ } else { \ - buf_p = p; \ + buf_p = P_; \ } \ } \ } while (0) @@ -4505,13 +5123,13 @@ static int inet_ctl_getifaddrs(inet_descriptor* desc_p, ifa_free_p = ifa_p; *buf_p++ = INET_REP_OK; for (; ifa_p; ifa_p = ifa_p->ifa_next) { - int len = strlen(ifa_p->ifa_name) + 1; - BUF_ENSURE(len + 1+4 + 1); - sys_memcpy(buf_p, ifa_p->ifa_name, len); + int len = utf8_len(ifa_p->ifa_name, -1); + BUF_ENSURE(len+1 + 1+4 + 1); + utf8_encode(ifa_p->ifa_name, -1, buf_p); buf_p += len; + *buf_p++ = '\0'; *buf_p++ = INET_IFOPT_FLAGS; - put_int32(IFGET_FLAGS(ifa_p->ifa_flags), buf_p); - buf_p += 4; + put_int32(IFGET_FLAGS(ifa_p->ifa_flags), buf_p); buf_p += 4; if (ifa_p->ifa_addr->sa_family == AF_INET #if defined(AF_INET6) || ifa_p->ifa_addr->sa_family == AF_INET6 @@ -4539,8 +5157,10 @@ static int inet_ctl_getifaddrs(inet_descriptor* desc_p, || ifa_p->ifa_addr->sa_family == AF_PACKET #endif ) { + char *bp = buf_p; BUF_ENSURE(1); SOCKADDR_TO_BUF(INET_IFOPT_HWADDR, ifa_p->ifa_addr); + if (buf_p - bp < 4) buf_p = bp; /* Empty hwaddr */ } #endif BUF_ENSURE(1); -- cgit v1.2.3