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);
}
}
int
TunnelIPv6Interface::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 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 {
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;
}
int
main()
{
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;
}
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;
}
/* return true if there is a known address with 'tentative' flag set */
static bool
virNetDevIPParseDadStatus(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;
}
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);
}
}
}
}
static void g_pn_nl_link(GPhonetNetlink *self, struct nlmsghdr *nlh)
{
const struct ifinfomsg *ifi;
const struct rtattr *rta;
int len;
const char *ifname = NULL;
GIsiModem *idx = NULL;
GPhonetLinkState st;
ifi = NLMSG_DATA(nlh);
len = IFA_PAYLOAD(nlh);
if (ifi->ifi_type != ARPHRD_PHONET)
return;
if (self->interface != 0 && self->interface != (unsigned)ifi->ifi_index)
return;
idx = make_modem(ifi->ifi_index);
#define UP (IFF_UP | IFF_LOWER_UP | IFF_RUNNING)
if (nlh->nlmsg_type == RTM_DELLINK)
st = PN_LINK_REMOVED;
else if ((ifi->ifi_flags & UP) != UP)
st = PN_LINK_DOWN;
else
st = PN_LINK_UP;
for (rta = IFLA_RTA(ifi); RTA_OK(rta, len);
rta = RTA_NEXT(rta, len)) {
if (rta->rta_type == IFLA_IFNAME)
ifname = RTA_DATA(rta);
}
if (ifname && idx)
self->callback(idx, st, ifname, self->opaque);
#undef UP
}
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);
}
}
}
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));
}
/*
* Parse a RTM_NEWADDR or RTM_DELADDR message.
*/
bool NetlinkEvent::parseIfAddrMessage(const struct nlmsghdr *nh) {
struct ifaddrmsg *ifaddr = (struct ifaddrmsg *) NLMSG_DATA(nh);
struct ifa_cacheinfo *cacheinfo = NULL;
char addrstr[INET6_ADDRSTRLEN] = "";
char ifname[IFNAMSIZ];
if (!checkRtNetlinkLength(nh, sizeof(*ifaddr)))
return false;
// Sanity check.
int type = nh->nlmsg_type;
if (type != RTM_NEWADDR && type != RTM_DELADDR) {
SLOGE("parseIfAddrMessage on incorrect message type 0x%x\n", type);
return false;
}
// For log messages.
const char *msgtype = rtMessageName(type);
struct rtattr *rta;
int len = IFA_PAYLOAD(nh);
for (rta = IFA_RTA(ifaddr); RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
if (rta->rta_type == IFA_ADDRESS) {
// Only look at the first address, because we only support notifying
// one change at a time.
if (maybeLogDuplicateAttribute(*addrstr != '\0', "IFA_ADDRESS", msgtype))
continue;
// Convert the IP address to a string.
if (ifaddr->ifa_family == AF_INET) {
struct in_addr *addr4 = (struct in_addr *) RTA_DATA(rta);
if (RTA_PAYLOAD(rta) < sizeof(*addr4)) {
SLOGE("Short IPv4 address (%zu bytes) in %s",
RTA_PAYLOAD(rta), msgtype);
continue;
}
inet_ntop(AF_INET, addr4, addrstr, sizeof(addrstr));
} else if (ifaddr->ifa_family == AF_INET6) {
struct in6_addr *addr6 = (struct in6_addr *) RTA_DATA(rta);
if (RTA_PAYLOAD(rta) < sizeof(*addr6)) {
SLOGE("Short IPv6 address (%zu bytes) in %s",
RTA_PAYLOAD(rta), msgtype);
continue;
}
inet_ntop(AF_INET6, addr6, addrstr, sizeof(addrstr));
} else {
SLOGE("Unknown address family %d\n", ifaddr->ifa_family);
continue;
}
// Find the interface name.
if (!if_indextoname(ifaddr->ifa_index, ifname)) {
SLOGE("Unknown ifindex %d in %s", ifaddr->ifa_index, msgtype);
return false;
}
} else if (rta->rta_type == IFA_CACHEINFO) {
// Address lifetime information.
if (maybeLogDuplicateAttribute(cacheinfo, "IFA_CACHEINFO", msgtype))
continue;
if (RTA_PAYLOAD(rta) < sizeof(*cacheinfo)) {
SLOGE("Short IFA_CACHEINFO (%zu vs. %zu bytes) in %s",
RTA_PAYLOAD(rta), sizeof(cacheinfo), msgtype);
continue;
}
cacheinfo = (struct ifa_cacheinfo *) RTA_DATA(rta);
}
}
if (addrstr[0] == '\0') {
SLOGE("No IFA_ADDRESS in %s\n", msgtype);
return false;
}
// Fill in netlink event information.
mAction = (type == RTM_NEWADDR) ? NlActionAddressUpdated :
NlActionAddressRemoved;
mSubsystem = strdup("net");
asprintf(&mParams[0], "ADDRESS=%s/%d", addrstr,
ifaddr->ifa_prefixlen);
asprintf(&mParams[1], "INTERFACE=%s", ifname);
asprintf(&mParams[2], "FLAGS=%u", ifaddr->ifa_flags);
asprintf(&mParams[3], "SCOPE=%u", ifaddr->ifa_scope);
if (cacheinfo) {
asprintf(&mParams[4], "PREFERRED=%u", cacheinfo->ifa_prefered);
asprintf(&mParams[5], "VALID=%u", cacheinfo->ifa_valid);
asprintf(&mParams[6], "CSTAMP=%u", cacheinfo->cstamp);
asprintf(&mParams[7], "TSTAMP=%u", cacheinfo->tstamp);
}
return true;
}
// Source-compatible with the BSD function.
int getifaddrs(ifaddrs** result) {
// Simplify cleanup for callers.
*result = NULL;
// Create a netlink socket.
ScopedFd fd(socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE));
if (fd.get() < 0) {
return -1;
}
// Ask for the address information.
addrReq_struct addrRequest;
memset(&addrRequest, 0, sizeof(addrRequest));
addrRequest.netlinkHeader.nlmsg_flags = NLM_F_REQUEST | NLM_F_MATCH;
addrRequest.netlinkHeader.nlmsg_type = RTM_GETADDR;
addrRequest.netlinkHeader.nlmsg_len = NLMSG_ALIGN(NLMSG_LENGTH(sizeof(addrRequest)));
addrRequest.msg.ifa_family = AF_UNSPEC; // All families.
addrRequest.msg.ifa_index = 0; // All interfaces.
if (!sendNetlinkMessage(fd.get(), &addrRequest, addrRequest.netlinkHeader.nlmsg_len)) {
return -1;
}
// Read the responses.
LocalArray<0> buf(65536); // We don't necessarily have std::vector.
ssize_t bytesRead;
while ((bytesRead = recvNetlinkMessage(fd.get(), &buf[0], buf.size())) > 0) {
nlmsghdr* hdr = reinterpret_cast<nlmsghdr*>(&buf[0]);
for (; NLMSG_OK(hdr, (unsigned int)bytesRead); hdr = NLMSG_NEXT(hdr, bytesRead)) {
switch (hdr->nlmsg_type) {
case NLMSG_DONE:
{
return 0;
}
case NLMSG_ERROR:
{
return -1;
}
case RTM_NEWADDR:
{
ifaddrmsg* address = reinterpret_cast<ifaddrmsg*>(NLMSG_DATA(hdr));
rtattr* rta = IFA_RTA(address);
size_t ifaPayloadLength = IFA_PAYLOAD(hdr);
while (RTA_OK(rta, ifaPayloadLength)) {
if (rta->rta_type == IFA_LOCAL) {
unsigned char family = address->ifa_family;
if (family == AF_INET || family == AF_INET6) {
*result = new ifaddrs(*result);
if (!(*result)->setNameAndFlagsByIndex(address->ifa_index)) {
return -1;
}
(*result)->setAddress(family, RTA_DATA(rta), RTA_PAYLOAD(rta));
(*result)->setNetmask(family, address->ifa_prefixlen);
}
}
rta = RTA_NEXT(rta, ifaPayloadLength);
}
}
break;
}
}
}
// We only get here if recv fails before we see a NLMSG_DONE.
return -1;
}
extern int ipaddr_list_or_flush(int argc, char **argv, int flush)
{
const char *option[] = { "to", "scope", "up", "label", "dev", 0 };
struct nlmsg_list *linfo = NULL;
struct nlmsg_list *ainfo = NULL;
struct nlmsg_list *l;
struct rtnl_handle rth;
char *filter_dev = NULL;
int no_link = 0;
ipaddr_reset_filter(oneline);
filter.showqueue = 1;
if (filter.family == AF_UNSPEC)
filter.family = preferred_family;
if (flush) {
if (argc <= 0) {
fprintf(stderr, "Flush requires arguments.\n");
return -1;
}
if (filter.family == AF_PACKET) {
fprintf(stderr, "Cannot flush link addresses.\n");
return -1;
}
}
while (argc > 0) {
const unsigned short option_num = compare_string_array(option, *argv);
switch (option_num) {
case 0: /* to */
NEXT_ARG();
get_prefix(&filter.pfx, *argv, filter.family);
if (filter.family == AF_UNSPEC) {
filter.family = filter.pfx.family;
}
break;
case 1: /* scope */
{
int scope = 0;
NEXT_ARG();
filter.scopemask = -1;
if (rtnl_rtscope_a2n(&scope, *argv)) {
if (strcmp(*argv, "all") != 0) {
invarg("invalid \"scope\"\n", *argv);
}
scope = RT_SCOPE_NOWHERE;
filter.scopemask = 0;
}
filter.scope = scope;
break;
}
case 2: /* up */
filter.up = 1;
break;
case 3: /* label */
NEXT_ARG();
filter.label = *argv;
break;
case 4: /* dev */
NEXT_ARG();
default:
if (filter_dev) {
duparg2("dev", *argv);
}
filter_dev = *argv;
}
argv++;
argc--;
}
if (rtnl_open(&rth, 0) < 0)
exit(1);
if (rtnl_wilddump_request(&rth, preferred_family, RTM_GETLINK) < 0) {
bb_perror_msg_and_die("Cannot send dump request");
}
if (rtnl_dump_filter(&rth, store_nlmsg, &linfo, NULL, NULL) < 0) {
bb_error_msg_and_die("Dump terminated");
}
if (filter_dev) {
filter.ifindex = ll_name_to_index(filter_dev);
if (filter.ifindex <= 0) {
bb_error_msg("Device \"%s\" does not exist.", filter_dev);
return -1;
}
}
if (flush) {
int round = 0;
char flushb[4096-512];
filter.flushb = flushb;
filter.flushp = 0;
filter.flushe = sizeof(flushb);
filter.rth = &rth;
for (;;) {
if (rtnl_wilddump_request(&rth, filter.family, RTM_GETADDR) < 0) {
perror("Cannot send dump request");
exit(1);
}
filter.flushed = 0;
if (rtnl_dump_filter(&rth, print_addrinfo, stdout, NULL, NULL) < 0) {
fprintf(stderr, "Flush terminated\n");
exit(1);
}
if (filter.flushed == 0) {
#if 0
if (round == 0)
fprintf(stderr, "Nothing to flush.\n");
#endif
fflush(stdout);
return 0;
}
round++;
if (flush_update() < 0)
exit(1);
}
}
if (filter.family != AF_PACKET) {
if (rtnl_wilddump_request(&rth, filter.family, RTM_GETADDR) < 0) {
bb_perror_msg_and_die("Cannot send dump request");
}
if (rtnl_dump_filter(&rth, store_nlmsg, &ainfo, NULL, NULL) < 0) {
bb_error_msg_and_die("Dump terminated");
}
}
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);
}
exit(0);
}
void Netlink::processNetlinkTelegram(void *pReadBuffer, size_t bufferSize) const
{
for (struct nlmsghdr *nh = reinterpret_cast <struct nlmsghdr *> (pReadBuffer); NLMSG_OK (nh, bufferSize); nh = NLMSG_NEXT (nh, bufferSize)) {
if (nh->nlmsg_type == NLMSG_DONE) {
// The end of multipart message.
break;
} else if (nh->nlmsg_type == NLMSG_ERROR) {
::syslog(LOG_ERR, "error processing netlink events");
break;
} else {
m_netadapterlist.update();
switch(nh->nlmsg_type) {
case RTM_NEWADDR:
{
struct ifaddrmsg* pIfaddrmsg = reinterpret_cast <struct ifaddrmsg*> (NLMSG_DATA(nh));
if(pIfaddrmsg->ifa_family==AF_INET) {
struct rtattr *rth = IFA_RTA(pIfaddrmsg);
int rtl = IFA_PAYLOAD(nh);
while (rtl && RTA_OK(rth, rtl)) {
if (rth->rta_type == IFA_LOCAL) {
// this is to be ignored if there are more than one ipv4 addresses assigned to the interface!
try {
communication::Netadapter adapter = m_netadapterlist.getAdapterByInterfaceIndex(pIfaddrmsg->ifa_index);
if(adapter.getIpv4Addresses().size()==1) {
if (m_eventHandler) {
struct in_addr* pIn = reinterpret_cast < struct in_addr* > (RTA_DATA(rth));
m_eventHandler(NEW, pIfaddrmsg->ifa_index, inet_ntoa(*pIn));
}
}
} catch(const hbm::exception::exception&) {
}
}
rth = RTA_NEXT(rth, rtl);
}
}
}
break;
case RTM_DELADDR:
{
struct ifaddrmsg* pIfaddrmsg = reinterpret_cast <struct ifaddrmsg*> (NLMSG_DATA(nh));
if(pIfaddrmsg->ifa_family==AF_INET) {
struct rtattr *rth = IFA_RTA(pIfaddrmsg);
int rtl = IFA_PAYLOAD(nh);
while (rtl && RTA_OK(rth, rtl)) {
if (rth->rta_type == IFA_LOCAL) {
// this is to be ignored if there is another ipv4 address left for the interface!
try {
communication::Netadapter adapter = m_netadapterlist.getAdapterByInterfaceIndex(pIfaddrmsg->ifa_index);
if(adapter.getIpv4Addresses().empty()==true) {
if (m_eventHandler) {
struct in_addr* pIn = reinterpret_cast < struct in_addr* > (RTA_DATA(rth));
m_eventHandler(NEW, pIfaddrmsg->ifa_index, inet_ntoa(*pIn));
}
}
} catch(const hbm::exception::exception&) {
}
}
rth = RTA_NEXT(rth, rtl);
}
}
}
break;
default:
break;
}
}
}
}
static void rtnl_print_ifaddr(struct nlmsghdr *hdr)
{
struct ifaddrmsg *ifa = NLMSG_DATA(hdr);
uint32_t attrs_len = IFA_PAYLOAD(hdr);
struct rtattr *attr = IFA_RTA(ifa);
struct ifa_cacheinfo *ci;
char addr_str[256];
char flags[256];
if (hdr->nlmsg_len < NLMSG_LENGTH(sizeof(*ifa)))
return;
tprintf(" [ Address Family %d (%s%s%s)", ifa->ifa_family,
colorize_start(bold),
addr_family2str(ifa->ifa_family),
colorize_end());
tprintf(", Prefix Len %d", ifa->ifa_prefixlen);
tprintf(", Flags %d (%s%s%s)", ifa->ifa_flags,
colorize_start(bold),
rtnl_addr_flags2str(ifa->ifa_flags, flags,
sizeof(flags)),
colorize_end());
tprintf(", Scope %d (%s%s%s)", ifa->ifa_scope,
colorize_start(bold),
scope2str(ifa->ifa_scope),
colorize_end());
tprintf(", Link Index %d ]\n", ifa->ifa_index);
for (; RTA_OK(attr, attrs_len); attr = RTA_NEXT(attr, attrs_len)) {
switch (attr->rta_type) {
case IFA_LOCAL:
rta_fmt(attr, "Local %s", addr2str(ifa->ifa_family,
RTA_DATA(attr), addr_str, sizeof(addr_str)));
break;
case IFA_ADDRESS:
rta_fmt(attr, "Address %s", addr2str(ifa->ifa_family,
RTA_DATA(attr), addr_str, sizeof(addr_str)));
break;
case IFA_BROADCAST:
rta_fmt(attr, "Broadcast %s",
addr2str(ifa->ifa_family,
RTA_DATA(attr), addr_str,
sizeof(addr_str)));
break;
case IFA_MULTICAST:
rta_fmt(attr, "Multicast %s",
addr2str(ifa->ifa_family,
RTA_DATA(attr), addr_str,
sizeof(addr_str)));
break;
case IFA_ANYCAST:
rta_fmt(attr, "Anycast %s", addr2str(ifa->ifa_family,
RTA_DATA(attr), addr_str, sizeof(addr_str)));
break;
#ifdef IFA_FLAGS
case IFA_FLAGS:
rta_fmt(attr, "Flags %d (%s%s%s)", RTA_INT(attr),
colorize_start(bold),
rtnl_addr_flags2str(RTA_INT(attr),
flags, sizeof(flags)),
colorize_end());
break;
#endif
case IFA_LABEL:
rta_fmt(attr, "Label %s", RTA_STR(attr));
break;
case IFA_CACHEINFO:
ci = RTA_DATA(attr);
tprintf("\tA: Cache (");
if (ci->ifa_valid == INFINITY)
tprintf("valid lft(forever)");
else
tprintf("valid lft(%us)", ci->ifa_valid);
if (ci->ifa_prefered == INFINITY)
tprintf(", prefrd lft(forever)");
else
tprintf(", prefrd lft(%us)", ci->ifa_prefered);
tprintf(", created on(%.2fs)", (double)ci->cstamp / 100);
tprintf(", updated on(%.2fs))", (double)ci->cstamp / 100);
tprintf(", Len %d\n", RTA_LEN(attr));
break;
default:
rta_fmt(attr, "0x%x", attr->rta_type);
break;
}
}
}
/*
* getifaddrs()
*
* Android (and other) compatible getifaddrs function, using
* rtnetlink. Enumerates all interfaces on the device.
*/
int getifaddrs(ifaddrs **addrlist) {
request_struct req;
struct ifaddrmsg *addr;
ifaddrs *prev;
struct rtattr *rta;
int afi;
size_t msglen;
int sockfd;
char rcvbuf[4096];
int readlen;
int retval;
struct nlmsghdr *rcvhdr;
*addrlist = NULL;
/*
* We open a separate socket here so the response can
* be synchronous
*/
sockfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
if (sockfd < 0) {
return -1;
}
/*
* Construct the request
*/
req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_MATCH;
req.nlh.nlmsg_type = RTM_GETADDR;
req.nlh.nlmsg_len = NLMSG_ALIGN(NLMSG_LENGTH(sizeof(request_struct)));
req.rtmsg.rtgen_family = AF_UNSPEC;
/*
* Send it
*/
retval = send(sockfd, &req, req.nlh.nlmsg_len, 0);
if (retval <= 0) {
close(sockfd);
return -1;
}
/*
* Receive the responses from the kernel
*/
while ((readlen = read(sockfd, rcvbuf, 4096)) > 0) {
rcvhdr = (struct nlmsghdr *)rcvbuf;
/*
* Walk through everything it sent us
*/
for (; NLMSG_OK(rcvhdr, (unsigned int)readlen); rcvhdr = NLMSG_NEXT(rcvhdr, readlen)) {
switch (rcvhdr->nlmsg_type) {
case NLMSG_DONE:
close(sockfd);
return 0;
case NLMSG_ERROR:
close(sockfd);
return -1;
case RTM_NEWADDR:
addr = (struct ifaddrmsg *)NLMSG_DATA(rcvhdr);
rta = IFA_RTA(addr);
msglen = IFA_PAYLOAD(rcvhdr);
while (RTA_OK(rta, msglen)) {
/*
* Only care about local addresses of our interfaces
*/
if (rta->rta_type == IFA_LOCAL) {
afi = addr->ifa_family;
if ((afi == AF_INET) || (afi == AF_INET6)) {
if (*addrlist) {
prev = *addrlist;
} else {
prev = NULL;
}
*addrlist = malloc(sizeof(ifaddrs)); // Must free elsewhere XXX
memset(*addrlist, 0, sizeof(ifaddrs));
(*addrlist)->ifa_next = prev;
populate_ifaddr_entry(*addrlist, afi, RTA_DATA(rta), addr->ifa_index, RTA_PAYLOAD(rta));
}
}
rta = RTA_NEXT(rta, msglen);
}
break;
default:
break;
}
}
}
close(sockfd);
return 0;
}
/*** msg_handler ***/
int msg_handler (struct sockaddr_nl *nl, struct nlmsghdr *msg) {
int rc = EXIT_FAILURE;
char *notifystr = NULL;
unsigned int errcount = 0;
GError *error = NULL;
struct ifaddrmsg *ifa;
struct ifinfomsg *ifi;
struct rtattr *rth;
int rtl;
char buf[INET6_ADDRSTRLEN];
NotifyNotification *tmp_notification = NULL, *notification = NULL;
char *icon = NULL;
ifa = (struct ifaddrmsg *) NLMSG_DATA (msg);
ifi = (struct ifinfomsg *) NLMSG_DATA (msg);
/* make sure we have alloced memory for NotifyNotification and addresses_seen struct array */
if (maxinterface < ifi->ifi_index) {
ifs = realloc(ifs, (ifi->ifi_index + 1) * sizeof(struct ifs));
while(maxinterface < ifi->ifi_index) {
maxinterface++;
if (verbose > 0)
printf("%s: Initializing interface %d: ", program, maxinterface);
/* get interface name and store it
* in case the interface does no longer exist this may fail,
* use static string '(unknown)' instead */
if (if_indextoname(maxinterface, ifs[maxinterface].name) == NULL)
strcpy(ifs[maxinterface].name, "(unknown)");
if (verbose > 0)
printf("%s\n", ifs[maxinterface].name);
ifs[maxinterface].state = -1;
ifs[maxinterface].deleted = 0;
ifs[maxinterface].notification =
# if NOTIFY_CHECK_VERSION(0, 7, 0)
notify_notification_new(TEXT_TOPIC, NULL, NULL);
# else
notify_notification_new(TEXT_TOPIC, NULL, NULL, NULL);
# endif
notify_notification_set_category(ifs[maxinterface].notification, PROGNAME);
notify_notification_set_urgency(ifs[maxinterface].notification, NOTIFY_URGENCY_NORMAL);
notify_notification_set_timeout(ifs[maxinterface].notification, notification_timeout);
ifs[maxinterface].addresses_seen = NULL;
}
} else if (ifs[ifi->ifi_index].deleted == 1) {
if (verbose > 0)
printf("%s: Ignoring event for deleted interface %d.\n", program, ifi->ifi_index);
rc = EXIT_SUCCESS;
goto out;
}
/* make notification point to the array element, will be overwritten
* later when needed for address notification */
notification = ifs[ifi->ifi_index].notification;
/* get interface name and store it
* in case the interface does no longer exist this may fail, but it does not overwrite */
if_indextoname(ifi->ifi_index, ifs[ifi->ifi_index].name);
if (verbose > 1)
printf("%s: Event for interface %s (%d): flags = %x, msg type = %d\n",
program, ifs[ifi->ifi_index].name, ifi->ifi_index, ifa->ifa_flags, msg->nlmsg_type);
switch (msg->nlmsg_type) {
/* just return for cases we want to ignore
* use break if a notification has to be displayed */
case RTM_NEWADDR:
rth = IFA_RTA (ifa);
rtl = IFA_PAYLOAD (msg);
while (rtl && RTA_OK (rth, rtl)) {
if ((rth->rta_type == IFA_LOCAL /* IPv4 */
|| rth->rta_type == IFA_ADDRESS /* IPv6 */)
&& ifa->ifa_scope == RT_SCOPE_UNIVERSE /* no IPv6 scope link */) {
inet_ntop(ifa->ifa_family, RTA_DATA (rth), buf, sizeof(buf));
/* check if we already notified about this address */
if (match_address(ifs[ifi->ifi_index].addresses_seen, buf, ifa->ifa_prefixlen)) {
if (verbose > 0)
printf("%s: Address %s/%d already known for %s, ignoring.\n",
program, buf, ifa->ifa_prefixlen, ifs[ifi->ifi_index].name);
break;
}
/* add address to struct */
ifs[ifi->ifi_index].addresses_seen =
add_address(ifs[ifi->ifi_index].addresses_seen, buf, ifa->ifa_prefixlen);
if (verbose > 1)
list_addresses(ifs[ifi->ifi_index].addresses_seen, ifs[ifi->ifi_index].name);
/* display notification */
notifystr = newstr_addr(ifs[ifi->ifi_index].name,
ifa->ifa_family, buf, ifa->ifa_prefixlen);
/* we are done, no need to run more loops */
break;
}
rth = RTA_NEXT (rth, rtl);
}
/* we did not find anything to notify */
if (notifystr == NULL) {
rc = EXIT_SUCCESS;
goto out;
}
/* do we want new notification, not update the notification about link status */
tmp_notification =
# if NOTIFY_CHECK_VERSION(0, 7, 0)
notify_notification_new(TEXT_TOPIC, NULL, NULL);
# else
notify_notification_new(TEXT_TOPIC, NULL, NULL, NULL);
# endif
notify_notification_set_category(tmp_notification, PROGNAME);
notify_notification_set_urgency(tmp_notification, NOTIFY_URGENCY_NORMAL);
notify_notification_set_timeout(tmp_notification, notification_timeout);
notification = tmp_notification;
icon = ICON_NETWORK_ADDRESS;
break;
case RTM_DELADDR:
rth = IFA_RTA (ifa);
rtl = IFA_PAYLOAD (msg);
while (rtl && RTA_OK (rth, rtl)) {
if ((rth->rta_type == IFA_LOCAL /* IPv4 */
|| rth->rta_type == IFA_ADDRESS /* IPv6 */)
&& ifa->ifa_scope == RT_SCOPE_UNIVERSE /* no IPv6 scope link */) {
inet_ntop(ifa->ifa_family, RTA_DATA (rth), buf, sizeof(buf));
ifs[ifi->ifi_index].addresses_seen =
remove_address(ifs[ifi->ifi_index].addresses_seen, buf, ifa->ifa_prefixlen);
if (verbose > 1)
list_addresses(ifs[ifi->ifi_index].addresses_seen, ifs[ifi->ifi_index].name);
/* we are done, no need to run more loops */
break;
}
rth = RTA_NEXT (rth, rtl);
}
rc = EXIT_SUCCESS;
goto out;
case RTM_NEWROUTE:
rc = EXIT_SUCCESS;
goto out;
case RTM_DELROUTE:
rc = EXIT_SUCCESS;
goto out;
case RTM_NEWLINK:
/* ignore if state did not change */
if ((ifi->ifi_flags & CHECK_CONNECTED) == ifs[ifi->ifi_index].state) {
rc = EXIT_SUCCESS;
goto out;
}
ifs[ifi->ifi_index].state = ifi->ifi_flags & CHECK_CONNECTED;
notifystr = newstr_link(ifs[ifi->ifi_index].name, ifi->ifi_flags);
icon = ifi->ifi_flags & CHECK_CONNECTED ? ICON_NETWORK_UP : ICON_NETWORK_DOWN;
/* free only if interface goes down */
if (!(ifi->ifi_flags & CHECK_CONNECTED)) {
free_addresses(ifs[ifi->ifi_index].addresses_seen);
ifs[ifi->ifi_index].addresses_seen = NULL;
}
break;
case RTM_DELLINK:
notifystr = newstr_away(ifs[ifi->ifi_index].name);
icon = ICON_NETWORK_AWAY;
free_addresses(ifs[ifi->ifi_index].addresses_seen);
/* marking interface deleted makes events for this interface to be ignored */
ifs[ifi->ifi_index].deleted = 1;
break;
default:
/* we should not get here... */
fprintf(stderr, "msg_handler: Unknown netlink nlmsg_type %d.\n", msg->nlmsg_type);
goto out;
}
if (verbose > 0)
printf("%s: %s\n", program, notifystr);
notify_notification_update(notification, TEXT_TOPIC, notifystr, icon);
while (notify_notification_show(notification, &error) == FALSE) {
if (errcount > 1) {
fprintf(stderr, "%s: Looks like we can not reconnect to notification daemon... Exiting.\n", program);
goto out;
} else {
g_printerr("%s: Error \"%s\" while trying to show notification. Trying to reconnect.\n", program, error->message);
errcount++;
g_error_free(error);
error = NULL;
notify_uninit();
usleep (500 * 1000);
if (notify_init(PROGNAME) == FALSE) {
fprintf(stderr, "%s: Can't create notify.\n", program);
goto out;
}
}
}
rc = EXIT_SUCCESS;
out:
if (tmp_notification)
g_object_unref(G_OBJECT(tmp_notification));
errcount = 0;
free(notifystr);
return rc;
}
/*
* Parse a binary message from a NETLINK_ROUTE netlink socket.
*/
bool NetlinkEvent::parseBinaryNetlinkMessage(char *buffer, int size) {
const struct nlmsghdr *nh;
for (nh = (struct nlmsghdr *) buffer;
NLMSG_OK(nh, (unsigned) size) && (nh->nlmsg_type != NLMSG_DONE);
nh = NLMSG_NEXT(nh, size)) {
if (nh->nlmsg_type == RTM_NEWLINK) {
int len = nh->nlmsg_len - sizeof(*nh);
struct ifinfomsg *ifi;
if (sizeof(*ifi) > (size_t) len) {
SLOGE("Got a short RTM_NEWLINK message\n");
continue;
}
ifi = (ifinfomsg *)NLMSG_DATA(nh);
if ((ifi->ifi_flags & IFF_LOOPBACK) != 0) {
continue;
}
struct rtattr *rta = (struct rtattr *)
((char *) ifi + NLMSG_ALIGN(sizeof(*ifi)));
len = NLMSG_PAYLOAD(nh, sizeof(*ifi));
while(RTA_OK(rta, len)) {
switch(rta->rta_type) {
case IFLA_IFNAME:
char buffer[16 + IFNAMSIZ];
snprintf(buffer, sizeof(buffer), "INTERFACE=%s",
(char *) RTA_DATA(rta));
mParams[0] = strdup(buffer);
mAction = (ifi->ifi_flags & IFF_LOWER_UP) ?
NlActionLinkUp : NlActionLinkDown;
mSubsystem = strdup("net");
break;
}
rta = RTA_NEXT(rta, len);
}
} else if (nh->nlmsg_type == QLOG_NL_EVENT) {
char *devname;
ulog_packet_msg_t *pm;
size_t len = nh->nlmsg_len - sizeof(*nh);
if (sizeof(*pm) > len) {
SLOGE("Got a short QLOG message\n");
continue;
}
pm = (ulog_packet_msg_t *)NLMSG_DATA(nh);
devname = pm->indev_name[0] ? pm->indev_name : pm->outdev_name;
asprintf(&mParams[0], "ALERT_NAME=%s", pm->prefix);
asprintf(&mParams[1], "INTERFACE=%s", devname);
mSubsystem = strdup("qlog");
mAction = NlActionChange;
} else if (nh->nlmsg_type == RTM_NEWADDR ||
nh->nlmsg_type == RTM_DELADDR) {
int len = nh->nlmsg_len - sizeof(*nh);
struct ifaddrmsg *ifa;
if (sizeof(*ifa) > (size_t) len) {
SLOGE("Got a short RTM_xxxADDR message\n");
continue;
}
ifa = (ifaddrmsg *)NLMSG_DATA(nh);
size_t rtasize = IFA_PAYLOAD(nh);
if (!parseIfAddrMessage(nh->nlmsg_type, ifa, rtasize)) {
continue;
}
} else if (nh->nlmsg_type == RTM_NEWNDUSEROPT) {
int len = nh->nlmsg_len - sizeof(*nh);
struct nduseroptmsg *ndmsg = (struct nduseroptmsg *) NLMSG_DATA(nh);
if (sizeof(*ndmsg) > (size_t) len) {
SLOGE("Got a short RTM_NEWNDUSEROPT message\n");
continue;
}
size_t optsize = NLMSG_PAYLOAD(nh, sizeof(*ndmsg));
if (!parseNdUserOptMessage(ndmsg, optsize)) {
continue;
}
} else {
SLOGD("Unexpected netlink message. type=0x%x\n",
nh->nlmsg_type);
}
}
return true;
}
/* Create a linked list of `struct ifaddrs' structures, one for each
network interface on the host machine. If successful, store the
list in *IFAP and return 0. On errors, return -1 and set `errno'. */
int
getifaddrs (struct ifaddrs **ifap)
{
struct netlink_handle nh = { 0, 0, 0, NULL, NULL };
struct netlink_res *nlp;
struct ifaddrs_storage *ifas;
unsigned int i, newlink, newaddr, newaddr_idx;
int *map_newlink_data;
size_t ifa_data_size = 0; /* Size to allocate for all ifa_data. */
char *ifa_data_ptr; /* Pointer to the unused part of memory for
ifa_data. */
int result = 0;
if (ifap)
*ifap = NULL;
if (! __no_netlink_support && __netlink_open (&nh) < 0)
{
#if __ASSUME_NETLINK_SUPPORT != 0
return -1;
#endif
}
#if __ASSUME_NETLINK_SUPPORT == 0
if (__no_netlink_support)
return fallback_getifaddrs (ifap);
#endif
/* Tell the kernel that we wish to get a list of all
active interfaces, collect all data for every interface. */
if (__netlink_request (&nh, RTM_GETLINK) < 0)
{
result = -1;
goto exit_free;
}
/* Now ask the kernel for all addresses which are assigned
to an interface and collect all data for every interface.
Since we store the addresses after the interfaces in the
list, we will later always find the interface before the
corresponding addresses. */
++nh.seq;
if (__netlink_request (&nh, RTM_GETADDR) < 0)
{
result = -1;
goto exit_free;
}
/* Count all RTM_NEWLINK and RTM_NEWADDR entries to allocate
enough memory. */
newlink = newaddr = 0;
for (nlp = nh.nlm_list; nlp; nlp = nlp->next)
{
struct nlmsghdr *nlh;
size_t size = nlp->size;
if (nlp->nlh == NULL)
continue;
/* Walk through all entries we got from the kernel and look, which
message type they contain. */
for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
{
/* Check if the message is what we want. */
if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
continue;
if (nlh->nlmsg_type == NLMSG_DONE)
break; /* ok */
if (nlh->nlmsg_type == RTM_NEWLINK)
{
/* A RTM_NEWLINK message can have IFLA_STATS data. We need to
know the size before creating the list to allocate enough
memory. */
struct ifinfomsg *ifim = (struct ifinfomsg *) NLMSG_DATA (nlh);
struct rtattr *rta = IFLA_RTA (ifim);
size_t rtasize = IFLA_PAYLOAD (nlh);
while (RTA_OK (rta, rtasize))
{
size_t rta_payload = RTA_PAYLOAD (rta);
if (rta->rta_type == IFLA_STATS)
{
ifa_data_size += rta_payload;
break;
}
else
rta = RTA_NEXT (rta, rtasize);
}
++newlink;
}
else if (nlh->nlmsg_type == RTM_NEWADDR)
++newaddr;
}
}
/* Return if no interface is up. */
if ((newlink + newaddr) == 0)
goto exit_free;
/* Allocate memory for all entries we have and initialize next
pointer. */
ifas = (struct ifaddrs_storage *) calloc (1,
(newlink + newaddr)
* sizeof (struct ifaddrs_storage)
+ ifa_data_size);
if (ifas == NULL)
{
result = -1;
goto exit_free;
}
/* Table for mapping kernel index to entry in our list. */
map_newlink_data = alloca (newlink * sizeof (int));
memset (map_newlink_data, '\xff', newlink * sizeof (int));
ifa_data_ptr = (char *) &ifas[newlink + newaddr];
newaddr_idx = 0; /* Counter for newaddr index. */
/* Walk through the list of data we got from the kernel. */
for (nlp = nh.nlm_list; nlp; nlp = nlp->next)
{
struct nlmsghdr *nlh;
size_t size = nlp->size;
if (nlp->nlh == NULL)
continue;
/* Walk through one message and look at the type: If it is our
message, we need RTM_NEWLINK/RTM_NEWADDR and stop if we reach
the end or we find the end marker (in this case we ignore the
following data. */
for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
{
int ifa_index = 0;
/* Check if the message is the one we want */
if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
continue;
if (nlh->nlmsg_type == NLMSG_DONE)
break; /* ok */
if (nlh->nlmsg_type == RTM_NEWLINK)
{
/* We found a new interface. Now extract everything from the
interface data we got and need. */
struct ifinfomsg *ifim = (struct ifinfomsg *) NLMSG_DATA (nlh);
struct rtattr *rta = IFLA_RTA (ifim);
size_t rtasize = IFLA_PAYLOAD (nlh);
/* Interfaces are stored in the first "newlink" entries
of our list, starting in the order as we got from the
kernel. */
ifa_index = map_newlink (ifim->ifi_index - 1, ifas,
map_newlink_data, newlink);
ifas[ifa_index].ifa.ifa_flags = ifim->ifi_flags;
while (RTA_OK (rta, rtasize))
{
char *rta_data = RTA_DATA (rta);
size_t rta_payload = RTA_PAYLOAD (rta);
switch (rta->rta_type)
{
case IFLA_ADDRESS:
if (rta_payload <= sizeof (ifas[ifa_index].addr))
{
ifas[ifa_index].addr.sl.sll_family = AF_PACKET;
memcpy (ifas[ifa_index].addr.sl.sll_addr,
(char *) rta_data, rta_payload);
ifas[ifa_index].addr.sl.sll_halen = rta_payload;
ifas[ifa_index].addr.sl.sll_ifindex
= ifim->ifi_index;
ifas[ifa_index].addr.sl.sll_hatype = ifim->ifi_type;
ifas[ifa_index].ifa.ifa_addr
= &ifas[ifa_index].addr.sa;
}
break;
case IFLA_BROADCAST:
if (rta_payload <= sizeof (ifas[ifa_index].broadaddr))
{
ifas[ifa_index].broadaddr.sl.sll_family = AF_PACKET;
memcpy (ifas[ifa_index].broadaddr.sl.sll_addr,
(char *) rta_data, rta_payload);
ifas[ifa_index].broadaddr.sl.sll_halen = rta_payload;
ifas[ifa_index].broadaddr.sl.sll_ifindex
= ifim->ifi_index;
ifas[ifa_index].broadaddr.sl.sll_hatype
= ifim->ifi_type;
ifas[ifa_index].ifa.ifa_broadaddr
= &ifas[ifa_index].broadaddr.sa;
}
break;
case IFLA_IFNAME: /* Name of Interface */
if ((rta_payload + 1) <= sizeof (ifas[ifa_index].name))
{
ifas[ifa_index].ifa.ifa_name = ifas[ifa_index].name;
*(char *) __mempcpy (ifas[ifa_index].name, rta_data,
rta_payload) = '\0';
}
break;
case IFLA_STATS: /* Statistics of Interface */
ifas[ifa_index].ifa.ifa_data = ifa_data_ptr;
ifa_data_ptr += rta_payload;
memcpy (ifas[ifa_index].ifa.ifa_data, rta_data,
rta_payload);
break;
case IFLA_UNSPEC:
break;
case IFLA_MTU:
break;
case IFLA_LINK:
break;
case IFLA_QDISC:
break;
default:
break;
}
rta = RTA_NEXT (rta, rtasize);
}
}
else if (nlh->nlmsg_type == RTM_NEWADDR)
{
struct ifaddrmsg *ifam = (struct ifaddrmsg *) NLMSG_DATA (nlh);
struct rtattr *rta = IFA_RTA (ifam);
size_t rtasize = IFA_PAYLOAD (nlh);
/* New Addresses are stored in the order we got them from
the kernel after the interfaces. Theoretically it is possible
that we have holes in the interface part of the list,
but we always have already the interface for this address. */
ifa_index = newlink + newaddr_idx;
ifas[ifa_index].ifa.ifa_flags
= ifas[map_newlink (ifam->ifa_index - 1, ifas,
map_newlink_data, newlink)].ifa.ifa_flags;
if (ifa_index > 0)
ifas[ifa_index - 1].ifa.ifa_next = &ifas[ifa_index].ifa;
++newaddr_idx;
while (RTA_OK (rta, rtasize))
{
char *rta_data = RTA_DATA (rta);
size_t rta_payload = RTA_PAYLOAD (rta);
switch (rta->rta_type)
{
case IFA_ADDRESS:
{
struct sockaddr *sa;
if (ifas[ifa_index].ifa.ifa_addr != NULL)
{
/* In a point-to-poing network IFA_ADDRESS
contains the destination address, local
address is supplied in IFA_LOCAL attribute.
destination address and broadcast address
are stored in an union, so it doesn't matter
which name we use. */
ifas[ifa_index].ifa.ifa_broadaddr
= &ifas[ifa_index].broadaddr.sa;
sa = &ifas[ifa_index].broadaddr.sa;
}
else
{
ifas[ifa_index].ifa.ifa_addr
= &ifas[ifa_index].addr.sa;
sa = &ifas[ifa_index].addr.sa;
}
sa->sa_family = ifam->ifa_family;
switch (ifam->ifa_family)
{
case AF_INET:
/* Size must match that of an address for IPv4. */
if (rta_payload == 4)
memcpy (&((struct sockaddr_in *) sa)->sin_addr,
rta_data, rta_payload);
break;
case AF_INET6:
/* Size must match that of an address for IPv6. */
if (rta_payload == 16)
{
memcpy (&((struct sockaddr_in6 *) sa)->sin6_addr,
rta_data, rta_payload);
if (IN6_IS_ADDR_LINKLOCAL (rta_data)
|| IN6_IS_ADDR_MC_LINKLOCAL (rta_data))
((struct sockaddr_in6 *) sa)->sin6_scope_id
= ifam->ifa_index;
}
break;
default:
if (rta_payload <= sizeof (ifas[ifa_index].addr))
memcpy (sa->sa_data, rta_data, rta_payload);
break;
}
}
break;
case IFA_LOCAL:
if (ifas[ifa_index].ifa.ifa_addr != NULL)
{
/* If ifa_addr is set and we get IFA_LOCAL,
assume we have a point-to-point network.
Move address to correct field. */
ifas[ifa_index].broadaddr = ifas[ifa_index].addr;
ifas[ifa_index].ifa.ifa_broadaddr
= &ifas[ifa_index].broadaddr.sa;
memset (&ifas[ifa_index].addr, '\0',
sizeof (ifas[ifa_index].addr));
}
ifas[ifa_index].ifa.ifa_addr = &ifas[ifa_index].addr.sa;
ifas[ifa_index].ifa.ifa_addr->sa_family
= ifam->ifa_family;
switch (ifam->ifa_family)
{
case AF_INET:
/* Size must match that of an address for IPv4. */
if (rta_payload == 4)
memcpy (&ifas[ifa_index].addr.s4.sin_addr,
rta_data, rta_payload);
break;
case AF_INET6:
/* Size must match that of an address for IPv6. */
if (rta_payload == 16)
{
memcpy (&ifas[ifa_index].addr.s6.sin6_addr,
rta_data, rta_payload);
if (IN6_IS_ADDR_LINKLOCAL (rta_data)
|| IN6_IS_ADDR_MC_LINKLOCAL (rta_data))
ifas[ifa_index].addr.s6.sin6_scope_id =
ifam->ifa_index;
}
break;
default:
if (rta_payload <= sizeof (ifas[ifa_index].addr))
memcpy (ifas[ifa_index].addr.sa.sa_data,
rta_data, rta_payload);
break;
}
break;
case IFA_BROADCAST:
/* We get IFA_BROADCAST, so IFA_LOCAL was too much. */
if (ifas[ifa_index].ifa.ifa_broadaddr != NULL)
memset (&ifas[ifa_index].broadaddr, '\0',
sizeof (ifas[ifa_index].broadaddr));
ifas[ifa_index].ifa.ifa_broadaddr
= &ifas[ifa_index].broadaddr.sa;
ifas[ifa_index].ifa.ifa_broadaddr->sa_family
= ifam->ifa_family;
switch (ifam->ifa_family)
{
case AF_INET:
/* Size must match that of an address for IPv4. */
if (rta_payload == 4)
memcpy (&ifas[ifa_index].broadaddr.s4.sin_addr,
rta_data, rta_payload);
break;
case AF_INET6:
/* Size must match that of an address for IPv6. */
if (rta_payload == 16)
{
memcpy (&ifas[ifa_index].broadaddr.s6.sin6_addr,
rta_data, rta_payload);
if (IN6_IS_ADDR_LINKLOCAL (rta_data)
|| IN6_IS_ADDR_MC_LINKLOCAL (rta_data))
ifas[ifa_index].broadaddr.s6.sin6_scope_id
= ifam->ifa_index;
}
break;
default:
if (rta_payload <= sizeof (ifas[ifa_index].addr))
memcpy (&ifas[ifa_index].broadaddr.sa.sa_data,
rta_data, rta_payload);
break;
}
break;
case IFA_LABEL:
if (rta_payload + 1 <= sizeof (ifas[ifa_index].name))
{
ifas[ifa_index].ifa.ifa_name = ifas[ifa_index].name;
*(char *) __mempcpy (ifas[ifa_index].name, rta_data,
rta_payload) = '\0';
}
else
abort ();
break;
case IFA_UNSPEC:
break;
case IFA_CACHEINFO:
break;
default:
break;
}
rta = RTA_NEXT (rta, rtasize);
}
/* If we didn't get the interface name with the
address, use the name from the interface entry. */
if (ifas[ifa_index].ifa.ifa_name == NULL)
ifas[ifa_index].ifa.ifa_name
= ifas[map_newlink (ifam->ifa_index - 1, ifas,
map_newlink_data, newlink)].ifa.ifa_name;
/* Calculate the netmask. */
if (ifas[ifa_index].ifa.ifa_addr
&& ifas[ifa_index].ifa.ifa_addr->sa_family != AF_UNSPEC
&& ifas[ifa_index].ifa.ifa_addr->sa_family != AF_PACKET)
{
uint32_t max_prefixlen = 0;
char *cp = NULL;
ifas[ifa_index].ifa.ifa_netmask
= &ifas[ifa_index].netmask.sa;
switch (ifas[ifa_index].ifa.ifa_addr->sa_family)
{
case AF_INET:
cp = (char *) &ifas[ifa_index].netmask.s4.sin_addr;
max_prefixlen = 32;
break;
case AF_INET6:
cp = (char *) &ifas[ifa_index].netmask.s6.sin6_addr;
max_prefixlen = 128;
break;
}
ifas[ifa_index].ifa.ifa_netmask->sa_family
= ifas[ifa_index].ifa.ifa_addr->sa_family;
if (cp != NULL)
{
char c;
unsigned int preflen;
if ((max_prefixlen > 0) &&
(ifam->ifa_prefixlen > max_prefixlen))
preflen = max_prefixlen;
else
preflen = ifam->ifa_prefixlen;
for (i = 0; i < (preflen / 8); i++)
*cp++ = 0xff;
c = 0xff;
c <<= (8 - (preflen % 8));
*cp = c;
}
}
}
}
}
assert (ifa_data_ptr <= (char *) &ifas[newlink + newaddr] + ifa_data_size);
if (newaddr_idx > 0)
{
for (i = 0; i < newlink; ++i)
if (map_newlink_data[i] == -1)
{
/* We have fewer links then we anticipated. Adjust the
forward pointer to the first address entry. */
ifas[i - 1].ifa.ifa_next = &ifas[newlink].ifa;
}
if (i == 0 && newlink > 0)
/* No valid link, but we allocated memory. We have to
populate the first entry. */
memmove (ifas, &ifas[newlink], sizeof (struct ifaddrs_storage));
}
if (ifap != NULL)
*ifap = &ifas[0].ifa;
exit_free:
__netlink_free_handle (&nh);
__netlink_close (&nh);
return result;
}
int ipaddr_list_or_flush(int argc, char **argv, int flush)
{
struct nlmsg_list *linfo = NULL;
struct nlmsg_list *ainfo = NULL;
struct nlmsg_list *l;
struct rtnl_handle rth;
char *filter_dev = NULL;
int no_link = 0;
ipaddr_reset_filter(oneline);
filter.showqueue = 1;
if (filter.family == AF_UNSPEC)
filter.family = preferred_family;
if (flush) {
if (argc <= 0) {
fprintf(stderr, "Flush requires arguments.\n");
return -1;
}
if (filter.family == AF_PACKET) {
fprintf(stderr, "Cannot flush link addresses.\n");
return -1;
}
}
while (argc > 0) {
if (strcmp(*argv, "to") == 0) {
NEXT_ARG();
get_prefix(&filter.pfx, *argv, filter.family);
if (filter.family == AF_UNSPEC)
filter.family = filter.pfx.family;
} else if (strcmp(*argv, "scope") == 0) {
int scope = 0;
NEXT_ARG();
filter.scopemask = -1;
if (rtnl_rtscope_a2n(&scope, *argv)) {
if (strcmp(*argv, "all") != 0)
invarg("invalid \"scope\"\n", *argv);
scope = RT_SCOPE_NOWHERE;
filter.scopemask = 0;
}
filter.scope = scope;
} else if (strcmp(*argv, "up") == 0) {
filter.up = 1;
} else if (strcmp(*argv, "dynamic") == 0) {
filter.flags &= ~IFA_F_PERMANENT;
filter.flagmask |= IFA_F_PERMANENT;
} else if (strcmp(*argv, "permanent") == 0) {
filter.flags |= IFA_F_PERMANENT;
filter.flagmask |= IFA_F_PERMANENT;
} else if (strcmp(*argv, "secondary") == 0) {
filter.flags |= IFA_F_SECONDARY;
filter.flagmask |= IFA_F_SECONDARY;
} else if (strcmp(*argv, "primary") == 0) {
filter.flags &= ~IFA_F_SECONDARY;
filter.flagmask |= IFA_F_SECONDARY;
} else if (strcmp(*argv, "tentative") == 0) {
filter.flags |= IFA_F_TENTATIVE;
filter.flagmask |= IFA_F_TENTATIVE;
} else if (strcmp(*argv, "deprecated") == 0) {
filter.flags |= IFA_F_DEPRECATED;
filter.flagmask |= IFA_F_DEPRECATED;
} else if (strcmp(*argv, "label") == 0) {
NEXT_ARG();
filter.label = *argv;
} else {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
}
if (matches(*argv, "help") == 0)
usage();
if (filter_dev)
duparg2("dev", *argv);
filter_dev = *argv;
}
argv++; argc--;
}
if (rtnl_open(&rth, 0) < 0)
exit(1);
if (rtnl_wilddump_request(&rth, preferred_family, RTM_GETLINK) < 0) {
perror("Cannot send dump request");
exit(1);
}
if (rtnl_dump_filter(&rth, store_nlmsg, &linfo, NULL, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
if (filter_dev) {
filter.ifindex = ll_name_to_index(filter_dev);
if (filter.ifindex <= 0) {
fprintf(stderr, "Device \"%s\" does not exist.\n", filter_dev);
return -1;
}
}
if (flush) {
int round = 0;
char flushb[4096-512];
filter.flushb = flushb;
filter.flushp = 0;
filter.flushe = sizeof(flushb);
filter.rth = &rth;
for (;;) {
if (rtnl_wilddump_request(&rth, filter.family, RTM_GETADDR) < 0) {
perror("Cannot send dump request");
exit(1);
}
filter.flushed = 0;
if (rtnl_dump_filter(&rth, print_addrinfo, stdout, NULL, NULL) < 0) {
fprintf(stderr, "Flush terminated\n");
exit(1);
}
if (filter.flushed == 0) {
if (round == 0) {
fprintf(stderr, "Nothing to flush.\n");
} else if (show_stats)
printf("*** Flush is complete after %d round%s ***\n", round, round>1?"s":"");
fflush(stdout);
return 0;
}
round++;
if (flush_update() < 0)
exit(1);
if (show_stats) {
printf("\n*** Round %d, deleting %d addresses ***\n", round, filter.flushed);
fflush(stdout);
}
}
}
if (filter.family != AF_PACKET) {
if (rtnl_wilddump_request(&rth, filter.family, RTM_GETADDR) < 0) {
perror("Cannot send dump request");
exit(1);
}
if (rtnl_dump_filter(&rth, store_nlmsg, &ainfo, NULL, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
}
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);
}
exit(0);
}
void
ProcessInterfaceWatchNotify(int s)
{
char buffer[4096];
struct iovec iov;
struct msghdr hdr;
struct nlmsghdr *nlhdr;
struct ifinfomsg *ifi;
struct ifaddrmsg *ifa;
int len;
struct rtattr *rth;
int rtl;
unsigned int ext_if_name_index = 0;
iov.iov_base = buffer;
iov.iov_len = sizeof(buffer);
memset(&hdr, 0, sizeof(hdr));
hdr.msg_iov = &iov;
hdr.msg_iovlen = 1;
len = recvmsg(s, &hdr, 0);
if (len < 0)
{
syslog(LOG_ERR, "recvmsg(s, &hdr, 0): %m");
return;
}
if(ext_if_name) {
ext_if_name_index = if_nametoindex(ext_if_name);
}
for (nlhdr = (struct nlmsghdr *) buffer;
NLMSG_OK (nlhdr, len);
nlhdr = NLMSG_NEXT (nlhdr, len))
{
if (nlhdr->nlmsg_type == NLMSG_DONE)
break;
switch(nlhdr->nlmsg_type) {
case RTM_DELLINK:
ifi = (struct ifinfomsg *) NLMSG_DATA(nlhdr);
/*if (ProcessInterfaceDown(ifi) < 0)
syslog(LOG_ERR, "ProcessInterfaceDown(ifi) failed");*/
break;
case RTM_NEWLINK:
ifi = (struct ifinfomsg *) NLMSG_DATA(nlhdr);
/*if (ProcessInterfaceUp(ifi) < 0)
syslog(LOG_ERR, "ProcessInterfaceUp(ifi) failed");*/
break;
case RTM_NEWADDR:
/* see /usr/include/linux/netlink.h
* and /usr/include/linux/rtnetlink.h */
ifa = (struct ifaddrmsg *) NLMSG_DATA(nlhdr);
syslog(LOG_DEBUG, "ProcessInterfaceWatchNotify RTM_NEWADDR");
for(rth = IFA_RTA(ifa), rtl = IFA_PAYLOAD(nlhdr);
rtl && RTA_OK(rth, rtl);
rth = RTA_NEXT(rth, rtl)) {
syslog(LOG_DEBUG, " - %u - %s type=%d",
ifa->ifa_index, inet_ntoa(*((struct in_addr *)RTA_DATA(rth))),
rth->rta_type);
}
if(ifa->ifa_index == ext_if_name_index) {
should_send_public_address_change_notif = 1;
}
break;
case RTM_DELADDR:
ifa = (struct ifaddrmsg *) NLMSG_DATA(nlhdr);
syslog(LOG_DEBUG, "ProcessInterfaceWatchNotify RTM_DELADDR");
if(ifa->ifa_index == ext_if_name_index) {
should_send_public_address_change_notif = 1;
}
break;
default:
syslog(LOG_DEBUG, "ProcessInterfaceWatchNotify type %d ignored", nlhdr->nlmsg_type);
}
}
}
/* Return value becomes exitcode. It's okay to not return at all */
int ipaddr_list_or_flush(int argc, char **argv, int flush)
{
static const char option[] ALIGN1 = "to\0""scope\0""up\0""label\0""dev\0";
struct nlmsg_list *linfo = NULL;
struct nlmsg_list *ainfo = NULL;
struct nlmsg_list *l;
struct rtnl_handle rth;
char *filter_dev = NULL;
int no_link = 0;
ipaddr_reset_filter(oneline);
filter.showqueue = 1;
if (filter.family == AF_UNSPEC)
filter.family = preferred_family;
if (flush) {
if (argc <= 0) {
bb_error_msg_and_die(bb_msg_requires_arg, "flush");
}
if (filter.family == AF_PACKET) {
bb_error_msg_and_die("cannot flush link addresses");
}
}
while (argc > 0) {
const int option_num = index_in_strings(option, *argv);
switch (option_num) {
case 0: /* to */
NEXT_ARG();
get_prefix(&filter.pfx, *argv, filter.family);
if (filter.family == AF_UNSPEC) {
filter.family = filter.pfx.family;
}
break;
case 1: /* scope */
{
uint32_t scope = 0;
NEXT_ARG();
filter.scopemask = -1;
if (rtnl_rtscope_a2n(&scope, *argv)) {
if (strcmp(*argv, "all") != 0) {
invarg(*argv, "scope");
}
scope = RT_SCOPE_NOWHERE;
filter.scopemask = 0;
}
filter.scope = scope;
break;
}
case 2: /* up */
filter.up = 1;
break;
case 3: /* label */
NEXT_ARG();
filter.label = *argv;
break;
case 4: /* dev */
NEXT_ARG();
default:
if (filter_dev) {
duparg2("dev", *argv);
}
filter_dev = *argv;
}
argv++;
argc--;
}
xrtnl_open(&rth);
xrtnl_wilddump_request(&rth, preferred_family, RTM_GETLINK);
xrtnl_dump_filter(&rth, store_nlmsg, &linfo);
if (filter_dev) {
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;
}
/** read a netlink message from the socket and create a new netlink event object **/
NetLinkManagerEvent::NetLinkManagerEvent(int fd)
: _type(EVENT_UNKOWN), _state(0), _wireless(false)
{
char buf[4096];
int len = 0;
struct nlmsghdr *nlh;
// cast netlink message
nlh = (struct nlmsghdr *) buf;
// get local reference to the attributes list
std::map<int, std::string> &attrlist = _attributes;
while ((len = recv(fd, nlh, 4096, 0)) > 0)
{
while ((NLMSG_OK(nlh, len)) && (nlh->nlmsg_type != NLMSG_DONE))
{
switch (nlh->nlmsg_type)
{
case RTM_BASE:
{
int attrlen, nlmsg_len, rta_len;
struct rtattr * attr;
struct ifinfomsg *ifi = (struct ifinfomsg *) NLMSG_DATA(nlh);
nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
attrlen = nlh->nlmsg_len - nlmsg_len;
if (attrlen < 0) break;
attr = (struct rtattr *) (((char *) ifi) + nlmsg_len);
rta_len = RTA_ALIGN(sizeof(struct rtattr));
while (RTA_OK(attr, attrlen))
{
size_t rta_length = RTA_PAYLOAD(attr);
switch (attr->rta_type)
{
case IFLA_IFNAME:
_interface = ibrcommon::vinterface( std::string((char*)RTA_DATA(attr), rta_length) );
_type = EVENT_LINK_STATE;
break;
case IFLA_OPERSTATE:
{
char s;
::memcpy(&s, (char*)RTA_DATA(attr), 1);
_state = s;
break;
}
case IFLA_WIRELESS:
_wireless = true;
break;
default:
attrlist[attr->rta_type] = std::string((char*)RTA_DATA(attr), rta_length);
break;
}
attr = RTA_NEXT(attr, attrlen);
}
break;
}
case 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);
_interface = ibrcommon::vinterface(name);
char address[256];
sprintf(address, "%d.%d.%d.%d", (ipaddr >> 24) & 0xff, (ipaddr >> 16) & 0xff, (ipaddr >> 8) & 0xff, ipaddr & 0xff);
_address = ibrcommon::vaddress(ibrcommon::vaddress::VADDRESS_INET, std::string(address));
_type = EVENT_ADDRESS_ADDED;
}
rth = RTA_NEXT(rth, rtl);
}
break;
}
case 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) {
uint32_t ipaddr = htonl(*((uint32_t *)RTA_DATA(rth)));
char name[IFNAMSIZ];
if_indextoname(ifa->ifa_index, name);
_interface = ibrcommon::vinterface(name);
char address[256];
sprintf(address, "%d.%d.%d.%d", (ipaddr >> 24) & 0xff, (ipaddr >> 16) & 0xff, (ipaddr >> 8) & 0xff, ipaddr & 0xff);
_address = ibrcommon::vaddress(ibrcommon::vaddress::VADDRESS_INET, std::string(address));
_type = EVENT_ADDRESS_REMOVED;
}
rth = RTA_NEXT(rth, rtl);
}
break;
}
default:
IBRCOMMON_LOGGER_DEBUG(10) << "unknown netlink type received: " << nlh->nlmsg_type << IBRCOMMON_LOGGER_ENDL;
break;
}
nlh = NLMSG_NEXT(nlh, len);
}
static void __handle_netlink_response(ifaddrs** out, nlmsghdr* hdr) {
if (hdr->nlmsg_type == RTM_NEWLINK) {
ifinfomsg* ifi = reinterpret_cast<ifinfomsg*>(NLMSG_DATA(hdr));
// Create a new ifaddr entry, and set the interface index and flags.
ifaddrs_storage* new_addr = new ifaddrs_storage(out);
new_addr->interface_index = ifi->ifi_index;
new_addr->ifa.ifa_flags = ifi->ifi_flags;
// Go through the various bits of information and find the name.
rtattr* rta = IFLA_RTA(ifi);
size_t rta_len = IFLA_PAYLOAD(hdr);
while (RTA_OK(rta, rta_len)) {
if (rta->rta_type == IFLA_ADDRESS) {
if (RTA_PAYLOAD(rta) < sizeof(new_addr->addr)) {
new_addr->SetAddress(AF_PACKET, RTA_DATA(rta), RTA_PAYLOAD(rta));
new_addr->SetPacketAttributes(ifi->ifi_index, ifi->ifi_type, RTA_PAYLOAD(rta));
}
} else if (rta->rta_type == IFLA_BROADCAST) {
if (RTA_PAYLOAD(rta) < sizeof(new_addr->ifa_ifu)) {
new_addr->SetBroadcastAddress(AF_PACKET, RTA_DATA(rta), RTA_PAYLOAD(rta));
new_addr->SetPacketAttributes(ifi->ifi_index, ifi->ifi_type, RTA_PAYLOAD(rta));
}
} else if (rta->rta_type == IFLA_IFNAME) {
if (RTA_PAYLOAD(rta) < sizeof(new_addr->name)) {
memcpy(new_addr->name, RTA_DATA(rta), RTA_PAYLOAD(rta));
new_addr->ifa.ifa_name = new_addr->name;
}
}
rta = RTA_NEXT(rta, rta_len);
}
} else if (hdr->nlmsg_type == RTM_NEWADDR) {
ifaddrmsg* msg = reinterpret_cast<ifaddrmsg*>(NLMSG_DATA(hdr));
// We should already know about this from an RTM_NEWLINK message.
const ifaddrs_storage* addr = reinterpret_cast<const ifaddrs_storage*>(*out);
while (addr != nullptr && addr->interface_index != static_cast<int>(msg->ifa_index)) {
addr = reinterpret_cast<const ifaddrs_storage*>(addr->ifa.ifa_next);
}
// If this is an unknown interface, ignore whatever we're being told about it.
if (addr == nullptr) return;
// Create a new ifaddr entry and copy what we already know.
ifaddrs_storage* new_addr = new ifaddrs_storage(out);
// We can just copy the name rather than look for IFA_LABEL.
strcpy(new_addr->name, addr->name);
new_addr->ifa.ifa_name = new_addr->name;
new_addr->ifa.ifa_flags = addr->ifa.ifa_flags;
new_addr->interface_index = addr->interface_index;
// Go through the various bits of information and find the address
// and any broadcast/destination address.
rtattr* rta = IFA_RTA(msg);
size_t rta_len = IFA_PAYLOAD(hdr);
while (RTA_OK(rta, rta_len)) {
if (rta->rta_type == IFA_ADDRESS) {
if (msg->ifa_family == AF_INET || msg->ifa_family == AF_INET6) {
new_addr->SetAddress(msg->ifa_family, RTA_DATA(rta), RTA_PAYLOAD(rta));
new_addr->SetNetmask(msg->ifa_family, msg->ifa_prefixlen);
}
} else if (rta->rta_type == IFA_BROADCAST) {
if (msg->ifa_family == AF_INET || msg->ifa_family == AF_INET6) {
new_addr->SetBroadcastAddress(msg->ifa_family, RTA_DATA(rta), RTA_PAYLOAD(rta));
}
}
rta = RTA_NEXT(rta, rta_len);
}
}
}
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;
}
}
/**
* Process the message and add/drop multicast membership if needed
*/
int
ProcessInterfaceWatch(int s, int s_ssdp, int s_ssdp6)
{
struct lan_addr_s * lan_addr;
ssize_t len;
char buffer[4096];
#ifdef __linux__
struct iovec iov;
struct msghdr hdr;
struct nlmsghdr *nlhdr;
struct ifaddrmsg *ifa;
struct rtattr *rta;
int ifa_len;
iov.iov_base = buffer;
iov.iov_len = sizeof(buffer);
memset(&hdr, 0, sizeof(hdr));
hdr.msg_iov = &iov;
hdr.msg_iovlen = 1;
len = recvmsg(s, &hdr, 0);
if(len < 0) {
syslog(LOG_ERR, "recvmsg(s, &hdr, 0): %m");
return -1;
}
for(nlhdr = (struct nlmsghdr *)buffer;
NLMSG_OK(nlhdr, len);
nlhdr = NLMSG_NEXT(nlhdr, len)) {
int is_del = 0;
char address[48];
char ifname[IFNAMSIZ];
address[0] = '\0';
ifname[0] = '\0';
if(nlhdr->nlmsg_type == NLMSG_DONE)
break;
switch(nlhdr->nlmsg_type) {
/* case RTM_NEWLINK: */
/* case RTM_DELLINK: */
case RTM_DELADDR:
is_del = 1;
case RTM_NEWADDR:
/* http://linux-hacks.blogspot.fr/2009/01/sample-code-to-learn-netlink.html */
ifa = (struct ifaddrmsg *)NLMSG_DATA(nlhdr);
rta = (struct rtattr *)IFA_RTA(ifa);
ifa_len = IFA_PAYLOAD(nlhdr);
syslog(LOG_DEBUG, "%s %s index=%d fam=%d prefixlen=%d flags=%d scope=%d",
"ProcessInterfaceWatchNotify", is_del ? "RTM_DELADDR" : "RTM_NEWADDR",
ifa->ifa_index, ifa->ifa_family, ifa->ifa_prefixlen,
ifa->ifa_flags, ifa->ifa_scope);
for(;RTA_OK(rta, ifa_len); rta = RTA_NEXT(rta, ifa_len)) {
/*RTA_DATA(rta)*/
/*rta_type : IFA_ADDRESS, IFA_LOCAL, etc. */
char tmp[128];
memset(tmp, 0, sizeof(tmp));
switch(rta->rta_type) {
case IFA_ADDRESS:
case IFA_LOCAL:
case IFA_BROADCAST:
case IFA_ANYCAST:
inet_ntop(ifa->ifa_family, RTA_DATA(rta), tmp, sizeof(tmp));
if(rta->rta_type == IFA_ADDRESS)
strncpy(address, tmp, sizeof(address));
break;
case IFA_LABEL:
strncpy(tmp, RTA_DATA(rta), sizeof(tmp));
strncpy(ifname, tmp, sizeof(ifname));
break;
case IFA_CACHEINFO:
{
struct ifa_cacheinfo *cache_info;
cache_info = RTA_DATA(rta);
snprintf(tmp, sizeof(tmp), "valid=%u prefered=%u",
cache_info->ifa_valid, cache_info->ifa_prefered);
}
break;
default:
strncpy(tmp, "*unknown*", sizeof(tmp));
}
syslog(LOG_DEBUG, " rta_len=%d rta_type=%d '%s'", rta->rta_len, rta->rta_type, tmp);
}
syslog(LOG_INFO, "%s: %s/%d %s",
is_del ? "RTM_DELADDR" : "RTM_NEWADDR",
address, ifa->ifa_prefixlen, ifname);
for(lan_addr = lan_addrs.lh_first; lan_addr != NULL; lan_addr = lan_addr->list.le_next) {
if((0 == strcmp(address, lan_addr->str)) ||
(0 == strcmp(ifname, lan_addr->ifname)) ||
(ifa->ifa_index == lan_addr->index)) {
if(ifa->ifa_family == AF_INET)
AddDropMulticastMembership(s_ssdp, lan_addr, 0, is_del);
else if(ifa->ifa_family == AF_INET6)
AddDropMulticastMembership(s_ssdp6, lan_addr, 1, is_del);
break;
}
}
break;
default:
syslog(LOG_DEBUG, "unknown nlmsg_type=%d", nlhdr->nlmsg_type);
}
}
#else /* __linux__ */
struct rt_msghdr * rtm;
struct ifa_msghdr * ifam;
int is_del = 0;
char tmp[64];
char * p;
struct sockaddr * sa;
int addr;
char address[48];
char ifname[IFNAMSIZ];
int family = AF_UNSPEC;
int prefixlen = 0;
address[0] = '\0';
ifname[0] = '\0';
len = recv(s, buffer, sizeof(buffer), 0);
if(len < 0) {
syslog(LOG_ERR, "%s recv: %m", "ProcessInterfaceWatchNotify");
return -1;
}
rtm = (struct rt_msghdr *)buffer;
switch(rtm->rtm_type) {
case RTM_DELADDR:
is_del = 1;
case RTM_NEWADDR:
ifam = (struct ifa_msghdr *)buffer;
syslog(LOG_DEBUG, "%s %s len=%d/%hu index=%hu addrs=%x flags=%x",
"ProcessInterfaceWatchNotify", is_del?"RTM_DELADDR":"RTM_NEWADDR",
(int)len, ifam->ifam_msglen,
ifam->ifam_index, ifam->ifam_addrs, ifam->ifam_flags);
p = buffer + sizeof(struct ifa_msghdr);
addr = 1;
while(p < buffer + len) {
sa = (struct sockaddr *)p;
while(!(addr & ifam->ifam_addrs) && (addr <= ifam->ifam_addrs))
addr = addr << 1;
sockaddr_to_string(sa, tmp, sizeof(tmp));
syslog(LOG_DEBUG, " %s", tmp);
switch(addr) {
case RTA_DST:
case RTA_GATEWAY:
break;
case RTA_NETMASK:
if(sa->sa_family == AF_INET
#if defined(__OpenBSD__)
|| (sa->sa_family == 0 &&
sa->sa_len <= sizeof(struct sockaddr_in))
#endif
) {
uint32_t sin_addr = ntohl(((struct sockaddr_in *)sa)->sin_addr.s_addr);
while((prefixlen < 32) &&
((sin_addr & (1 << (31 - prefixlen))) != 0))
prefixlen++;
} else if(sa->sa_family == AF_INET6
#if defined(__OpenBSD__)
|| (sa->sa_family == 0 &&
sa->sa_len == sizeof(struct sockaddr_in6))
#endif
) {
int i = 0;
uint8_t * q = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr;
while((*q == 0xff) && (i < 16)) {
prefixlen += 8;
q++; i++;
}
if(i < 16) {
i = 0;
while((i < 8) &&
((*q & (1 << (7 - i))) != 0))
i++;
prefixlen += i;
}
}
break;
case RTA_GENMASK:
break;
case RTA_IFP:
#ifdef AF_LINK
if(sa->sa_family == AF_LINK) {
struct sockaddr_dl * sdl = (struct sockaddr_dl *)sa;
memset(ifname, 0, sizeof(ifname));
memcpy(ifname, sdl->sdl_data, sdl->sdl_nlen);
}
#endif
break;
case RTA_IFA:
family = sa->sa_family;
if(sa->sa_family == AF_INET) {
inet_ntop(sa->sa_family,
&((struct sockaddr_in *)sa)->sin_addr,
address, sizeof(address));
} else if(sa->sa_family == AF_INET6) {
inet_ntop(sa->sa_family,
&((struct sockaddr_in6 *)sa)->sin6_addr,
address, sizeof(address));
}
break;
case RTA_AUTHOR:
break;
case RTA_BRD:
break;
}
#if 0
syslog(LOG_DEBUG, " %d.%d.%d.%d %02x%02x%02x%02x",
(uint8_t)p[0], (uint8_t)p[1], (uint8_t)p[2], (uint8_t)p[3],
(uint8_t)p[0], (uint8_t)p[1], (uint8_t)p[2], (uint8_t)p[3]);
syslog(LOG_DEBUG, " %d.%d.%d.%d %02x%02x%02x%02x",
(uint8_t)p[4], (uint8_t)p[5], (uint8_t)p[6], (uint8_t)p[7],
(uint8_t)p[4], (uint8_t)p[5], (uint8_t)p[6], (uint8_t)p[7]);
#endif
p += SA_RLEN(sa);
addr = addr << 1;
}
syslog(LOG_INFO, "%s: %s/%d %s",
is_del ? "RTM_DELADDR" : "RTM_NEWADDR",
address, prefixlen, ifname);
for(lan_addr = lan_addrs.lh_first; lan_addr != NULL; lan_addr = lan_addr->list.le_next) {
if((0 == strcmp(address, lan_addr->str)) ||
(0 == strcmp(ifname, lan_addr->ifname)) ||
(ifam->ifam_index == lan_addr->index)) {
if(family == AF_INET)
AddDropMulticastMembership(s_ssdp, lan_addr, 0, is_del);
else if(family == AF_INET6)
AddDropMulticastMembership(s_ssdp6, lan_addr, 1, is_del);
break;
}
}
break;
default:
syslog(LOG_DEBUG, "Unknown RTM message : rtm->rtm_type=%d len=%d",
rtm->rtm_type, (int)len);
}
#endif
return 0;
}