d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
8135893765
freebsd-dev/crypto/heimdal/lib/roken/getifaddrs.c

1183 lines
30 KiB
C
Raw Blame History

/*
* Copyright (c) 2000 - 2002 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
RCSID("$Id: getifaddrs.c,v 1.9 2002/09/05 03:36:23 assar Exp $");
#endif
#include "roken.h"
#ifdef __osf__
/* hate */
struct rtentry;
struct mbuf;
#endif
#ifdef HAVE_NET_IF_H
#include <net/if.h>
#endif
#ifdef HAVE_SYS_SOCKIO_H
#include <sys/sockio.h>
#endif /* HAVE_SYS_SOCKIO_H */
#ifdef HAVE_NETINET_IN6_VAR_H
#include <netinet/in6_var.h>
#endif /* HAVE_NETINET_IN6_VAR_H */
#include <ifaddrs.h>
#ifdef AF_NETLINK
/*
* The linux - AF_NETLINK version of getifaddrs - from Usagi.
* Linux does not return v6 addresses from SIOCGIFCONF.
*/
/* $USAGI: ifaddrs.c,v 1.18 2002/03/06 01:50:46 yoshfuji Exp $ */
/**************************************************************************
* ifaddrs.c
* Copyright (C)2000 Hideaki YOSHIFUJI, All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the author nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "config.h"
#include <string.h>
#include <time.h>
#include <malloc.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <asm/types.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netpacket/packet.h>
#include <net/ethernet.h> /* the L2 protocols */
#include <sys/uio.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <ifaddrs.h>
#include <netinet/in.h>
#define __set_errno(e) (errno = (e))
#define __close(fd) (close(fd))
#undef ifa_broadaddr
#define ifa_broadaddr ifa_dstaddr
#define IFA_NETMASK
/* ====================================================================== */
struct nlmsg_list{
struct nlmsg_list *nlm_next;
struct nlmsghdr *nlh;
int size;
time_t seq;
};
struct rtmaddr_ifamap {
void *address;
void *local;
#ifdef IFA_NETMASK
void *netmask;
#endif
void *broadcast;
#ifdef HAVE_IFADDRS_IFA_ANYCAST
void *anycast;
#endif
int address_len;
int local_len;
#ifdef IFA_NETMASK
int netmask_len;
#endif
int broadcast_len;
#ifdef HAVE_IFADDRS_IFA_ANYCAST
int anycast_len;
#endif
};
/* ====================================================================== */
static size_t
ifa_sa_len(sa_family_t family, int len)
{
size_t size;
switch(family){
case AF_INET:
size = sizeof(struct sockaddr_in);
break;
case AF_INET6:
size = sizeof(struct sockaddr_in6);
break;
case AF_PACKET:
size = (size_t)(((struct sockaddr_ll *)NULL)->sll_addr) + len;
if (size < sizeof(struct sockaddr_ll))
size = sizeof(struct sockaddr_ll);
break;
default:
size = (size_t)(((struct sockaddr *)NULL)->sa_data) + len;
if (size < sizeof(struct sockaddr))
size = sizeof(struct sockaddr);
}
return size;
}
static void
ifa_make_sockaddr(sa_family_t family,
struct sockaddr *sa,
void *p, size_t len,
uint32_t scope, uint32_t scopeid)
{
if (sa == NULL) return;
switch(family){
case AF_INET:
memcpy(&((struct sockaddr_in*)sa)->sin_addr, (char *)p, len);
break;
case AF_INET6:
memcpy(&((struct sockaddr_in6*)sa)->sin6_addr, (char *)p, len);
if (IN6_IS_ADDR_LINKLOCAL(p) ||
IN6_IS_ADDR_MC_LINKLOCAL(p)){
((struct sockaddr_in6*)sa)->sin6_scope_id = scopeid;
}
break;
case AF_PACKET:
memcpy(((struct sockaddr_ll*)sa)->sll_addr, (char *)p, len);
((struct sockaddr_ll*)sa)->sll_halen = len;
break;
default:
memcpy(sa->sa_data, p, len); /*XXX*/
break;
}
sa->sa_family = family;
#ifdef HAVE_SOCKADDR_SA_LEN
sa->sa_len = ifa_sa_len(family, len);
#endif
}
#ifndef IFA_NETMASK
static struct sockaddr *
ifa_make_sockaddr_mask(sa_family_t family,
struct sockaddr *sa,
uint32_t prefixlen)
{
int i;
char *p = NULL, c;
uint32_t max_prefixlen = 0;
if (sa == NULL) return NULL;
switch(family){
case AF_INET:
memset(&((struct sockaddr_in*)sa)->sin_addr, 0, sizeof(((struct sockaddr_in*)sa)->sin_addr));
p = (char *)&((struct sockaddr_in*)sa)->sin_addr;
max_prefixlen = 32;
break;
case AF_INET6:
memset(&((struct sockaddr_in6*)sa)->sin6_addr, 0, sizeof(((struct sockaddr_in6*)sa)->sin6_addr));
p = (char *)&((struct sockaddr_in6*)sa)->sin6_addr;
#if 0 /* XXX: fill scope-id? */
if (IN6_IS_ADDR_LINKLOCAL(p) ||
IN6_IS_ADDR_MC_LINKLOCAL(p)){
((struct sockaddr_in6*)sa)->sin6_scope_id = scopeid;
}
#endif
max_prefixlen = 128;
break;
default:
return NULL;
}
sa->sa_family = family;
#ifdef HAVE_SOCKADDR_SA_LEN
sa->sa_len = ifa_sa_len(family, len);
#endif
if (p){
if (prefixlen > max_prefixlen)
prefixlen = max_prefixlen;
for (i=0; i<(prefixlen / 8); i++)
*p++ = 0xff;
c = 0xff;
c <<= (8 - (prefixlen % 8));
*p = c;
}
return sa;
}
#endif
/* ====================================================================== */
static int
nl_sendreq(int sd, int request, int flags, int *seq)
{
char reqbuf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
NLMSG_ALIGN(sizeof(struct rtgenmsg))];
struct sockaddr_nl nladdr;
struct nlmsghdr *req_hdr;
struct rtgenmsg *req_msg;
time_t t = time(NULL);
if (seq) *seq = t;
memset(&reqbuf, 0, sizeof(reqbuf));
req_hdr = (struct nlmsghdr *)reqbuf;
req_msg = (struct rtgenmsg *)NLMSG_DATA(req_hdr);
req_hdr->nlmsg_len = NLMSG_LENGTH(sizeof(*req_msg));
req_hdr->nlmsg_type = request;
req_hdr->nlmsg_flags = flags | NLM_F_REQUEST;
req_hdr->nlmsg_pid = 0;
req_hdr->nlmsg_seq = t;
req_msg->rtgen_family = AF_UNSPEC;
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
return (sendto(sd, (void *)req_hdr, req_hdr->nlmsg_len, 0,
(struct sockaddr *)&nladdr, sizeof(nladdr)));
}
static int
nl_recvmsg(int sd, int request, int seq,
void *buf, size_t buflen,
int *flags)
{
struct msghdr msg;
struct iovec iov = { buf, buflen };
struct sockaddr_nl nladdr;
int read_len;
for (;;){
msg.msg_name = (void *)&nladdr;
msg.msg_namelen = sizeof(nladdr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = 0;
read_len = recvmsg(sd, &msg, 0);
if ((read_len < 0 && errno == EINTR) || (msg.msg_flags & MSG_TRUNC))
continue;
if (flags) *flags = msg.msg_flags;
break;
}
return read_len;
}
static int
nl_getmsg(int sd, int request, int seq,
struct nlmsghdr **nlhp,
int *done)
{
struct nlmsghdr *nh;
size_t bufsize = 65536, lastbufsize = 0;
void *buff = NULL;
int result = 0, read_size;
int msg_flags;
pid_t pid = getpid();
for (;;){
void *newbuff = realloc(buff, bufsize);
if (newbuff == NULL || bufsize < lastbufsize) {
result = -1;
break;
}
buff = newbuff;
result = read_size = nl_recvmsg(sd, request, seq, buff, bufsize, &msg_flags);
if (read_size < 0 || (msg_flags & MSG_TRUNC)){
lastbufsize = bufsize;
bufsize *= 2;
continue;
}
if (read_size == 0) break;
nh = (struct nlmsghdr *)buff;
for (nh = (struct nlmsghdr *)buff;
NLMSG_OK(nh, read_size);
nh = (struct nlmsghdr *)NLMSG_NEXT(nh, read_size)){
if (nh->nlmsg_pid != pid ||
nh->nlmsg_seq != seq)
continue;
if (nh->nlmsg_type == NLMSG_DONE){
(*done)++;
break; /* ok */
}
if (nh->nlmsg_type == NLMSG_ERROR){
struct nlmsgerr *nlerr = (struct nlmsgerr *)NLMSG_DATA(nh);
result = -1;
if (nh->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
__set_errno(EIO);
else
__set_errno(-nlerr->error);
break;
}
}
break;
}
if (result < 0)
if (buff){
int saved_errno = errno;
free(buff);
__set_errno(saved_errno);
}
*nlhp = (struct nlmsghdr *)buff;
return result;
}
static int
nl_getlist(int sd, int seq,
int request,
struct nlmsg_list **nlm_list,
struct nlmsg_list **nlm_end)
{
struct nlmsghdr *nlh = NULL;
int status;
int done = 0;
status = nl_sendreq(sd, request, NLM_F_ROOT|NLM_F_MATCH, &seq);
if (status < 0)
return status;
if (seq == 0)
seq = (int)time(NULL);
while(!done){
status = nl_getmsg(sd, request, seq, &nlh, &done);
if (status < 0)
return status;
if (nlh){
struct nlmsg_list *nlm_next = (struct nlmsg_list *)malloc(sizeof(struct nlmsg_list));
if (nlm_next == NULL){
int saved_errno = errno;
free(nlh);
__set_errno(saved_errno);
status = -1;
} else {
nlm_next->nlm_next = NULL;
nlm_next->nlh = (struct nlmsghdr *)nlh;
nlm_next->size = status;
nlm_next->seq = seq;
if (*nlm_list == NULL){
*nlm_list = nlm_next;
*nlm_end = nlm_next;
} else {
(*nlm_end)->nlm_next = nlm_next;
*nlm_end = nlm_next;
}
}
}
}
return status >= 0 ? seq : status;
}
/* ---------------------------------------------------------------------- */
static void
free_nlmsglist(struct nlmsg_list *nlm0)
{
struct nlmsg_list *nlm;
int saved_errno;
if (!nlm0)
return;
saved_errno = errno;
for (nlm=nlm0; nlm; nlm=nlm->nlm_next){
if (nlm->nlh)
free(nlm->nlh);
}
free(nlm0);
__set_errno(saved_errno);
}
static void
free_data(void *data, void *ifdata)
{
int saved_errno = errno;
if (data != NULL) free(data);
if (ifdata != NULL) free(ifdata);
__set_errno(saved_errno);
}
/* ---------------------------------------------------------------------- */
static void
nl_close(int sd)
{
int saved_errno = errno;
if (sd >= 0) __close(sd);
__set_errno(saved_errno);
}
/* ---------------------------------------------------------------------- */
static int
nl_open(void)
{
struct sockaddr_nl nladdr;
int sd;
sd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sd < 0) return -1;
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
if (bind(sd, (struct sockaddr*)&nladdr, sizeof(nladdr)) < 0){
nl_close(sd);
return -1;
}
return sd;
}
/* ====================================================================== */
int getifaddrs(struct ifaddrs **ifap)
{
int sd;
struct nlmsg_list *nlmsg_list, *nlmsg_end, *nlm;
/* - - - - - - - - - - - - - - - */
int icnt;
size_t dlen, xlen, nlen;
uint32_t max_ifindex = 0;
pid_t pid = getpid();
int seq;
int result;
int build ; /* 0 or 1 */
/* ---------------------------------- */
/* initialize */
icnt = dlen = xlen = nlen = 0;
nlmsg_list = nlmsg_end = NULL;
if (ifap)
*ifap = NULL;
/* ---------------------------------- */
/* open socket and bind */
sd = nl_open();
if (sd < 0)
return -1;
/* ---------------------------------- */
/* gather info */
if ((seq = nl_getlist(sd, 0, RTM_GETLINK,
&nlmsg_list, &nlmsg_end)) < 0){
free_nlmsglist(nlmsg_list);
nl_close(sd);
return -1;
}
if ((seq = nl_getlist(sd, seq+1, RTM_GETADDR,
&nlmsg_list, &nlmsg_end)) < 0){
free_nlmsglist(nlmsg_list);
nl_close(sd);
return -1;
}
/* ---------------------------------- */
/* Estimate size of result buffer and fill it */
for (build=0; build<=1; build++){
struct ifaddrs *ifl = NULL, *ifa = NULL;
struct nlmsghdr *nlh, *nlh0;
char *data = NULL, *xdata = NULL;
void *ifdata = NULL;
char *ifname = NULL, **iflist = NULL;
uint16_t *ifflist = NULL;
struct rtmaddr_ifamap ifamap;
if (build){
data = calloc(1,
NLMSG_ALIGN(sizeof(struct ifaddrs[icnt]))
+ dlen + xlen + nlen);
ifa = (struct ifaddrs *)data;
ifdata = calloc(1,
NLMSG_ALIGN(sizeof(char *[max_ifindex+1]))
+ NLMSG_ALIGN(sizeof(uint16_t [max_ifindex+1])));
if (ifap != NULL)
*ifap = (ifdata != NULL) ? ifa : NULL;
else{
free_data(data, ifdata);
result = 0;
break;
}
if (data == NULL || ifdata == NULL){
free_data(data, ifdata);
result = -1;
break;
}
ifl = NULL;
data += NLMSG_ALIGN(sizeof(struct ifaddrs)) * icnt;
xdata = data + dlen;
ifname = xdata + xlen;
iflist = ifdata;
ifflist = (uint16_t *)(((char *)iflist) + NLMSG_ALIGN(sizeof(char *[max_ifindex+1])));
}
for (nlm=nlmsg_list; nlm; nlm=nlm->nlm_next){
int nlmlen = nlm->size;
if (!(nlh0 = nlm->nlh))
continue;
for (nlh = nlh0;
NLMSG_OK(nlh, nlmlen);
nlh=NLMSG_NEXT(nlh,nlmlen)){
struct ifinfomsg *ifim = NULL;
struct ifaddrmsg *ifam = NULL;
struct rtattr *rta;
size_t nlm_struct_size = 0;
sa_family_t nlm_family = 0;
uint32_t nlm_scope = 0, nlm_index = 0;
size_t sockaddr_size = 0;
uint32_t nlm_prefixlen = 0;
size_t rtasize;
memset(&ifamap, 0, sizeof(ifamap));
/* check if the message is what we want */
if (nlh->nlmsg_pid != pid ||
nlh->nlmsg_seq != nlm->seq)
continue;
if (nlh->nlmsg_type == NLMSG_DONE){
break; /* ok */
}
switch (nlh->nlmsg_type){
case RTM_NEWLINK:
ifim = (struct ifinfomsg *)NLMSG_DATA(nlh);
nlm_struct_size = sizeof(*ifim);
nlm_family = ifim->ifi_family;
nlm_scope = 0;
nlm_index = ifim->ifi_index;
nlm_prefixlen = 0;
if (build)
ifflist[nlm_index] = ifa->ifa_flags = ifim->ifi_flags;
break;
case RTM_NEWADDR:
ifam = (struct ifaddrmsg *)NLMSG_DATA(nlh);
nlm_struct_size = sizeof(*ifam);
nlm_family = ifam->ifa_family;
nlm_scope = ifam->ifa_scope;
nlm_index = ifam->ifa_index;
nlm_prefixlen = ifam->ifa_prefixlen;
if (build)
ifa->ifa_flags = ifflist[nlm_index];
break;
default:
continue;
}
if (!build){
if (max_ifindex < nlm_index)
max_ifindex = nlm_index;
} else {
if (ifl != NULL)
ifl->ifa_next = ifa;
}
rtasize = NLMSG_PAYLOAD(nlh, nlmlen) - NLMSG_ALIGN(nlm_struct_size);
for (rta = (struct rtattr *)(((char *)NLMSG_DATA(nlh)) + NLMSG_ALIGN(nlm_struct_size));
RTA_OK(rta, rtasize);
rta = RTA_NEXT(rta, rtasize)){
struct sockaddr **sap = NULL;
void *rtadata = RTA_DATA(rta);
size_t rtapayload = RTA_PAYLOAD(rta);
socklen_t sa_len;
switch(nlh->nlmsg_type){
case RTM_NEWLINK:
switch(rta->rta_type){
case IFLA_ADDRESS:
case IFLA_BROADCAST:
if (build){
sap = (rta->rta_type == IFLA_ADDRESS) ? &ifa->ifa_addr : &ifa->ifa_broadaddr;
*sap = (struct sockaddr *)data;
}
sa_len = ifa_sa_len(AF_PACKET, rtapayload);
if (rta->rta_type == IFLA_ADDRESS)
sockaddr_size = NLMSG_ALIGN(sa_len);
if (!build){
dlen += NLMSG_ALIGN(sa_len);
} else {
memset(*sap, 0, sa_len);
ifa_make_sockaddr(AF_PACKET, *sap, rtadata,rtapayload, 0,0);
((struct sockaddr_ll *)*sap)->sll_ifindex = nlm_index;
((struct sockaddr_ll *)*sap)->sll_hatype = ifim->ifi_type;
data += NLMSG_ALIGN(sa_len);
}
break;
case IFLA_IFNAME:/* Name of Interface */
if (!build)
nlen += NLMSG_ALIGN(rtapayload + 1);
else{
ifa->ifa_name = ifname;
if (iflist[nlm_index] == NULL)
iflist[nlm_index] = ifa->ifa_name;
strncpy(ifa->ifa_name, rtadata, rtapayload);
ifa->ifa_name[rtapayload] = '\0';
ifname += NLMSG_ALIGN(rtapayload + 1);
}
break;
case IFLA_STATS:/* Statistics of Interface */
if (!build)
xlen += NLMSG_ALIGN(rtapayload);
else{
ifa->ifa_data = xdata;
memcpy(ifa->ifa_data, rtadata, rtapayload);
xdata += NLMSG_ALIGN(rtapayload);
}
break;
case IFLA_UNSPEC:
break;
case IFLA_MTU:
break;
case IFLA_LINK:
break;
case IFLA_QDISC:
break;
default:
}
break;
case RTM_NEWADDR:
if (nlm_family == AF_PACKET) break;
switch(rta->rta_type){
case IFA_ADDRESS:
ifamap.address = rtadata;
ifamap.address_len = rtapayload;
break;
case IFA_LOCAL:
ifamap.local = rtadata;
ifamap.local_len = rtapayload;
break;
case IFA_BROADCAST:
ifamap.broadcast = rtadata;
ifamap.broadcast_len = rtapayload;
break;
#ifdef HAVE_IFADDRS_IFA_ANYCAST
case IFA_ANYCAST:
ifamap.anycast = rtadata;
ifamap.anycast_len = rtapayload;
break;
#endif
case IFA_LABEL:
if (!build)
nlen += NLMSG_ALIGN(rtapayload + 1);
else{
ifa->ifa_name = ifname;
if (iflist[nlm_index] == NULL)
iflist[nlm_index] = ifname;
strncpy(ifa->ifa_name, rtadata, rtapayload);
ifa->ifa_name[rtapayload] = '\0';
ifname += NLMSG_ALIGN(rtapayload + 1);
}
break;
case IFA_UNSPEC:
break;
case IFA_CACHEINFO:
break;
default:
}
}
}
if (nlh->nlmsg_type == RTM_NEWADDR &&
nlm_family != AF_PACKET) {
if (!ifamap.local) {
ifamap.local = ifamap.address;
ifamap.local_len = ifamap.address_len;
}
if (!ifamap.address) {
ifamap.address = ifamap.local;
ifamap.address_len = ifamap.local_len;
}
if (ifamap.address_len != ifamap.local_len ||
(ifamap.address != NULL &&
memcmp(ifamap.address, ifamap.local, ifamap.address_len))) {
/* p2p; address is peer and local is ours */
ifamap.broadcast = ifamap.address;
ifamap.broadcast_len = ifamap.address_len;
ifamap.address = ifamap.local;
ifamap.address_len = ifamap.local_len;
}
if (ifamap.address) {
#ifndef IFA_NETMASK
sockaddr_size = NLMSG_ALIGN(ifa_sa_len(nlm_family,ifamap.address_len));
#endif
if (!build)
dlen += NLMSG_ALIGN(ifa_sa_len(nlm_family,ifamap.address_len));
else {
ifa->ifa_addr = (struct sockaddr *)data;
ifa_make_sockaddr(nlm_family, ifa->ifa_addr, ifamap.address, ifamap.address_len,
nlm_scope, nlm_index);
data += NLMSG_ALIGN(ifa_sa_len(nlm_family, ifamap.address_len));
}
}
#ifdef IFA_NETMASK
if (ifamap.netmask) {
if (!build)
dlen += NLMSG_ALIGN(ifa_sa_len(nlm_family,ifamap.netmask_len));
else {
ifa->ifa_netmask = (struct sockaddr *)data;
ifa_make_sockaddr(nlm_family, ifa->ifa_netmask, ifamap.netmask, ifamap.netmask_len,
nlm_scope, nlm_index);
data += NLMSG_ALIGN(ifa_sa_len(nlm_family, ifamap.netmask_len));
}
}
#endif
if (ifamap.broadcast) {
if (!build)
dlen += NLMSG_ALIGN(ifa_sa_len(nlm_family,ifamap.broadcast_len));
else {
ifa->ifa_broadaddr = (struct sockaddr *)data;
ifa_make_sockaddr(nlm_family, ifa->ifa_broadaddr, ifamap.broadcast, ifamap.broadcast_len,
nlm_scope, nlm_index);
data += NLMSG_ALIGN(ifa_sa_len(nlm_family, ifamap.broadcast_len));
}
}
#ifdef HAVE_IFADDRS_IFA_ANYCAST
if (ifamap.anycast) {
if (!build)
dlen += NLMSG_ALIGN(ifa_sa_len(nlm_family,ifamap.anycast_len));
else {
ifa->ifa_anycast = (struct sockaddr *)data;
ifa_make_sockaddr(nlm_family, ifa->ifa_anyaddr, ifamap.anycast, ifamap.anycast_len,
nlm_scope, nlm_index);
data += NLMSG_ALIGN(ifa_sa_len(nlm_family, ifamap.anycast_len));
}
}
#endif
}
if (!build){
#ifndef IFA_NETMASK
dlen += sockaddr_size;
#endif
icnt++;
} else {
if (ifa->ifa_name == NULL)
ifa->ifa_name = iflist[nlm_index];
#ifndef IFA_NETMASK
if (ifa->ifa_addr &&
ifa->ifa_addr->sa_family != AF_UNSPEC &&
ifa->ifa_addr->sa_family != AF_PACKET){
ifa->ifa_netmask = (struct sockaddr *)data;
ifa_make_sockaddr_mask(ifa->ifa_addr->sa_family, ifa->ifa_netmask, nlm_prefixlen);
}
data += sockaddr_size;
#endif
ifl = ifa++;
}
}
}
if (!build){
if (icnt == 0 && (dlen + nlen + xlen == 0)){
if (ifap != NULL)
*ifap = NULL;
break; /* cannot found any addresses */
}
}
else
free_data(NULL, ifdata);
}
/* ---------------------------------- */
/* Finalize */
free_nlmsglist(nlmsg_list);
nl_close(sd);
return 0;
}
/* ---------------------------------------------------------------------- */
void
freeifaddrs(struct ifaddrs *ifa)
{
free(ifa);
}
#else /* !AF_NETLINK */
/*
* The generic SIOCGIFCONF version.
*/
static int
getifaddrs2(struct ifaddrs **ifap,
int af, int siocgifconf, int siocgifflags,
size_t ifreq_sz)
{
int ret;
int fd;
size_t buf_size;
char *buf;
struct ifconf ifconf;
char *p;
size_t sz;
struct sockaddr sa_zero;
struct ifreq *ifr;
struct ifaddrs *start = NULL, **end = &start;
buf = NULL;
memset (&sa_zero, 0, sizeof(sa_zero));
fd = socket(af, SOCK_DGRAM, 0);
if (fd < 0)
return -1;
buf_size = 8192;
for (;;) {
buf = calloc(1, buf_size);
if (buf == NULL) {
ret = ENOMEM;
goto error_out;
}
ifconf.ifc_len = buf_size;
ifconf.ifc_buf = buf;
/*
* Solaris returns EINVAL when the buffer is too small.
*/
if (ioctl (fd, siocgifconf, &ifconf) < 0 && errno != EINVAL) {
ret = errno;
goto error_out;
}
/*
* Can the difference between a full and a overfull buf
* be determined?
*/
if (ifconf.ifc_len < buf_size)
break;
free (buf);
buf_size *= 2;
}
for (p = ifconf.ifc_buf;
p < ifconf.ifc_buf + ifconf.ifc_len;
p += sz) {
struct ifreq ifreq;
struct sockaddr *sa;
size_t salen;
ifr = (struct ifreq *)p;
sa = &ifr->ifr_addr;
sz = ifreq_sz;
salen = sizeof(struct sockaddr);
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
salen = sa->sa_len;
sz = max(sz, sizeof(ifr->ifr_name) + sa->sa_len);
#endif
#ifdef SA_LEN
salen = SA_LEN(sa);
sz = max(sz, sizeof(ifr->ifr_name) + SA_LEN(sa));
#endif
memset (&ifreq, 0, sizeof(ifreq));
memcpy (ifreq.ifr_name, ifr->ifr_name, sizeof(ifr->ifr_name));
if (ioctl(fd, siocgifflags, &ifreq) < 0) {
ret = errno;
goto error_out;
}
*end = malloc(sizeof(**end));
if (*end == NULL) {
ret = ENOMEM;
goto error_out;
}
(*end)->ifa_next = NULL;
(*end)->ifa_name = strdup(ifr->ifr_name);
(*end)->ifa_flags = ifreq.ifr_flags;
(*end)->ifa_addr = malloc(salen);
memcpy((*end)->ifa_addr, sa, salen);
(*end)->ifa_netmask = NULL;
#if 0
/* fix these when we actually need them */
if(ifreq.ifr_flags & IFF_BROADCAST) {
(*end)->ifa_broadaddr = malloc(sizeof(ifr->ifr_broadaddr));
memcpy((*end)->ifa_broadaddr, &ifr->ifr_broadaddr,
sizeof(ifr->ifr_broadaddr));
} else if(ifreq.ifr_flags & IFF_POINTOPOINT) {
(*end)->ifa_dstaddr = malloc(sizeof(ifr->ifr_dstaddr));
memcpy((*end)->ifa_dstaddr, &ifr->ifr_dstaddr,
sizeof(ifr->ifr_dstaddr));
} else
(*end)->ifa_dstaddr = NULL;
#else
(*end)->ifa_dstaddr = NULL;
#endif
(*end)->ifa_data = NULL;
end = &(*end)->ifa_next;
}
*ifap = start;
close(fd);
free(buf);
return 0;
error_out:
freeifaddrs(start);
close(fd);
free(buf);
errno = ret;
return -1;
}
#if defined(HAVE_IPV6) && defined(SIOCGLIFCONF) && defined(SIOCGLIFFLAGS)
static int
getlifaddrs2(struct ifaddrs **ifap,
int af, int siocgifconf, int siocgifflags,
size_t ifreq_sz)
{
int ret;
int fd;
size_t buf_size;
char *buf;
struct lifconf ifconf;
char *p;
size_t sz;
struct sockaddr sa_zero;
struct lifreq *ifr;
struct ifaddrs *start = NULL, **end = &start;
buf = NULL;
memset (&sa_zero, 0, sizeof(sa_zero));
fd = socket(af, SOCK_DGRAM, 0);
if (fd < 0)
return -1;
buf_size = 8192;
for (;;) {
buf = calloc(1, buf_size);
if (buf == NULL) {
ret = ENOMEM;
goto error_out;
}
ifconf.lifc_family = AF_UNSPEC;
ifconf.lifc_flags = 0;
ifconf.lifc_len = buf_size;
ifconf.lifc_buf = buf;
/*
* Solaris returns EINVAL when the buffer is too small.
*/
if (ioctl (fd, siocgifconf, &ifconf) < 0 && errno != EINVAL) {
ret = errno;
goto error_out;
}
/*
* Can the difference between a full and a overfull buf
* be determined?
*/
if (ifconf.lifc_len < buf_size)
break;
free (buf);
buf_size *= 2;
}
for (p = ifconf.lifc_buf;
p < ifconf.lifc_buf + ifconf.lifc_len;
p += sz) {
struct lifreq ifreq;
struct sockaddr_storage *sa;
size_t salen;
ifr = (struct lifreq *)p;
sa = &ifr->lifr_addr;
sz = ifreq_sz;
salen = sizeof(struct sockaddr_storage);
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
salen = sa->sa_len;
sz = max(sz, sizeof(ifr->ifr_name) + sa->sa_len);
#endif
#ifdef SA_LEN
salen = SA_LEN(sa);
sz = max(sz, sizeof(ifr->ifr_name) + SA_LEN(sa));
#endif
memset (&ifreq, 0, sizeof(ifreq));
memcpy (ifreq.lifr_name, ifr->lifr_name, sizeof(ifr->lifr_name));
if (ioctl(fd, siocgifflags, &ifreq) < 0) {
ret = errno;
goto error_out;
}
*end = malloc(sizeof(**end));
(*end)->ifa_next = NULL;
(*end)->ifa_name = strdup(ifr->lifr_name);
(*end)->ifa_flags = ifreq.lifr_flags;
(*end)->ifa_addr = malloc(salen);
memcpy((*end)->ifa_addr, sa, salen);
(*end)->ifa_netmask = NULL;
#if 0
/* fix these when we actually need them */
if(ifreq.ifr_flags & IFF_BROADCAST) {
(*end)->ifa_broadaddr = malloc(sizeof(ifr->ifr_broadaddr));
memcpy((*end)->ifa_broadaddr, &ifr->ifr_broadaddr,
sizeof(ifr->ifr_broadaddr));
} else if(ifreq.ifr_flags & IFF_POINTOPOINT) {
(*end)->ifa_dstaddr = malloc(sizeof(ifr->ifr_dstaddr));
memcpy((*end)->ifa_dstaddr, &ifr->ifr_dstaddr,
sizeof(ifr->ifr_dstaddr));
} else
(*end)->ifa_dstaddr = NULL;
#else
(*end)->ifa_dstaddr = NULL;
#endif
(*end)->ifa_data = NULL;
end = &(*end)->ifa_next;
}
*ifap = start;
close(fd);
free(buf);
return 0;
error_out:
freeifaddrs(start);
close(fd);
free(buf);
errno = ret;
return -1;
}
#endif /* defined(HAVE_IPV6) && defined(SIOCGLIFCONF) && defined(SIOCGLIFFLAGS) */
int
getifaddrs(struct ifaddrs **ifap)
{
int ret = -1;
errno = ENXIO;
#if defined(AF_INET6) && defined(SIOCGIF6CONF) && defined(SIOCGIF6FLAGS)
if (ret)
ret = getifaddrs2 (ifap, AF_INET6, SIOCGIF6CONF, SIOCGIF6FLAGS,
sizeof(struct in6_ifreq));
#endif
#if defined(HAVE_IPV6) && defined(SIOCGLIFCONF) && defined(SIOCGLIFFLAGS)
if (ret)
ret = getlifaddrs2 (ifap, AF_INET6, SIOCGLIFCONF, SIOCGLIFFLAGS,
sizeof(struct lifreq));
#endif
#if defined(HAVE_IPV6) && defined(SIOCGIFCONF)
if (ret)
ret = getifaddrs2 (ifap, AF_INET6, SIOCGIFCONF, SIOCGIFFLAGS,
sizeof(struct ifreq));
#endif
#if defined(AF_INET) && defined(SIOCGIFCONF) && defined(SIOCGIFFLAGS)
if (ret)
ret = getifaddrs2 (ifap, AF_INET, SIOCGIFCONF, SIOCGIFFLAGS,
sizeof(struct ifreq));
#endif
return ret;
}
void
freeifaddrs(struct ifaddrs *ifp)
{
struct ifaddrs *p, *q;
for(p = ifp; p; ) {
free(p->ifa_name);
if(p->ifa_addr)
free(p->ifa_addr);
if(p->ifa_dstaddr)
free(p->ifa_dstaddr);
if(p->ifa_netmask)
free(p->ifa_netmask);
if(p->ifa_data)
free(p->ifa_data);
q = p;
p = p->ifa_next;
free(q);
}
}
#endif /* !AF_NETLINK */
#ifdef TEST
void
print_addr(const char *s, struct sockaddr *sa)
{
int i;
printf(" %s=%d/", s, sa->sa_family);
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
for(i = 0; i < sa->sa_len - ((long)sa->sa_data - (long)&sa->sa_family); i++)
printf("%02x", ((unsigned char*)sa->sa_data)[i]);
#else
for(i = 0; i < sizeof(sa->sa_data); i++)
printf("%02x", ((unsigned char*)sa->sa_data)[i]);
#endif
printf("\n");
}
void
print_ifaddrs(struct ifaddrs *x)
{
struct ifaddrs *p;
for(p = x; p; p = p->ifa_next) {
printf("%s\n", p->ifa_name);
printf(" flags=%x\n", p->ifa_flags);
if(p->ifa_addr)
print_addr("addr", p->ifa_addr);
if(p->ifa_dstaddr)
print_addr("dstaddr", p->ifa_dstaddr);
if(p->ifa_netmask)
print_addr("netmask", p->ifa_netmask);
printf(" %p\n", p->ifa_data);
}
}
int
main()
{
struct ifaddrs *a = NULL, *b;
getifaddrs2(&a, AF_INET, SIOCGIFCONF, SIOCGIFFLAGS, sizeof(struct ifreq));
print_ifaddrs(a);
printf("---\n");
getifaddrs(&b);
print_ifaddrs(b);
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink