networking/libiproute/ll_map.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License
   5  * as published by the Free Software Foundation; either version
   6  * 2 of the License, or (at your option) any later version.
   7  *
   8  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
   9  */
  10
  11 #include <net/if.h>  /* struct ifreq and co. */
  12
  13 #include "libbb.h"
  14 #include "libnetlink.h"
  15 #include "ll_map.h"
  16
  17 struct idxmap {
  18         struct idxmap *next;
  19         int            index;
  20         int            type;
  21         int            alen;
  22         unsigned       flags;
  23         unsigned char  addr[8];
  24         char           name[16];
  25 };
  26
  27 static struct idxmap **idxmap; /* treat as *idxmap[16] */
  28
  29 static struct idxmap *find_by_index(int idx)
  30 {
  31         struct idxmap *im;
  32
  33         if (idxmap)
  34                 for (im = idxmap[idx & 0xF]; im; im = im->next)
  35                         if (im->index == idx)
  36                                 return im;
  37         return NULL;
  38 }
  39
  40 int FAST_FUNC ll_remember_index(const struct sockaddr_nl *who UNUSED_PARAM,
  41                 struct nlmsghdr *n,
  42                 void *arg UNUSED_PARAM)
  43 {
  44         int h;
  45         struct ifinfomsg *ifi = NLMSG_DATA(n);
  46         struct idxmap *im, **imp;
  47         struct rtattr *tb[IFLA_MAX+1];
  48
  49         if (n->nlmsg_type != RTM_NEWLINK)
  50                 return 0;
  51
  52         if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifi)))
  53                 return -1;
  54
  55         memset(tb, 0, sizeof(tb));
  56         parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));
  57         if (tb[IFLA_IFNAME] == NULL)
  58                 return 0;
  59
  60         if (!idxmap)
  61                 idxmap = xzalloc(sizeof(idxmap[0]) * 16);
  62
  63         h = ifi->ifi_index & 0xF;
  64         for (imp = &idxmap[h]; (im = *imp) != NULL; imp = &im->next)
  65                 if (im->index == ifi->ifi_index)
  66                         goto found;
  67
  68         im = xmalloc(sizeof(*im));
  69         im->next = *imp;
  70         im->index = ifi->ifi_index;
  71         *imp = im;
  72  found:
  73         im->type = ifi->ifi_type;
  74         im->flags = ifi->ifi_flags;
  75         if (tb[IFLA_ADDRESS]) {
  76                 int alen;
  77                 im->alen = alen = RTA_PAYLOAD(tb[IFLA_ADDRESS]);
  78                 if (alen > (int)sizeof(im->addr))
  79                         alen = sizeof(im->addr);
  80                 memcpy(im->addr, RTA_DATA(tb[IFLA_ADDRESS]), alen);
  81         } else {
  82                 im->alen = 0;
  83                 memset(im->addr, 0, sizeof(im->addr));
  84         }
  85         strcpy(im->name, RTA_DATA(tb[IFLA_IFNAME]));
  86         return 0;
  87 }
  88
  89 const char FAST_FUNC *ll_idx_n2a(int idx, char *buf)
  90 {
  91         struct idxmap *im;
  92
  93         if (idx == 0)
  94                 return "*";
  95         im = find_by_index(idx);
  96         if (im)
  97                 return im->name;
  98         snprintf(buf, 16, "if%d", idx);
  99         return buf;
 100 }
 101
 102 const char FAST_FUNC *ll_index_to_name(int idx)
 103 {
 104         static char nbuf[16];
 105
 106         return ll_idx_n2a(idx, nbuf);
 107 }
 108
 109 #ifdef UNUSED
 110 int ll_index_to_type(int idx)
 111 {
 112         struct idxmap *im;
 113
 114         if (idx == 0)
 115                 return -1;
 116         im = find_by_index(idx);
 117         if (im)
 118                 return im->type;
 119         return -1;
 120 }
 121 #endif
 122
 123 unsigned FAST_FUNC ll_index_to_flags(int idx)
 124 {
 125         struct idxmap *im;
 126
 127         if (idx == 0)
 128                 return 0;
 129         im = find_by_index(idx);
 130         if (im)
 131                 return im->flags;
 132         return 0;
 133 }
 134
 135 int FAST_FUNC xll_name_to_index(const char *name)
 136 {
 137         int ret = 0;
 138         int sock_fd;
 139
 140 /* caching is not warranted - no users which repeatedly call it */
 141 #ifdef UNUSED
 142         static char ncache[16];
 143         static int icache;
 144
 145         struct idxmap *im;
 146         int i;
 147
 148         if (name == NULL)
 149                 goto out;
 150         if (icache && strcmp(name, ncache) == 0) {
 151                 ret = icache;
 152                 goto out;
 153         }
 154         if (idxmap) {
 155                 for (i = 0; i < 16; i++) {
 156                         for (im = idxmap[i]; im; im = im->next) {
 157                                 if (strcmp(im->name, name) == 0) {
 158                                         icache = im->index;
 159                                         strcpy(ncache, name);
 160                                         ret = im->index;
 161                                         goto out;
 162                                 }
 163                         }
 164                 }
 165         }
 166         /* We have not found the interface in our cache, but the kernel
 167          * may still know about it. One reason is that we may be using
 168          * module on-demand loading, which means that the kernel will
 169          * load the module and make the interface exist only when
 170          * we explicitely request it (check for dev_load() in net/core/dev.c).
 171          * I can think of other similar scenario, but they are less common...
 172          * Jean II */
 173 #endif
 174
 175         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 176         if (sock_fd >= 0) {
 177                 struct ifreq ifr;
 178                 int tmp;
 179
 180                 strncpy_IFNAMSIZ(ifr.ifr_name, name);
 181                 ifr.ifr_ifindex = -1;
 182                 tmp = ioctl(sock_fd, SIOCGIFINDEX, &ifr);
 183                 close(sock_fd);
 184                 if (tmp >= 0)
 185                         /* In theory, we should redump the interface list
 186                          * to update our cache, this is left as an exercise
 187                          * to the reader... Jean II */
 188                         ret = ifr.ifr_ifindex;
 189         }
 190 /* out:*/
 191         if (ret <= 0)
 192                 bb_error_msg_and_die("can't find device '%s'", name);
 193         return ret;
 194 }
 195
 196 int FAST_FUNC ll_init_map(struct rtnl_handle *rth)
 197 {
 198         xrtnl_wilddump_request(rth, AF_UNSPEC, RTM_GETLINK);
 199         xrtnl_dump_filter(rth, ll_remember_index, NULL);
 200         return 0;
 201 }