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
 103 const char FAST_FUNC *ll_index_to_name(int idx)
 104 {
 105         static char nbuf[16];
 106
 107         return ll_idx_n2a(idx, nbuf);
 108 }
 109
 110 #ifdef UNUSED
 111 int ll_index_to_type(int idx)
 112 {
 113         struct idxmap *im;
 114
 115         if (idx == 0)
 116                 return -1;
 117         im = find_by_index(idx);
 118         if (im)
 119                 return im->type;
 120         return -1;
 121 }
 122 #endif
 123
 124 unsigned FAST_FUNC ll_index_to_flags(int idx)
 125 {
 126         struct idxmap *im;
 127
 128         if (idx == 0)
 129                 return 0;
 130         im = find_by_index(idx);
 131         if (im)
 132                 return im->flags;
 133         return 0;
 134 }
 135
 136 int FAST_FUNC xll_name_to_index(const char *name)
 137 {
 138         int ret = 0;
 139         int sock_fd;
 140
 141 /* caching is not warranted - no users which repeatedly call it */
 142 #ifdef UNUSED
 143         static char ncache[16];
 144         static int icache;
 145
 146         struct idxmap *im;
 147         int i;
 148
 149         if (name == NULL)
 150                 goto out;
 151         if (icache && strcmp(name, ncache) == 0) {
 152                 ret = icache;
 153                 goto out;
 154         }
 155         if (idxmap) {
 156                 for (i = 0; i < 16; i++) {
 157                         for (im = idxmap[i]; im; im = im->next) {
 158                                 if (strcmp(im->name, name) == 0) {
 159                                         icache = im->index;
 160                                         strcpy(ncache, name);
 161                                         ret = im->index;
 162                                         goto out;
 163                                 }
 164                         }
 165                 }
 166         }
 167         /* We have not found the interface in our cache, but the kernel
 168          * may still know about it. One reason is that we may be using
 169          * module on-demand loading, which means that the kernel will
 170          * load the module and make the interface exist only when
 171          * we explicitely request it (check for dev_load() in net/core/dev.c).
 172          * I can think of other similar scenario, but they are less common...
 173          * Jean II */
 174 #endif
 175
 176         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 177         if (sock_fd >= 0) {
 178                 struct ifreq ifr;
 179                 int tmp;
 180
 181                 strncpy_IFNAMSIZ(ifr.ifr_name, name);
 182                 ifr.ifr_ifindex = -1;
 183                 tmp = ioctl(sock_fd, SIOCGIFINDEX, &ifr);
 184                 close(sock_fd);
 185                 if (tmp >= 0)
 186                         /* In theory, we should redump the interface list
 187                          * to update our cache, this is left as an exercise
 188                          * to the reader... Jean II */
 189                         ret = ifr.ifr_ifindex;
 190         }
 191 /* out:*/
 192         if (ret <= 0)
 193                 bb_error_msg_and_die("can't find device '%s'", name);
 194         return ret;
 195 }
 196
 197 int FAST_FUNC ll_init_map(struct rtnl_handle *rth)
 198 {
 199         xrtnl_wilddump_request(rth, AF_UNSPEC, RTM_GETLINK);
 200         xrtnl_dump_filter(rth, ll_remember_index, NULL);
 201         return 0;
 202 }