release/src/router/busybox/networking/libiproute/ll_map.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * ll_map.c
   4  *
   5  *              This program is free software; you can redistribute it and/or
   6  *              modify it under the terms of the GNU General Public License
   7  *              as published by the Free Software Foundation; either version
   8  *              2 of the License, or (at your option) any later version.
   9  *
  10  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  11  *
  12  */
  13
  14 #include <net/if.h>     /* struct ifreq and co. */
  15
  16 #include "libbb.h"
  17 #include "libnetlink.h"
  18 #include "ll_map.h"
  19
  20 struct idxmap {
  21         struct idxmap *next;
  22         int            index;
  23         int            type;
  24         int            alen;
  25         unsigned       flags;
  26         unsigned char  addr[8];
  27         char           name[16];
  28 };
  29
  30 static struct idxmap *idxmap[16];
  31
  32 static struct idxmap *find_by_index(int idx)
  33 {
  34         struct idxmap *im;
  35
  36         for (im = idxmap[idx & 0xF]; im; im = im->next)
  37                 if (im->index == idx)
  38                         return im;
  39         return NULL;
  40 }
  41
  42 int ll_remember_index(const struct sockaddr_nl *who UNUSED_PARAM,
  43                 struct nlmsghdr *n,
  44                 void *arg UNUSED_PARAM)
  45 {
  46         int h;
  47         struct ifinfomsg *ifi = NLMSG_DATA(n);
  48         struct idxmap *im, **imp;
  49         struct rtattr *tb[IFLA_MAX+1];
  50
  51         if (n->nlmsg_type != RTM_NEWLINK)
  52                 return 0;
  53
  54         if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifi)))
  55                 return -1;
  56
  57         memset(tb, 0, sizeof(tb));
  58         parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));
  59         if (tb[IFLA_IFNAME] == NULL)
  60                 return 0;
  61
  62         h = ifi->ifi_index & 0xF;
  63
  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 *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 *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 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 xll_name_to_index(const char *const 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         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         /* We have not found the interface in our cache, but the kernel
 166          * may still know about it. One reason is that we may be using
 167          * module on-demand loading, which means that the kernel will
 168          * load the module and make the interface exist only when
 169          * we explicitely request it (check for dev_load() in net/core/dev.c).
 170          * I can think of other similar scenario, but they are less common...
 171          * Jean II */
 172 #endif
 173
 174         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 175         if (sock_fd >= 0) {
 176                 struct ifreq ifr;
 177                 int tmp;
 178
 179                 strncpy_IFNAMSIZ(ifr.ifr_name, name);
 180                 ifr.ifr_ifindex = -1;
 181                 tmp = ioctl(sock_fd, SIOCGIFINDEX, &ifr);
 182                 close(sock_fd);
 183                 if (tmp >= 0)
 184                         /* In theory, we should redump the interface list
 185                          * to update our cache, this is left as an exercise
 186                          * to the reader... Jean II */
 187                         ret = ifr.ifr_ifindex;
 188         }
 189 /* out:*/
 190         if (ret <= 0)
 191                 bb_error_msg_and_die("cannot find device \"%s\"", name);
 192         return ret;
 193 }
 194
 195 int ll_init_map(struct rtnl_handle *rth)
 196 {
 197         xrtnl_wilddump_request(rth, AF_UNSPEC, RTM_GETLINK);
 198         xrtnl_dump_filter(rth, ll_remember_index, &idxmap);
 199         return 0;
 200 }