networking/libiproute/rt_names.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * rt_names.c           rtnetlink names DB.
   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 #include "libbb.h"
  13 #include "rt_names.h"
  14
  15 typedef struct rtnl_tab_t {
  16         const char *cached_str;
  17         unsigned cached_result;
  18         const char *tab[256];
  19 } rtnl_tab_t;
  20
  21 static void rtnl_tab_initialize(const char *file, const char **tab)
  22 {
  23         char *token[2];
  24         parser_t *parser = config_open2(file, fopen_for_read);
  25
  26         while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL)) {
  27                 unsigned id = bb_strtou(token[0], NULL, 0);
  28                 if (id > 256) {
  29                         bb_error_msg("database %s is corrupted at line %d",
  30                                 file, parser->lineno);
  31                         break;
  32                 }
  33                 tab[id] = xstrdup(token[1]);
  34         }
  35         config_close(parser);
  36 }
  37
  38 static int rtnl_a2n(rtnl_tab_t *tab, uint32_t *id, const char *arg, int base)
  39 {
  40         unsigned i;
  41
  42         if (tab->cached_str && strcmp(tab->cached_str, arg) == 0) {
  43                 *id = tab->cached_result;
  44                 return 0;
  45         }
  46
  47         for (i = 0; i < 256; i++) {
  48                 if (tab->tab[i]
  49                  && strcmp(tab->tab[i], arg) == 0
  50                 ) {
  51                         tab->cached_str = tab->tab[i];
  52                         tab->cached_result = i;
  53                         *id = i;
  54                         return 0;
  55                 }
  56         }
  57
  58         i = bb_strtou(arg, NULL, base);
  59         if (i > 255)
  60                 return -1;
  61         *id = i;
  62         return 0;
  63 }
  64
  65
  66 static rtnl_tab_t *rtnl_rtprot_tab;
  67
  68 static void rtnl_rtprot_initialize(void)
  69 {
  70         static const char *const init_tab[] = {
  71                 "none",
  72                 "redirect",
  73                 "kernel",
  74                 "boot",
  75                 "static",
  76                 NULL,
  77                 NULL,
  78                 NULL,
  79                 "gated",
  80                 "ra",
  81                 "mrt",
  82                 "zebra",
  83                 "bird",
  84         };
  85
  86         if (rtnl_rtprot_tab)
  87                 return;
  88         rtnl_rtprot_tab = xzalloc(sizeof(*rtnl_rtprot_tab));
  89         memcpy(rtnl_rtprot_tab->tab, init_tab, sizeof(init_tab));
  90         rtnl_tab_initialize("/etc/iproute2/rt_protos", rtnl_rtprot_tab->tab);
  91 }
  92
  93 const char* rtnl_rtprot_n2a(int id, char *buf, int len)
  94 {
  95         if (id < 0 || id >= 256) {
  96                 snprintf(buf, len, "%d", id);
  97                 return buf;
  98         }
  99
 100         rtnl_rtprot_initialize();
 101
 102         if (rtnl_rtprot_tab->tab[id])
 103                 return rtnl_rtprot_tab->tab[id];
 104         snprintf(buf, len, "%d", id);
 105         return buf;
 106 }
 107
 108 int rtnl_rtprot_a2n(uint32_t *id, char *arg)
 109 {
 110         rtnl_rtprot_initialize();
 111         return rtnl_a2n(rtnl_rtprot_tab, id, arg, 0);
 112 }
 113
 114
 115 static rtnl_tab_t *rtnl_rtscope_tab;
 116
 117 static void rtnl_rtscope_initialize(void)
 118 {
 119         if (rtnl_rtscope_tab)
 120                 return;
 121         rtnl_rtscope_tab = xzalloc(sizeof(*rtnl_rtscope_tab));
 122         rtnl_rtscope_tab->tab[0] = "global";
 123         rtnl_rtscope_tab->tab[255] = "nowhere";
 124         rtnl_rtscope_tab->tab[254] = "host";
 125         rtnl_rtscope_tab->tab[253] = "link";
 126         rtnl_rtscope_tab->tab[200] = "site";
 127         rtnl_tab_initialize("/etc/iproute2/rt_scopes", rtnl_rtscope_tab->tab);
 128 }
 129
 130 const char* rtnl_rtscope_n2a(int id, char *buf, int len)
 131 {
 132         if (id < 0 || id >= 256) {
 133                 snprintf(buf, len, "%d", id);
 134                 return buf;
 135         }
 136
 137         rtnl_rtscope_initialize();
 138
 139         if (rtnl_rtscope_tab->tab[id])
 140                 return rtnl_rtscope_tab->tab[id];
 141         snprintf(buf, len, "%d", id);
 142         return buf;
 143 }
 144
 145 int rtnl_rtscope_a2n(uint32_t *id, char *arg)
 146 {
 147         rtnl_rtscope_initialize();
 148         return rtnl_a2n(rtnl_rtscope_tab, id, arg, 0);
 149 }
 150
 151
 152 static rtnl_tab_t *rtnl_rtrealm_tab;
 153
 154 static void rtnl_rtrealm_initialize(void)
 155 {
 156         if (rtnl_rtrealm_tab) return;
 157         rtnl_rtrealm_tab = xzalloc(sizeof(*rtnl_rtrealm_tab));
 158         rtnl_rtrealm_tab->tab[0] = "unknown";
 159         rtnl_tab_initialize("/etc/iproute2/rt_realms", rtnl_rtrealm_tab->tab);
 160 }
 161
 162 int rtnl_rtrealm_a2n(uint32_t *id, char *arg)
 163 {
 164         rtnl_rtrealm_initialize();
 165         return rtnl_a2n(rtnl_rtrealm_tab, id, arg, 0);
 166 }
 167
 168 #if ENABLE_FEATURE_IP_RULE
 169 const char* rtnl_rtrealm_n2a(int id, char *buf, int len)
 170 {
 171         if (id < 0 || id >= 256) {
 172                 snprintf(buf, len, "%d", id);
 173                 return buf;
 174         }
 175
 176         rtnl_rtrealm_initialize();
 177
 178         if (rtnl_rtrealm_tab->tab[id])
 179                 return rtnl_rtrealm_tab->tab[id];
 180         snprintf(buf, len, "%d", id);
 181         return buf;
 182 }
 183 #endif
 184
 185
 186 static rtnl_tab_t *rtnl_rtdsfield_tab;
 187
 188 static void rtnl_rtdsfield_initialize(void)
 189 {
 190         if (rtnl_rtdsfield_tab) return;
 191         rtnl_rtdsfield_tab = xzalloc(sizeof(*rtnl_rtdsfield_tab));
 192         rtnl_rtdsfield_tab->tab[0] = "0";
 193         rtnl_tab_initialize("/etc/iproute2/rt_dsfield", rtnl_rtdsfield_tab->tab);
 194 }
 195
 196 const char * rtnl_dsfield_n2a(int id, char *buf, int len)
 197 {
 198         if (id < 0 || id >= 256) {
 199                 snprintf(buf, len, "%d", id);
 200                 return buf;
 201         }
 202
 203         rtnl_rtdsfield_initialize();
 204
 205         if (rtnl_rtdsfield_tab->tab[id])
 206                 return rtnl_rtdsfield_tab->tab[id];
 207         snprintf(buf, len, "0x%02x", id);
 208         return buf;
 209 }
 210
 211 int rtnl_dsfield_a2n(uint32_t *id, char *arg)
 212 {
 213         rtnl_rtdsfield_initialize();
 214         return rtnl_a2n(rtnl_rtdsfield_tab, id, arg, 16);
 215 }
 216
 217
 218 #if ENABLE_FEATURE_IP_RULE
 219 static rtnl_tab_t *rtnl_rttable_tab;
 220
 221 static void rtnl_rttable_initialize(void)
 222 {
 223         if (rtnl_rtdsfield_tab) return;
 224         rtnl_rttable_tab = xzalloc(sizeof(*rtnl_rttable_tab));
 225         rtnl_rttable_tab->tab[0] = "unspec";
 226         rtnl_rttable_tab->tab[255] = "local";
 227         rtnl_rttable_tab->tab[254] = "main";
 228         rtnl_rttable_tab->tab[253] = "default";
 229         rtnl_tab_initialize("/etc/iproute2/rt_tables", rtnl_rttable_tab->tab);
 230 }
 231
 232 const char *rtnl_rttable_n2a(int id, char *buf, int len)
 233 {
 234         if (id < 0 || id >= 256) {
 235                 snprintf(buf, len, "%d", id);
 236                 return buf;
 237         }
 238
 239         rtnl_rttable_initialize();
 240
 241         if (rtnl_rttable_tab->tab[id])
 242                 return rtnl_rttable_tab->tab[id];
 243         snprintf(buf, len, "%d", id);
 244         return buf;
 245 }
 246
 247 int rtnl_rttable_a2n(uint32_t *id, char *arg)
 248 {
 249         rtnl_rttable_initialize();
 250         return rtnl_a2n(rtnl_rttable_tab, id, arg, 0);
 251 }
 252
 253 #endif