Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mkinitrd-magellan/busybox/networking/libiproute/ll_map.c

    Contents of /trunk/mkinitrd-magellan/busybox/networking/libiproute/ll_map.c

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 816 - (show annotations) (download)
    Fri Apr 24 18:33:46 2009 UTC (15 years, 1 month ago) by niro
    File MIME type: text/plain
    File size: 4212 byte(s) 
    -updated to busybox-1.13.4
    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) {
    176 struct ifreq ifr;
    177 int tmp;
    178
    179 strncpy(ifr.ifr_name, name, IFNAMSIZ);
    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 }