自学教程：C++ IFA_RTA函数代码示例

static void g_pn_nl_addr(GPhonetNetlink *self, struct nlmsghdr *nlh){	int len;	uint8_t local = 0xff;	uint8_t remote = 0xff;	const struct ifaddrmsg *ifa;	const struct rtattr *rta;	ifa = NLMSG_DATA(nlh);	len = IFA_PAYLOAD(nlh);	/* If Phonet is absent, kernel transmits other families... */	if (ifa->ifa_family != AF_PHONET)		return;	if (ifa->ifa_index != self->interface)		return;	for (rta = IFA_RTA(ifa); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {		if (rta->rta_type == IFA_LOCAL)			local = *(uint8_t *)RTA_DATA(rta);		else if (rta->rta_type == IFA_ADDRESS)			remote = *(uint8_t *)RTA_DATA(rta);	}}

void linux_unicast_router::handle_addr_event(bool isnew, nlmsghdr *hdr) {    ifaddrmsg *ifa = (ifaddrmsg *)NLMSG_DATA(hdr);    if (ifa->ifa_family == AF_INET6) {        rtattr *tb[IFA_MAX + 1];        memset(tb, 0, sizeof(tb));        netlink_msg::parse_rtatable(tb, IFA_MAX, IFA_RTA(ifa),                                    hdr->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));        rtattr *arta = tb[IFA_LOCAL];        if (!arta)            arta = tb[IFA_ADDRESS];        if (arta) {            inet6_addr addr;            memcpy(&addr.addr, RTA_DATA(arta), RTA_PAYLOAD(arta));            addr.prefixlen = ifa->ifa_prefixlen;            if (addr.type() & (inet6_addr::multicast | inet6_addr::network))                return;            if (addr.is_any())                return;            interface *intf = g_mrd->get_interface_by_index(ifa->ifa_index);            if (intf) {                intf->address_added_or_removed(isnew, addr);            }        }    }}

intTunnelIPv6Interface::process(void){	uint8_t buffer[1024];	ssize_t buffer_len(-1);	if (mNetlinkFD >= 0) {		buffer_len = recv(mNetlinkFD, buffer, sizeof(buffer), 0);	}	if (buffer_len > 0) {		struct nlmsghdr *nlp;		struct rtmsg *rtp;		int rta_len;		struct rtattr *rta;		nlp = (struct nlmsghdr *)buffer;		for (;NLMSG_OK(nlp, buffer_len); nlp=NLMSG_NEXT(nlp, buffer_len))		{			if (nlp->nlmsg_type == RTM_NEWADDR || nlp->nlmsg_type == RTM_DELADDR) {				struct ifaddrmsg *ifaddr = (struct ifaddrmsg *)NLMSG_DATA(nlp);				char ifnamebuf[IF_NAMESIZE];				const char *ifname = if_indextoname(ifaddr->ifa_index, ifnamebuf);				struct in6_addr addr;				if ((ifname == NULL) || (get_interface_name() != ifname)) {					continue;				}				// get RTNETLINK message header				// get start of attributes				rta = (struct rtattr *) IFA_RTA(ifaddr);				// get length of attributes				rta_len = IFA_PAYLOAD(nlp);				for(;RTA_OK(rta, rta_len); rta = RTA_NEXT(rta, rta_len)) {					switch(rta->rta_type) {					case IFA_ADDRESS:					case IFA_LOCAL:					case IFA_BROADCAST:					case IFA_ANYCAST:						memcpy(addr.s6_addr, RTA_DATA(rta), sizeof(addr));						if (nlp->nlmsg_type == RTM_NEWADDR) {							mAddressWasAdded(addr, ifaddr->ifa_prefixlen);						} else if (nlp->nlmsg_type == RTM_DELADDR) {							mAddressWasRemoved(addr, ifaddr->ifa_prefixlen);						}						break;					default:						break;					}				}			}		}	}	return nl::UnixSocket::process();}

static intparse_addr_rta(struct ifaddrmsg *addr, int len, struct in6_addr *res){    struct rtattr *rta;    len -= NLMSG_ALIGN(sizeof(*addr));    rta = IFA_RTA(addr);    while (RTA_OK(rta, len)) {        switch(rta->rta_type) {            case IFA_LOCAL:            case IFA_ADDRESS:                switch (addr->ifa_family) {                    case AF_INET:                        if (res)                            v4tov6(res->s6_addr, RTA_DATA(rta));                        break;                    case AF_INET6:                        if (res)                            memcpy(res->s6_addr, RTA_DATA(rta), 16);                        break;                    default:                        kdebugf("ifaddr: unexpected address family %d/n", addr->ifa_family);                        return -1;                        break;                }                break;            default:                break;        }        rta = RTA_NEXT(rta, len);    }    return 0;}

/* Add remote address */static int netlink_addroute(uint32_t ifa_index, uint8_t remote){	struct rtmsg *rtm;	struct rtattr *rta;	uint32_t reqlen = NLMSG_LENGTH(NLMSG_ALIGN(sizeof(*rtm)) +				RTA_SPACE(1) +				RTA_SPACE(sizeof(ifa_index)));	struct req {		struct nlmsghdr nlh;		char buf[512];	} req = {		.nlh = {			.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK					| NLM_F_CREATE | NLM_F_APPEND,			.nlmsg_type = RTM_NEWROUTE,			.nlmsg_pid = getpid(),			.nlmsg_len = reqlen,		},	};	size_t buflen = sizeof(req.buf) - sizeof(*rtm);	int fd;	int error;	struct sockaddr_nl addr = { .nl_family = AF_NETLINK, };	rtm = NLMSG_DATA(&req.nlh);	rtm->rtm_family = AF_PHONET;	rtm->rtm_dst_len = 6;	rtm->rtm_src_len = 0;	rtm->rtm_tos = 0;	rtm->rtm_table = RT_TABLE_MAIN;	rtm->rtm_protocol = RTPROT_STATIC;	rtm->rtm_scope = RT_SCOPE_UNIVERSE;	rtm->rtm_type = RTN_UNICAST;	rtm->rtm_flags = 0;	rta = IFA_RTA(rtm);	rta->rta_type = RTA_DST;	rta->rta_len = RTA_LENGTH(1);	*(uint8_t *)RTA_DATA(rta) = remote;	rta = RTA_NEXT(rta, buflen);	rta->rta_type = RTA_OIF;	rta->rta_len = RTA_LENGTH(sizeof(ifa_index));	*(uint32_t *)RTA_DATA(rta) = ifa_index;	fd = netlink_socket();	if (fd == -1)		return -errno;	if (sendto(fd, &req, reqlen, 0, (void *)&addr, sizeof(addr)) == -1)		error = -errno;	else		error = netlink_getack(fd);	close(fd);	return error;}

int addr_do(const struct in6_addr *addr, int plen, int ifindex, void *arg,	    int (*do_callback)(struct ifaddrmsg *ifa,			       struct rtattr *rta_tb[], void *arg)){	uint8_t sbuf[256];	uint8_t rbuf[256];	struct nlmsghdr *sn, *rn;	struct ifaddrmsg *ifa;	int err;	struct rtattr *rta_tb[IFA_MAX+1];	memset(sbuf, 0, sizeof(sbuf));	sn = (struct nlmsghdr *)sbuf;	sn->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));	sn->nlmsg_flags = NLM_F_REQUEST;	sn->nlmsg_type = RTM_GETADDR;	ifa = NLMSG_DATA(sn);	ifa->ifa_family = AF_INET6;	ifa->ifa_prefixlen = plen;	ifa->ifa_scope = RT_SCOPE_UNIVERSE;	ifa->ifa_index = ifindex;	addattr_l(sn, sizeof(sbuf), IFA_LOCAL, addr, sizeof(*addr));	memset(rbuf, 0, sizeof(rbuf));	rn = (struct nlmsghdr *)rbuf;	err = rtnl_route_do(sn, rn);	if (err < 0) {		rn = sn;		ifa = NLMSG_DATA(rn);	} else {		ifa = NLMSG_DATA(rn);		if (rn->nlmsg_type != RTM_NEWADDR ||		    rn->nlmsg_len < NLMSG_LENGTH(sizeof(*ifa)) ||		    ifa->ifa_family != AF_INET6) {			return -EINVAL;		}	}	memset(rta_tb, 0, sizeof(rta_tb));	parse_rtattr(rta_tb, IFA_MAX, IFA_RTA(ifa),		     rn->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));	if (!rta_tb[IFA_ADDRESS])		rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];	if (!rta_tb[IFA_ADDRESS] ||	    !IN6_ARE_ADDR_EQUAL(RTA_DATA(rta_tb[IFA_ADDRESS]), addr)) {		return -EINVAL;	}	if (do_callback)		err = do_callback(ifa, rta_tb, arg);	return err;}

static int read_iface_prefix(const char *ip_str, int is_ipv6){	uint8_t family = is_ipv6 ? AF_INET6 : AF_INET;	char buf[16384];	unsigned int len;	struct {		struct nlmsghdr nlhdr;		struct ifaddrmsg addrmsg;	} msg;	struct nlmsghdr *retmsg;	int sock = SAFE_SOCKET(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);	memset(&msg, 0, sizeof(msg));	msg.nlhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));	msg.nlhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;	msg.nlhdr.nlmsg_type = RTM_GETADDR;	msg.addrmsg.ifa_family = family;	SAFE_SEND(1, sock, &msg, msg.nlhdr.nlmsg_len, 0);	len = recv(sock, buf, sizeof(buf), 0);	retmsg = (struct nlmsghdr *)buf;	while NLMSG_OK(retmsg, len) {		char ifname[IFNAMSIZ];		struct ifaddrmsg *retaddr;		struct rtattr *retrta;		char pradd[128];		int attlen;		retaddr = (struct ifaddrmsg *)NLMSG_DATA(retmsg);		retrta = (struct rtattr *)IFA_RTA(retaddr);		attlen = IFA_PAYLOAD(retmsg);		while RTA_OK(retrta, attlen) {			if (retrta->rta_type == IFA_ADDRESS) {				inet_ntop(family, RTA_DATA(retrta), pradd,					  sizeof(pradd));				if_indextoname(retaddr->ifa_index, ifname);				if (!strcmp(pradd, ip_str)) {					prefix = retaddr->ifa_prefixlen;					iface = strdup(ifname);					return 0;				}			}			retrta = RTA_NEXT(retrta, attlen);		}		retmsg = NLMSG_NEXT(retmsg, len);	}	return -1;}

// Returns AF_MAX (with errno set) if error, AF_UNSPEC if no more addrs (socket closed)struct IPAddr nextAddr(struct AddrFilter const filter, struct MonitorState * const state){	// NLMSG_OK checks length first, so safe to call with state->nlh == NULL iff	// state->nlmsg_len < (int) sizeof(struct nlmsghdr)	if (NLMSG_OK(state->nlh, state->nlmsg_len) && (state->nlh->nlmsg_type != NLMSG_DONE)){		struct nlmsghdr * nlh = state->nlh;		state->nlh = NLMSG_NEXT(state->nlh, state->nlmsg_len);		switch(nlh->nlmsg_type){		case NLMSG_ERROR:			errno = -((struct nlmsgerr *) NLMSG_DATA(nlh))->error;			struct IPAddr addr = {.af = AF_MAX};			return addr;		case RTM_NEWADDR: {			struct ifaddrmsg * ifa = (struct ifaddrmsg *) NLMSG_DATA(nlh);			if (!filterIfAddrMsg(*ifa, filter))				return nextAddr(filter, state);			{			struct rtattr * rth;			size_t rtmsg_len;			for (rth = IFA_RTA(ifa), rtmsg_len = IFA_PAYLOAD(nlh);			     RTA_OK(rth, rtmsg_len); RTA_NEXT(rth, rtmsg_len)){				if (rth->rta_type != IFA_ADDRESS)					continue;				// family checked in filterIfAddrMsg, so always valid.				struct IPAddr addr = {.af = ifa->ifa_family};				switch (ifa->ifa_family) {				case AF_INET:					addr.ipv4 = *((struct in_addr *) RTA_DATA(rth));					break;				case AF_INET6:					addr.ipv6 = *((struct in6_addr *) RTA_DATA(rth));					break;				}				if (addrIsPrivate(addr) && !filter.allow_private)					return nextAddr(filter, state);				else					return addr;			}			}			// Recieved RTM_NEWADDR without any address.			errno = EBADMSG;			struct IPAddr addr = {.af = AF_MAX};			return addr;		}		default:			return nextAddr(filter, state);		}	} else {		state->nlmsg_len = nextMessage(filter, state->socket, &state->buf, &state->buf_len);		if (state->nlmsg_len == 0) {			// Socket closed by kernel			struct IPAddr addr = {.af = AF_UNSPEC};			return addr;		} else if (state->nlmsg_len < 0) {			// Socket error			struct IPAddr addr = {.af = AF_MAX};			return addr;		} else  {

boost::asio::ip::address_v6 get_ipv6_address(const nlmsghdr *in, const nlmsghdr *an){	boost::asio::ip::address_v6 unspec;	if (in->nlmsg_type != RTM_NEWLINK)		return unspec;	if (an->nlmsg_type != RTM_NEWADDR)		return unspec;	ifinfomsg* ifi = (ifinfomsg*)NLMSG_DATA(in);	ifaddrmsg* ifa = (ifaddrmsg*)NLMSG_DATA(an);	__u32 ilen = in->nlmsg_len;	if (ilen < NLMSG_LENGTH(sizeof(*ifi)))		return unspec;	ilen -= NLMSG_LENGTH(sizeof(*ifi));	__u32 alen = an->nlmsg_len;	if (alen < NLMSG_LENGTH(sizeof(*ifa)))		return unspec;	alen -= NLMSG_LENGTH(sizeof(*ifa));	/* NOTE: ifi_index and ifa_index should have the same type (int), but for	 * some reason they are not... So instead of a normal (in)equality comparison	 * we do a bit-wise compare.	 */	if (ifi->ifi_index ^ ifa->ifa_index)		return unspec;	if (ifi->ifi_family != AF_INET6 || ifa->ifa_family != AF_INET6)		return unspec;	rtattr* tbi[IFLA_MAX+1];	memset(tbi, 0, sizeof(tbi));	parse_rtattr(tbi, IFLA_MAX, IFLA_RTA(ifi), ilen);	if (tbi[IFLA_IFNAME] == NULL)		return unspec;	rtattr* tba[IFA_MAX+1];	memset(tba, 0, sizeof(tba));	parse_rtattr(tba, IFA_MAX, IFA_RTA(ifa), alen);	char abuf[256];	rt_addr_n2a(ifa->ifa_family,			RTA_PAYLOAD(tba[IFA_ADDRESS]),			RTA_DATA(tba[IFA_ADDRESS]),			abuf, sizeof(abuf));	std::string ipaddr = abuf;	try {		boost::asio::ip::address_v6 addr(boost::asio::ip::address_v6::from_string(ipaddr));		addr.scope_id(ifi->ifi_index);		return addr;	} catch(...) {		return unspec;	}}

/* * Netlink interface address lookup filter * We need to handle multiple primary address and * multiple secondary address to the same interface. */static intnetlink_if_address_filter(struct sockaddr_nl *snl, struct nlmsghdr *h){	struct ifaddrmsg *ifa;	struct rtattr *tb[IFA_MAX + 1];	interface_t *ifp;	int len;	void *addr;	ifa = NLMSG_DATA(h);	/* Only IPV4 are valid us */	if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6)		return 0;	if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)		return 0;	len = h->nlmsg_len - NLMSG_LENGTH(sizeof (struct ifaddrmsg));	if (len < 0)		return -1;	memset(tb, 0, sizeof (tb));	parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);	/* Fetch interface_t */	ifp = if_get_by_ifindex(ifa->ifa_index);	if (!ifp)		return 0;	if (tb[IFA_LOCAL] == NULL)		tb[IFA_LOCAL] = tb[IFA_ADDRESS];	if (tb[IFA_ADDRESS] == NULL)		tb[IFA_ADDRESS] = tb[IFA_LOCAL];	/* local interface address */	addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);	if (addr == NULL)		return -1;	/* If no address is set on interface then set the first time */	if (ifa->ifa_family == AF_INET) {		if (!ifp->sin_addr.s_addr)			ifp->sin_addr = *(struct in_addr *) addr;	} else {		if (!ifp->sin6_addr.s6_addr16[0] && ifa->ifa_scope == RT_SCOPE_LINK)			ifp->sin6_addr = *(struct in6_addr *) addr;	}#ifdef _WITH_LVS_	/* Refresh checkers state */	update_checker_activity(ifa->ifa_family, addr,				(h->nlmsg_type == RTM_NEWADDR) ? 1 : 0);#endif	return 0;}

static int handle_addr_msg(struct nlmsghdr *nlh, int n){	struct ifaddrmsg *ifa_msg = NLMSG_DATA(nlh);	struct rtattr *tb[IFA_MAX];	parse_rt_attrs(tb, IFA_MAX, IFA_RTA(ifa_msg), IFA_PAYLOAD(nlh));	handle_addr_attrs(ifa_msg, tb, nlh->nlmsg_type);	return 0;}

void process_nl_del_address (struct nlmsghdr *nlh){    struct ifaddrmsg    *ifa            = NULL;    struct rtattr       *rth            = NULL;    int                 iface_index     = 0;    int                 rt_length       = 0;    lispd_iface_elt     *iface          = NULL;    lisp_addr_t         new_addr;    char                iface_name[IF_NAMESIZE];    ifa = (struct ifaddrmsg *) NLMSG_DATA (nlh);    iface_index = ifa->ifa_index;    iface = get_interface_from_index(iface_index);    if (iface == NULL) {        if_indextoname(iface_index, iface_name);        lispd_log_msg(LISP_LOG_DEBUG_2, "process_nl_add_address: the netlink message is not for any interface associated with RLOCs (%s)",                      iface_name);        return;    }    rth = IFA_RTA (ifa);    rth = IFA_RTA (ifa);    rt_length = IFA_PAYLOAD (nlh);    for (; rt_length && RTA_OK (rth, rt_length); rth = RTA_NEXT (rth,rt_length))    {        if (rth->rta_type == IFA_ADDRESS) {            if (ifa->ifa_family == AF_INET) {                memcpy (&(new_addr.address),(struct in_addr *)RTA_DATA(rth),sizeof(struct in_addr));                new_addr.afi = AF_INET;            } else if (ifa->ifa_family == AF_INET6) {                memcpy (&(new_addr.address),(struct in6_addr *)RTA_DATA(rth),sizeof(struct in6_addr));                new_addr.afi = AF_INET6;            }            break;        }    }    /* Actions to be done when address is removed */    lispd_log_msg(LISP_LOG_DEBUG_2,"   deleted address: %s/n", get_char_from_lisp_addr_t(new_addr));}

intmain(){  struct sockaddr_nl addr;  int sock, len;  char buffer[4096];  struct nlmsghdr *nlh;  if ((sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1) {    perror("couldn't open NETLINK_ROUTE socket");    return 1;  }  fprintf(stderr,"socket: f%d/n",sock);  memset(&addr, 0, sizeof(addr));  addr.nl_family = AF_NETLINK;  addr.nl_groups = RTMGRP_IPV4_IFADDR;  if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {    perror("couldn't bind");    return 1;  }  fprintf(stderr,"bound/n");  nlh = (struct nlmsghdr *)buffer;  while ((len = recv(sock, nlh, 4096, 0)) > 0) {    fprintf(stderr,"recv returned %db (%d %s)/n",len,errno,strerror(errno));    while ((NLMSG_OK(nlh, len)) && (nlh->nlmsg_type != NLMSG_DONE)) {      if (nlh->nlmsg_type == RTM_NEWADDR) {	struct ifaddrmsg *ifa = (struct ifaddrmsg *) NLMSG_DATA(nlh);	struct rtattr *rth = IFA_RTA(ifa);	int rtl = IFA_PAYLOAD(nlh);	while (rtl && RTA_OK(rth, rtl)) {	  if (rth->rta_type == IFA_LOCAL) {	    uint32_t ipaddr = htonl(*((uint32_t *)RTA_DATA(rth)));	    char name[IFNAMSIZ];	    if_indextoname(ifa->ifa_index, name);	    printf("%s is now %d.%d.%d.%d/n",		   name,		   (ipaddr >> 24) & 0xff,		   (ipaddr >> 16) & 0xff,		   (ipaddr >> 8) & 0xff,		   ipaddr & 0xff);	  }	  rth = RTA_NEXT(rth, rtl);	}      }      nlh = NLMSG_NEXT(nlh, len);    }  }

static void easycwmp_netlink_interface(struct nlmsghdr *nlh){	struct ifaddrmsg *ifa = (struct ifaddrmsg *) NLMSG_DATA(nlh);	struct rtattr *rth = IFA_RTA(ifa);	int rtl = IFA_PAYLOAD(nlh);	char if_name[IFNAMSIZ], if_addr[INET_ADDRSTRLEN];	static old_addr=0;	memset(&if_name, 0, sizeof(if_name));	memset(&if_addr, 0, sizeof(if_addr));	while (rtl && RTA_OK(rth, rtl)) {		if (rth->rta_type != IFA_LOCAL) {			rth = RTA_NEXT(rth, rtl);			continue;		}		uint32_t addr = htonl(* (uint32_t *)RTA_DATA(rth));		if (htonl(13) == 13) {			// running on big endian system		} else {			// running on little endian system			addr = __bswap_32(addr);		}		if_indextoname(ifa->ifa_index, if_name);		if (strncmp(config->local->interface, if_name, IFNAMSIZ)) {			rth = RTA_NEXT(rth, rtl);			continue;		}		if ((addr != old_addr) && (old_addr != 0)) {			log_message(NAME, L_DEBUG, "ip address of the interface %s is changed/n",	if_name);			cwmp_add_event(EVENT_VALUE_CHANGE, NULL, 0, EVENT_NO_BACKUP);			cwmp_add_inform_timer();		}		old_addr = addr;		inet_ntop(AF_INET, &(addr), if_addr, INET_ADDRSTRLEN);		if (config->local) FREE(config->local->ip);		config->local->ip = strdup(if_addr);		break;	}	if (strlen(if_addr) == 0) return;	log_message(NAME, L_DEBUG, "interface %s has ip %s/n",			if_name, if_addr);}

/* ****************************************************************************** * dcs_local_ip_monitor_process                                           *//** * * /brief - Called by the polling thread that gets an indication that the local *          IP address has changed. The function sets the Local IP Address in  *          the dcs_local_ip variable * * /param[in] socket - The socket on which the information arrived * /param[in] context - NULL * * /retval DOVE_STATUS_OK * ****************************************************************************** */static int dcs_local_ip_monitor_process(int socket, void *context){	struct nlmsghdr *nlh;	char buf[4096];	int len;	dove_status status = DOVE_STATUS_OK;	while ((len = recv(dps_monitor_socket, buf, sizeof(buf), 0)) > 0)	{		nlh = (struct nlmsghdr *)buf;		while ((NLMSG_OK(nlh, (uint32_t)len)) && (nlh->nlmsg_type != NLMSG_DONE))		{			if (nlh->nlmsg_type == RTM_NEWADDR || nlh->nlmsg_type == RTM_DELADDR)			{				struct ifaddrmsg *ifa = (struct ifaddrmsg *)NLMSG_DATA(nlh);				struct rtattr *rth = IFA_RTA(ifa);				int rtl = IFA_PAYLOAD(nlh);				while (rtl && RTA_OK(rth, rtl))				{					if (rth->rta_type == IFA_LOCAL)					{						char ifname[IFNAMSIZ];						if_indextoname(ifa->ifa_index, ifname);						if (!strcmp(ifname, SVA_INTERFACE_NAME) && (nlh->nlmsg_type == RTM_NEWADDR))						{							status = set_local_ip();							if (status != DOVE_STATUS_OK)							{								log_warn(PythonDataHandlerLogLevel,								         "Cannot get IP Address of SVA");								break;							}							// Register the Local DPS Node with the Cluster							dcs_set_service_role(dcs_role_assigned);						}					}					rth = RTA_NEXT(rth, rtl);				}			}			nlh = NLMSG_NEXT(nlh, len);		}	}	return DOVE_STATUS_OK;}

/* return true if there is a known address with 'tentative' flag set */static boolvirNetDevIPParseDadStatus(struct nlmsghdr *nlh, int len,                          virSocketAddrPtr *addrs, size_t count){    struct ifaddrmsg *ifaddrmsg_ptr;    unsigned int ifaddrmsg_len;    struct rtattr *rtattr_ptr;    size_t i;    struct in6_addr *addr;    VIR_WARNINGS_NO_CAST_ALIGN    for (; NLMSG_OK(nlh, len); nlh = NLMSG_NEXT(nlh, len)) {        VIR_WARNINGS_RESET        if (NLMSG_PAYLOAD(nlh, 0) < sizeof(struct ifaddrmsg)) {            /* Message without payload is the last one. */            break;        }        ifaddrmsg_ptr = (struct ifaddrmsg *)NLMSG_DATA(nlh);        if (!(ifaddrmsg_ptr->ifa_flags & IFA_F_TENTATIVE)) {            /* Not tentative: we are not interested in this entry. */            continue;        }        ifaddrmsg_len = IFA_PAYLOAD(nlh);        VIR_WARNINGS_NO_CAST_ALIGN        rtattr_ptr = (struct rtattr *) IFA_RTA(ifaddrmsg_ptr);        for (; RTA_OK(rtattr_ptr, ifaddrmsg_len);            rtattr_ptr = RTA_NEXT(rtattr_ptr, ifaddrmsg_len)) {            VIR_WARNINGS_RESET            if (RTA_PAYLOAD(rtattr_ptr) != sizeof(struct in6_addr)) {                /* No address: ignore. */                continue;            }            /* We check only known addresses. */            for (i = 0; i < count; i++) {                addr = &addrs[i]->data.inet6.sin6_addr;                if (!memcmp(addr, RTA_DATA(rtattr_ptr),                            sizeof(struct in6_addr))) {                    /* We found matching tentative address. */                    return true;                }            }        }    }    return false;}

static int parse_v4_addr_msg(orc_options_t * options, struct nlmsghdr * nl_msg,        u32 * ipv4_addr, int * if_index, char ifnam[IFNAMSIZ]){    struct ifaddrmsg * ifaddr_msg;    struct rtattr * attr;    int rtattr_len;    int found_addr = 0;    int found_ifnam = 0;    ifaddr_msg = (struct ifaddrmsg *) NLMSG_DATA(nl_msg);    /* extract the first attribute */    attr = (struct rtattr *) IFA_RTA(ifaddr_msg);    rtattr_len = IFA_PAYLOAD(nl_msg);    *if_index = ifaddr_msg->ifa_index;    if (ifaddr_msg->ifa_family == AF_INET6)    {        /* TODO: add IPv6 support */        orc_debug("Ignoring new IPv6 address: IPv6 unsupported/n");        return 0;    }    /** note: the RTA_NEXT() macro decrements rtattr_len each time */    for(; RTA_OK(attr, rtattr_len); attr = RTA_NEXT(attr, rtattr_len))    {        switch (attr->rta_type)        {            case IFA_ADDRESS:                memcpy(ipv4_addr, RTA_DATA(attr), sizeof(*ipv4_addr));                found_addr = 1;     /* probably always there, but... */                break;            case IFA_LABEL:                snprintf(ifnam, IFNAMSIZ, "%s", (char *) RTA_DATA(attr));                found_ifnam = 1;                break;            case IFA_LOCAL:            case IFA_BROADCAST:                orc_trace("Intentionally ignoring address update %s - not needed/n",                    attr->rta_type == IFA_LOCAL? "IFA_LOCAL" : "IFA_BROADCAST");                break;            default:                orc_warn("Skipping unhandled ipv4 address attr: %d/n", attr->rta_type);        }    }    return found_addr && found_ifnam;}

static int fill_if_addr(struct if_entry *dest, struct nlmsg_entry *ainfo){    struct if_addr *entry;    struct nlmsghdr *n;    struct ifaddrmsg *ifa;    struct rtattr *rta_tb[IFA_MAX + 1];    int len, err;    for (; ainfo; ainfo = ainfo->next) {        n = &ainfo->h;        ifa = NLMSG_DATA(n);        if (ifa->ifa_index != dest->if_index)            continue;        if (n->nlmsg_type != RTM_NEWADDR)            continue;        len = n->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa));        if (len < 0)            continue;        if (ifa->ifa_family != AF_INET &&                ifa->ifa_family != AF_INET6)            /* only IP addresses supported (at least for now) */            continue;        rtnl_parse(rta_tb, IFA_MAX, IFA_RTA(ifa), len);        if (!rta_tb[IFA_LOCAL] && !rta_tb[IFA_ADDRESS])            /* don't care about broadcast and anycast adresses */            continue;        entry = calloc(sizeof(struct if_addr), 1);        if (!entry)            return ENOMEM;        if (!rta_tb[IFA_LOCAL]) {            rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];            rta_tb[IFA_ADDRESS] = NULL;        }        if ((err = addr_init_netlink(&entry->addr, ifa, rta_tb[IFA_LOCAL])))            return err;        if (rta_tb[IFA_ADDRESS] &&                memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_LOCAL]),                       ifa->ifa_family == AF_INET ? 4 : 16)) {            if ((err = addr_init_netlink(&entry->peer, ifa, rta_tb[IFA_ADDRESS])))                return err;        }        list_append(&dest->addr, node(entry));    }    return 0;}

int main(int argc, const char *argv[]){ struct sockaddr_nl addr; int nls,len,rtl; char buffer[4096]; struct nlmsghdr *nlh; struct ifaddrmsg *ifa; struct rtattr *rth; if ((nls = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1)   perror ("socket failure/n"); memset (&addr,0,sizeof(addr)); addr.nl_family = AF_NETLINK; //addr.nl_groups = RTMGRP_IPV4_IFADDR; addr.nl_groups = RTNLGRP_IPV4_IFADDR; if (bind(nls, (struct sockaddr *)&addr, sizeof(addr)) == -1)    perror ("bind failure/n"); nlh = (struct nlmsghdr *)buffer; while ((len = recv (nls,nlh,4096,0)) > 0) {     for (;(NLMSG_OK (nlh, len)) && (nlh->nlmsg_type != NLMSG_DONE); nlh = NLMSG_NEXT(nlh, len))     {         if (nlh->nlmsg_type != RTM_NEWADDR) {printf("/nsomething..../n");continue; }/* some other kind of announcement */         ifa = (struct ifaddrmsg *) NLMSG_DATA (nlh);         rth = IFA_RTA (ifa);         rtl = IFA_PAYLOAD (nlh);         for (;rtl && RTA_OK (rth, rtl); rth = RTA_NEXT (rth,rtl))         {             char name[IFNAMSIZ];             uint32_t ipaddr;             if (rth->rta_type != IFA_LOCAL) continue;             ipaddr = * ((uint32_t *)RTA_DATA(rth));             ipaddr = htonl(ipaddr);             fprintf (stdout,"%s is now %X/n",if_indextoname(ifa->ifa_index,name),ipaddr);         }     } }}

int TunManager::getAddrRespParser(const struct sockaddr_nl *who,                                  struct nlmsghdr *n,                                  void *arg) {  // only cares about RTM_NEWADDR  if (n->nlmsg_type != RTM_NEWADDR) {    return 0;  }  struct ifaddrmsg *ifa = static_cast<struct ifaddrmsg *>(NLMSG_DATA(n));  struct rtattr *tb[IFA_MAX + 1];  int len = n->nlmsg_len;  len -= NLMSG_LENGTH(sizeof(*ifa));  if (len < 0) {    throw FbossError("Wrong length for RTM_GETADDR response ", len, " vs ",                     NLMSG_LENGTH(sizeof(*ifa)));  }  // only care about v4 and v6 address  if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6) {    VLOG(3) << "Skip address from device @ index "            << static_cast<int>(ifa->ifa_index)            << " because of its address family "            << static_cast<int>(ifa->ifa_family);    return 0;  }  parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);  if (tb[IFA_ADDRESS] == nullptr) {    VLOG(3) << "Device @ index " << static_cast<int>(ifa->ifa_index)            << " does not have address at family "            << static_cast<int>(ifa->ifa_family);    return 0;  }  IPAddress addr;  const void *data = RTA_DATA(tb[IFA_ADDRESS]);  if (ifa->ifa_family == AF_INET) {    addr = IPAddress(*static_cast<const in_addr *>(data));  } else {    addr = IPAddress(*static_cast<const in6_addr *>(data));  }  TunManager *mgr = static_cast<TunManager *>(arg);  mgr->addProbedAddr(ifa->ifa_index, addr, ifa->ifa_prefixlen);  return 0;}

void process_nl_add_address (struct nlmsghdr *nlh){    struct ifaddrmsg            *ifa                = NULL;    struct rtattr               *rth                = NULL;    int                         iface_index         = 0;    int                         rt_length           = 0;    lispd_iface_elt             *iface              = NULL;    lisp_addr_t                 new_addr;    char                        iface_name[IF_NAMESIZE];    /*     * Get the new address from the net link message     */    ifa = (struct ifaddrmsg *) NLMSG_DATA (nlh);    iface_index = ifa->ifa_index;    iface = get_interface_from_index(iface_index);    if (iface == NULL){        if_indextoname(iface_index, iface_name);        lispd_log_msg(LISP_LOG_DEBUG_2, "process_nl_add_address: the netlink message is not for any interface associated with RLOCs  (%s / %d)",                iface_name, iface_index);        return;    }    rth = IFA_RTA (ifa);    rt_length = IFA_PAYLOAD (nlh);    for (;rt_length && RTA_OK (rth, rt_length); rth = RTA_NEXT (rth,rt_length))    {    	if (ifa->ifa_family == AF_INET && rth->rta_type == IFA_LOCAL){    		memcpy (&(new_addr.address),(struct in_addr *)RTA_DATA(rth),sizeof(struct in_addr));    		new_addr.afi = AF_INET;    		process_address_change (iface, new_addr);    	}    	if (ifa->ifa_family == AF_INET6 && rth->rta_type == IFA_ADDRESS){    		memcpy (&(new_addr.address),(struct in6_addr *)RTA_DATA(rth),sizeof(struct in6_addr));    		new_addr.afi = AF_INET6;    		process_address_change (iface, new_addr);    	}    }}

static int rtnl_ifaddr_get(struct nlmsghdr *h, 			   int (*if_callback)(int, struct in_ifaddr *)){	struct rtattr *tb[IFA_MAX + 1];	struct ifaddrmsg *ifaddr;	int len;		struct in_ifaddr in_ifaddr;		if (h->nlmsg_type != RTM_NEWADDR)		return 0;		ifaddr = NLMSG_DATA(h);		len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));	if (len < 0)		return -1;	netlink_parse_rtattr(tb, IFA_MAX, IFA_RTA(ifaddr), len);		strcpy(in_ifaddr.ifa_label, (char *)RTA_DATA(tb[IFA_LABEL]));		in_ifaddr.ifa_address	= *(uint32_t *)RTA_DATA(tb[IFA_ADDRESS]);	in_ifaddr.ifa_local	= *(uint32_t *)RTA_DATA(tb[IFA_LOCAL]);		if (tb[IFA_BROADCAST]) 		in_ifaddr.ifa_broadcast	= *(uint32_t *)RTA_DATA(tb[IFA_BROADCAST]);		if (tb[IFA_ANYCAST])		in_ifaddr.ifa_anycast = *(uint32_t *)RTA_DATA(tb[IFA_ANYCAST]);	in_ifaddr.ifa_family	= ifaddr->ifa_family;	in_ifaddr.ifa_prefixlen = ifaddr->ifa_prefixlen;		in_ifaddr.ifa_flags 	= ifaddr->ifa_flags;	in_ifaddr.ifa_scope	= ifaddr->ifa_scope;		return if_callback(ifaddr->ifa_index, &in_ifaddr);}

/**************************************************************** NAME	: print_addr				00/06/02 18:24:09 AIM	:  REMARK	:****************************************************************/static int get_addrinfo(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg){	struct ifaddrmsg *ifa 	= NLMSG_DATA(n);	int		len	= n->nlmsg_len;	iplist_ctx	*ctx	= (iplist_ctx *)arg;	struct rtattr 	*rta_tb[IFA_MAX+1];	/* sanity check */	len -= NLMSG_LENGTH(sizeof(*ifa));	if (len < 0) {		fprintf(stderr, "BUG: wrong nlmsg len %d/n", len);		return -1;	}	/* check the message type */	if (n->nlmsg_type != RTM_NEWADDR )		return 0;	/* check it is ipv4 */	if( ifa->ifa_family != AF_INET)		return 0;	/* check it is the good interface */	if( ifa->ifa_index != ctx->ifindex )		return 0;			/* parse the attribute */	memset(rta_tb, 0, sizeof(rta_tb));	parse_rtattr(rta_tb, IFA_MAX, IFA_RTA(ifa), len);	if (!rta_tb[IFA_LOCAL])		rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];	if (rta_tb[IFA_LOCAL]) {		u_char *src = RTA_DATA(rta_tb[IFA_LOCAL]);		if( ctx->nb_elem >= ctx->max_elem )			return 0;		ctx->addr[ctx->nb_elem++] = 	(src[0]<<24) + (src[1]<<16) +						(src[2]<<8) + src[3];	}	return 0;}

/* function: getaddr_cb * callback for getinterface_ip * msg  - netlink message * data - (struct target) info for which address we're looking for */static int getaddr_cb(struct nl_msg *msg, void *data) {  struct ifaddrmsg *ifa_p;  struct rtattr *rta_p;  int rta_len;  struct target *targ_p = (struct target *)data;  ifa_p = (struct ifaddrmsg *)nlmsg_data(nlmsg_hdr(msg));  rta_p = (struct rtattr *)IFA_RTA(ifa_p);  if(ifa_p->ifa_index != targ_p->ifindex)    return NL_OK;  if(ifa_p->ifa_scope != RT_SCOPE_UNIVERSE)    return NL_OK;  rta_len = RTM_PAYLOAD(nlmsg_hdr(msg));  for (; RTA_OK(rta_p, rta_len); rta_p = RTA_NEXT(rta_p, rta_len)) {    switch(rta_p->rta_type) {      case IFA_ADDRESS:        if((targ_p->family == AF_INET6) && !(ifa_p->ifa_flags & IFA_F_SECONDARY)) {          memcpy(&targ_p->ip.ip6, RTA_DATA(rta_p), rta_p->rta_len - sizeof(struct rtattr));          targ_p->foundip = 1;          return NL_OK;        }        break;      case IFA_LOCAL:        if(targ_p->family == AF_INET) {          memcpy(&targ_p->ip.ip4, RTA_DATA(rta_p), rta_p->rta_len - sizeof(struct rtattr));          targ_p->foundip = 1;          return NL_OK;        }        break;    }  }  return NL_OK;}

    void dispatch_ifaddr_v6(Tag, struct ifaddrmsg * ifa, std::size_t len)    {        acqua::network::internet6_address addr;        std::string label;        uint prefixlen = ifa->ifa_prefixlen;        uint flags = ifa->ifa_flags;#pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wcast-align"        for(auto * rta = IFA_RTA(ifa); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {            switch(rta->rta_type) {                case IFA_ADDRESS:                    addr = addr.from_voidptr(RTA_DATA(rta));                    break;                case IFA_LABEL:                    label = static_cast<char const *>(RTA_DATA(rta));                    break;            }        }#pragma GCC diagnostic pop        static_cast<Derived *>(this)->on_ifaddr(addr, label, prefixlen, flags);    }

int print_addrinfo(const struct sockaddr_nl *who, struct nlmsghdr *n,		   void *arg){	FILE *fp = arg;	struct ifaddrmsg *ifa = NLMSG_DATA(n);	int len = n->nlmsg_len;	int deprecated = 0;	/* Use local copy of ifa_flags to not interfere with filtering code */	unsigned int ifa_flags;	struct rtattr * rta_tb[IFA_MAX+1];	char abuf[256];	SPRINT_BUF(b1);	if (n->nlmsg_type != RTM_NEWADDR && n->nlmsg_type != RTM_DELADDR)		return 0;	len -= NLMSG_LENGTH(sizeof(*ifa));	if (len < 0) {		fprintf(stderr, "BUG: wrong nlmsg len %d/n", len);		return -1;	}	if (filter.flushb && n->nlmsg_type != RTM_NEWADDR)		return 0;	parse_rtattr(rta_tb, IFA_MAX, IFA_RTA(ifa),		     n->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));	ifa_flags = get_ifa_flags(ifa, rta_tb[IFA_FLAGS]);	if (!rta_tb[IFA_LOCAL])		rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];	if (!rta_tb[IFA_ADDRESS])		rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];	if (filter.ifindex && filter.ifindex != ifa->ifa_index)		return 0;	if ((filter.scope^ifa->ifa_scope)&filter.scopemask)		return 0;	if ((filter.flags ^ ifa_flags) & filter.flagmask)		return 0;	if (filter.label) {		SPRINT_BUF(b1);		const char *label;		if (rta_tb[IFA_LABEL])			label = RTA_DATA(rta_tb[IFA_LABEL]);		else			label = ll_idx_n2a(ifa->ifa_index, b1);		if (fnmatch(filter.label, label, 0) != 0)			return 0;	}	if (filter.pfx.family) {		if (rta_tb[IFA_LOCAL]) {			inet_prefix dst;			memset(&dst, 0, sizeof(dst));			dst.family = ifa->ifa_family;			memcpy(&dst.data, RTA_DATA(rta_tb[IFA_LOCAL]), RTA_PAYLOAD(rta_tb[IFA_LOCAL]));			if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))				return 0;		}	}	if (filter.family && filter.family != ifa->ifa_family)		return 0;	if (filter.flushb) {		struct nlmsghdr *fn;		if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {			if (flush_update())				return -1;		}		fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));		memcpy(fn, n, n->nlmsg_len);		fn->nlmsg_type = RTM_DELADDR;		fn->nlmsg_flags = NLM_F_REQUEST;		fn->nlmsg_seq = ++rth.seq;		filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;		filter.flushed++;		if (show_stats < 2)			return 0;	}	if (n->nlmsg_type == RTM_DELADDR)		fprintf(fp, "Deleted ");	if (filter.oneline || filter.flushb)		fprintf(fp, "%u: %s", ifa->ifa_index, ll_index_to_name(ifa->ifa_index));	if (ifa->ifa_family == AF_INET)		fprintf(fp, "    inet ");	else if (ifa->ifa_family == AF_INET6)		fprintf(fp, "    inet6 ");	else if (ifa->ifa_family == AF_DECnet)		fprintf(fp, "    dnet ");	else if (ifa->ifa_family == AF_IPX)		fprintf(fp, "     ipx ");	else		fprintf(fp, "    family %d ", ifa->ifa_family);	if (rta_tb[IFA_LOCAL]) {		if (ifa->ifa_family == AF_INET)			color_fprintf(fp, COLOR_INET, "%s", format_host(ifa->ifa_family,//.........这里部分代码省略.........

static void ipaddr_filter(struct nlmsg_chain *linfo, struct nlmsg_chain *ainfo){	struct nlmsg_list *l, **lp;	lp = &linfo->head;	while ( (l = *lp) != NULL) {		int ok = 0;		int missing_net_address = 1;		struct ifinfomsg *ifi = NLMSG_DATA(&l->h);		struct nlmsg_list *a;		for (a = ainfo->head; a; a = a->next) {			struct nlmsghdr *n = &a->h;			struct ifaddrmsg *ifa = NLMSG_DATA(n);			struct rtattr *tb[IFA_MAX + 1];			unsigned int ifa_flags;			if (ifa->ifa_index != ifi->ifi_index)				continue;			missing_net_address = 0;			if (filter.family && filter.family != ifa->ifa_family)				continue;			if ((filter.scope^ifa->ifa_scope)&filter.scopemask)				continue;			parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), IFA_PAYLOAD(n));			ifa_flags = get_ifa_flags(ifa, tb[IFA_FLAGS]);			if ((filter.flags ^ ifa_flags) & filter.flagmask)				continue;			if (filter.pfx.family || filter.label) {				if (!tb[IFA_LOCAL])					tb[IFA_LOCAL] = tb[IFA_ADDRESS];				if (filter.pfx.family && tb[IFA_LOCAL]) {					inet_prefix dst;					memset(&dst, 0, sizeof(dst));					dst.family = ifa->ifa_family;					memcpy(&dst.data, RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_LOCAL]));					if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))						continue;				}				if (filter.label) {					SPRINT_BUF(b1);					const char *label;					if (tb[IFA_LABEL])						label = RTA_DATA(tb[IFA_LABEL]);					else						label = ll_idx_n2a(ifa->ifa_index, b1);					if (fnmatch(filter.label, label, 0) != 0)						continue;				}			}			ok = 1;			break;		}		if (missing_net_address &&		    (filter.family == AF_UNSPEC || filter.family == AF_PACKET))			ok = 1;		if (!ok) {			*lp = l->next;			free(l);		} else			lp = &l->next;	}}

//.........这里部分代码省略.........		filter.ifindex = xll_name_to_index(filter_dev);	}	if (flush) {		char flushb[4096-512];		filter.flushb = flushb;		filter.flushp = 0;		filter.flushe = sizeof(flushb);		filter.rth = &rth;		for (;;) {			xrtnl_wilddump_request(&rth, filter.family, RTM_GETADDR);			filter.flushed = 0;			xrtnl_dump_filter(&rth, print_addrinfo, stdout);			if (filter.flushed == 0) {				return 0;			}			if (flush_update() < 0)				return 1;		}	}	if (filter.family != AF_PACKET) {		xrtnl_wilddump_request(&rth, filter.family, RTM_GETADDR);		xrtnl_dump_filter(&rth, store_nlmsg, &ainfo);	}	if (filter.family && filter.family != AF_PACKET) {		struct nlmsg_list **lp;		lp=&linfo;		if (filter.oneline)			no_link = 1;		while ((l=*lp)!=NULL) {			int ok = 0;			struct ifinfomsg *ifi = NLMSG_DATA(&l->h);			struct nlmsg_list *a;			for (a=ainfo; a; a=a->next) {				struct nlmsghdr *n = &a->h;				struct ifaddrmsg *ifa = NLMSG_DATA(n);				if (ifa->ifa_index != ifi->ifi_index ||				    (filter.family && filter.family != ifa->ifa_family))					continue;				if ((filter.scope^ifa->ifa_scope)&filter.scopemask)					continue;				if ((filter.flags^ifa->ifa_flags)&filter.flagmask)					continue;				if (filter.pfx.family || filter.label) {					struct rtattr *tb[IFA_MAX+1];					memset(tb, 0, sizeof(tb));					parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), IFA_PAYLOAD(n));					if (!tb[IFA_LOCAL])						tb[IFA_LOCAL] = tb[IFA_ADDRESS];					if (filter.pfx.family && tb[IFA_LOCAL]) {						inet_prefix dst;						memset(&dst, 0, sizeof(dst));						dst.family = ifa->ifa_family;						memcpy(&dst.data, RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_LOCAL]));						if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))							continue;					}					if (filter.label) {						SPRINT_BUF(b1);						const char *label;						if (tb[IFA_LABEL])							label = RTA_DATA(tb[IFA_LABEL]);						else							label = ll_idx_n2a(ifa->ifa_index, b1);						if (fnmatch(filter.label, label, 0) != 0)							continue;					}				}				ok = 1;				break;			}			if (!ok)				*lp = l->next;			else				lp = &l->next;		}	}	for (l = linfo; l; l = l->next) {		if (no_link || print_linkinfo(NULL, &l->h, stdout) == 0) {			struct ifinfomsg *ifi = NLMSG_DATA(&l->h);			if (filter.family != AF_PACKET)				print_selected_addrinfo(ifi->ifi_index, ainfo, stdout);		}		fflush(stdout); /* why? */	}	return 0;}