git.meshlink.io Git - catta/blob - iface.c

   1 #include <string.h>
   2 #include <sys/socket.h>
   3 #include <asm/types.h>
   4 #include <linux/netlink.h>
   5 #include <linux/rtnetlink.h>
   6 #include <errno.h>
   7
   8 #include "iface.h"
   9 #include "netlink.h"
  10
  11 typedef struct _interface_callback_info {
  12     void (*callback)(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterface *i, gpointer userdata);
  13     gpointer userdata;
  14     struct _interface_callback_info *next;
  15 } interface_callback_info;
  16
  17 typedef struct _address_callback_info {
  18     void (*callback)(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterfaceAddress *i, gpointer userdata);
  19     gpointer userdata;
  20     struct _address_callback_info *next;
  21 } address_callback_info;
  22
  23 struct _flxInterfaceMonitor {
  24     flxNetlink *netlink;
  25     GHashTable *hash_table;
  26     interface_callback_info *interface_callbacks;
  27     address_callback_info *address_callbacks;
  28     flxInterface *interfaces;
  29     guint query_addr_seq, query_link_seq;
  30     enum { LIST_IFACE, LIST_ADDR, LIST_DONE } list;
  31 };
  32
  33 static void run_interface_callbacks(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterface *i) {
  34     interface_callback_info *c;
  35     g_assert(m);
  36     g_assert(i);
  37
  38     for (c = m->interface_callbacks; c; c = c->next) {
  39         g_assert(c->callback);
  40         c->callback(m, change, i, c->userdata);
  41     }
  42 }
  43
  44 static void run_address_callbacks(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterfaceAddress *a) {
  45     address_callback_info *c;
  46     g_assert(m);
  47     g_assert(a);
  48
  49     for (c = m->address_callbacks; c; c = c->next) {
  50         g_assert(c->callback);
  51         c->callback(m, change, a, c->userdata);
  52     }
  53 }
  54
  55 static void free_address(flxInterfaceMonitor *m, flxInterfaceAddress *a) {
  56     g_assert(m);
  57     g_assert(a);
  58     g_assert(a->interface);
  59
  60     if (a->address.family == AF_INET)
  61         a->interface->n_ipv4_addrs --;
  62     else if (a->address.family == AF_INET6)
  63         a->interface->n_ipv6_addrs --;
  64
  65     if (a->prev)
  66         a->prev->next = a->next;
  67     else
  68         a->interface->addresses = a->next;
  69
  70     if (a->next)
  71         a->next->prev = a->prev;
  72
  73     g_free(a);
  74 }
  75
  76 static void free_interface(flxInterfaceMonitor *m, flxInterface *i) {
  77     g_assert(m);
  78     g_assert(i);
  79
  80     while (i->addresses)
  81         free_address(m, i->addresses);
  82
  83     g_assert(i->n_ipv6_addrs == 0);
  84     g_assert(i->n_ipv4_addrs == 0);
  85
  86     if (i->prev)
  87         i->prev->next = i->next;
  88     else
  89         m->interfaces = i->next;
  90
  91     if (i->next)
  92         i->next->prev = i->prev;
  93
  94     g_hash_table_remove(m->hash_table, &i->index);
  95
  96     g_free(i->name);
  97     g_free(i);
  98 }
  99
 100 static flxInterfaceAddress* get_address(flxInterfaceMonitor *m, flxInterface *i, const flxAddress *raddr) {
 101     flxInterfaceAddress *ia;
 102
 103     g_assert(m);
 104     g_assert(i);
 105     g_assert(raddr);
 106
 107     for (ia = i->addresses; ia; ia = ia->next) {
 108         if (flx_address_cmp(&ia->address, raddr) == 0)
 109             return ia;
 110     }
 111
 112     return NULL;
 113 }
 114
 115 static int netlink_list_items(flxNetlink *nl, guint16 type, guint *ret_seq) {
 116     struct nlmsghdr *n;
 117     struct rtgenmsg *gen;
 118     guint8 req[1024];
 119
 120     memset(&req, 0, sizeof(req));
 121     n = (struct nlmsghdr*) req;
 122     n->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
 123     n->nlmsg_type = type;
 124     n->nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
 125     n->nlmsg_pid = 0;
 126
 127     gen = NLMSG_DATA(n);
 128     memset(gen, 0, sizeof(struct rtgenmsg));
 129     gen->rtgen_family = AF_UNSPEC;
 130
 131     return flx_netlink_send(nl, n, ret_seq);
 132 }
 133
 134 static void callback(flxNetlink *nl, struct nlmsghdr *n, gpointer userdata) {
 135     flxInterfaceMonitor *m = userdata;
 136
 137     g_assert(m);
 138     g_assert(n);
 139     g_assert(m->netlink == nl);
 140
 141     if (n->nlmsg_type == RTM_NEWLINK) {
 142         struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
 143         flxInterface *i;
 144         struct rtattr *a = NULL;
 145         size_t l;
 146         int changed;
 147
 148         if (ifinfomsg->ifi_family != AF_UNSPEC)
 149             return;
 150
 151         if ((i = (flxInterface*) flx_interface_monitor_get_interface(m, ifinfomsg->ifi_index)))
 152             changed = 1;
 153         else {
 154             i = g_new(flxInterface, 1);
 155             i->name = NULL;
 156             i->index = ifinfomsg->ifi_index;
 157             i->addresses = NULL;
 158             i->n_ipv4_addrs = i->n_ipv6_addrs = 0;
 159             if ((i->next = m->interfaces))
 160                 i->next->prev = i;
 161             m->interfaces = i;
 162             i->prev = NULL;
 163             g_hash_table_insert(m->hash_table, &i->index, i);
 164             changed = 0;
 165         }
 166
 167         i->flags = ifinfomsg->ifi_flags;
 168
 169         l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
 170         a = IFLA_RTA(ifinfomsg);
 171
 172         while (RTA_OK(a, l)) {
 173             switch(a->rta_type) {
 174                 case IFLA_IFNAME:
 175                     g_free(i->name);
 176                     i->name = g_strndup(RTA_DATA(a), RTA_PAYLOAD(a));
 177                     break;
 178
 179                 default:
 180                     ;
 181             }
 182
 183             a = RTA_NEXT(a, l);
 184         }
 185
 186         run_interface_callbacks(m, changed ? FLX_INTERFACE_CHANGE : FLX_INTERFACE_NEW, i);
 187
 188     } else if (n->nlmsg_type == RTM_DELLINK) {
 189         struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
 190         flxInterface *i;
 191         flxInterfaceAddress *a;
 192
 193         if (ifinfomsg->ifi_family != AF_UNSPEC)
 194             return;
 195
 196         if (!(i = (flxInterface*) flx_interface_monitor_get_interface(m, ifinfomsg->ifi_index)))
 197             return;
 198
 199         for (a = i->addresses; a; a = a->next)
 200             run_address_callbacks(m, FLX_INTERFACE_REMOVE, a);
 201
 202         run_interface_callbacks(m, FLX_INTERFACE_REMOVE, i);
 203
 204         free_interface(m, i);
 205
 206     } else if (n->nlmsg_type == RTM_NEWADDR || n->nlmsg_type == RTM_DELADDR) {
 207
 208         struct ifaddrmsg *ifaddrmsg = NLMSG_DATA(n);
 209         flxInterface *i;
 210         struct rtattr *a = NULL;
 211         size_t l;
 212         int changed;
 213         flxAddress raddr;
 214         int raddr_valid = 0;
 215
 216         if (ifaddrmsg->ifa_family != AF_INET && ifaddrmsg->ifa_family != AF_INET6)
 217             return;
 218
 219         if (!(i = (flxInterface*) flx_interface_monitor_get_interface(m, ifaddrmsg->ifa_index)))
 220             return;
 221
 222         raddr.family = ifaddrmsg->ifa_family;
 223
 224         l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
 225         a = IFA_RTA(ifaddrmsg);
 226
 227         while (RTA_OK(a, l)) {
 228             switch(a->rta_type) {
 229                 case IFA_ADDRESS:
 230                     if ((raddr.family == AF_INET6 && RTA_PAYLOAD(a) != 16) ||
 231                         (raddr.family == AF_INET && RTA_PAYLOAD(a) != 4))
 232                         return;
 233
 234                     memcpy(raddr.data, RTA_DATA(a), RTA_PAYLOAD(a));
 235                     raddr_valid = 1;
 236
 237                     break;
 238
 239                 default:
 240                     ;
 241             }
 242
 243             a = RTA_NEXT(a, l);
 244         }
 245
 246
 247         if (!raddr_valid)
 248             return;
 249
 250         if (n->nlmsg_type == RTM_NEWADDR) {
 251             flxInterfaceAddress *addr;
 252
 253             if ((addr = get_address(m, i, &raddr)))
 254                 changed = 1;
 255             else {
 256                 addr = g_new(flxInterfaceAddress, 1);
 257                 addr->address = raddr;
 258
 259                 if (raddr.family == AF_INET)
 260                     i->n_ipv4_addrs++;
 261                 else if (raddr.family == AF_INET6)
 262                     i->n_ipv6_addrs++;
 263
 264                 addr->interface = i;
 265                 if ((addr->next = i->addresses))
 266                     addr->next->prev = addr;
 267                 i->addresses = addr;
 268                 addr->prev = NULL;
 269
 270                 changed = 0;
 271             }
 272
 273             addr->flags = ifaddrmsg->ifa_flags;
 274             addr->scope = ifaddrmsg->ifa_scope;
 275
 276             run_address_callbacks(m, changed ? FLX_INTERFACE_CHANGE : FLX_INTERFACE_NEW, addr);
 277         } else {
 278             flxInterfaceAddress *addr;
 279
 280             if (!(addr = get_address(m, i, &raddr)))
 281                 return;
 282
 283             run_address_callbacks(m, FLX_INTERFACE_REMOVE, addr);
 284             free_address(m, addr);
 285         }
 286
 287     } else if (n->nlmsg_type == NLMSG_DONE) {
 288
 289         if (m->list == LIST_IFACE) {
 290             m->list = LIST_DONE;
 291
 292             if (netlink_list_items(m->netlink, RTM_GETADDR, &m->query_addr_seq) < 0) {
 293                 g_warning("NETLINK: Failed to list addrs: %s", strerror(errno));
 294             } else
 295                 m->list = LIST_ADDR;
 296         } else
 297             m->list = LIST_DONE;
 298
 299     } else if (n->nlmsg_type == NLMSG_ERROR && (n->nlmsg_seq == m->query_link_seq || n->nlmsg_seq == m->query_addr_seq)) {
 300         struct nlmsgerr *e = NLMSG_DATA (n);
 301
 302         if (e->error)
 303             g_warning("NETLINK: Failed to browse: %s", strerror(-e->error));
 304     }
 305 }
 306
 307 flxInterfaceMonitor *flx_interface_monitor_new(GMainContext *c) {
 308     flxInterfaceMonitor *m = NULL;
 309
 310     m = g_new0(flxInterfaceMonitor, 1);
 311     if (!(m->netlink = flx_netlink_new(c, RTMGRP_LINK|RTMGRP_IPV4_IFADDR|RTMGRP_IPV6_IFADDR, callback, m)))
 312         goto fail;
 313
 314     m->hash_table = g_hash_table_new(g_int_hash, g_int_equal);
 315     m->interface_callbacks = NULL;
 316     m->address_callbacks = NULL;
 317     m->interfaces = NULL;
 318
 319     if (netlink_list_items(m->netlink, RTM_GETLINK, &m->query_link_seq) < 0)
 320         goto fail;
 321
 322     m->list = LIST_IFACE;
 323
 324     return m;
 325
 326 fail:
 327     flx_interface_monitor_free(m);
 328     return NULL;
 329 }
 330
 331 void flx_interface_monitor_free(flxInterfaceMonitor *m) {
 332     g_assert(m);
 333
 334     if (m->netlink)
 335         flx_netlink_free(m->netlink);
 336
 337     if (m->hash_table)
 338         g_hash_table_destroy(m->hash_table);
 339
 340     while (m->interface_callbacks) {
 341         interface_callback_info *c = m->interface_callbacks;
 342         m->interface_callbacks = c->next;
 343         g_free(c);
 344     }
 345
 346     while (m->address_callbacks) {
 347         address_callback_info *c = m->address_callbacks;
 348         m->address_callbacks = c->next;
 349         g_free(c);
 350     }
 351
 352     g_free(m);
 353 }
 354
 355
 356 const flxInterface* flx_interface_monitor_get_interface(flxInterfaceMonitor *m, gint index) {
 357     g_assert(m);
 358     g_assert(index > 0);
 359
 360     return g_hash_table_lookup(m->hash_table, &index);
 361 }
 362
 363 void flx_interface_monitor_add_interface_callback(
 364     flxInterfaceMonitor *m,
 365     void (*callback)(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterface *i, gpointer userdata),
 366     gpointer userdata) {
 367
 368     interface_callback_info *info;
 369
 370     g_assert(m);
 371     g_assert(callback);
 372
 373     info = g_new(interface_callback_info, 1);
 374     info->callback = callback;
 375     info->userdata = userdata;
 376     info->next = m->interface_callbacks;
 377     m->interface_callbacks = info;
 378 }
 379
 380 void flx_interface_monitor_remove_interface_callback(
 381     flxInterfaceMonitor *m,
 382     void (*callback)(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterface *i, gpointer userdata),
 383     gpointer userdata) {
 384
 385     interface_callback_info *info, *prev;
 386
 387     g_assert(m);
 388     g_assert(callback);
 389
 390     info = m->interface_callbacks;
 391     prev = NULL;
 392
 393     while (info) {
 394         if (info->callback == callback && info->userdata == userdata) {
 395             interface_callback_info *c = info;
 396
 397             if (prev)
 398                 prev->next = c->next;
 399             else
 400                 m->interface_callbacks = c->next;
 401
 402             info = c->next;
 403             g_free(c);
 404         } else {
 405             prev = info;
 406             info = info->next;
 407         }
 408     }
 409 }
 410
 411 void flx_interface_monitor_add_address_callback(
 412     flxInterfaceMonitor *m,
 413     void (*callback)(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterfaceAddress *a, gpointer userdata),
 414     gpointer userdata) {
 415
 416     address_callback_info *info;
 417
 418     g_assert(m);
 419     g_assert(callback);
 420
 421     info = g_new(address_callback_info, 1);
 422     info->callback = callback;
 423     info->userdata = userdata;
 424     info->next = m->address_callbacks;
 425     m->address_callbacks = info;
 426 }
 427
 428
 429 void flx_interface_monitor_remove_address_callback(
 430     flxInterfaceMonitor *m,
 431     void (*callback)(flxInterfaceMonitor *m, flxInterfaceChange change, const flxInterfaceAddress *a, gpointer userdata),
 432     gpointer userdata) {
 433
 434     address_callback_info *info, *prev;
 435
 436     g_assert(m);
 437     g_assert(callback);
 438
 439     info = m->address_callbacks;
 440     prev = NULL;
 441
 442     while (info) {
 443         if (info->callback == callback && info->userdata == userdata) {
 444             address_callback_info *c = info;
 445
 446             if (prev)
 447                 prev->next = c->next;
 448             else
 449                 m->address_callbacks = c->next;
 450
 451             info = c->next;
 452             g_free(c);
 453         } else {
 454             prev = info;
 455             info = info->next;
 456         }
 457     }
 458
 459 }
 460
 461 const flxInterface* flx_interface_monitor_get_first(flxInterfaceMonitor *m) {
 462     g_assert(m);
 463     return m->interfaces;
 464 }