package/swconfig/src/uci.c

   1 /*
   2  * uci.c: UCI binding for the switch configuration utility
   3  *
   4  * Copyright (C) 2009 Felix Fietkau <nbd@openwrt.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * version 2 as published by the Free Software Foundatio.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <inttypes.h>
  20 #include <errno.h>
  21 #include <stdint.h>
  22 #include <getopt.h>
  23 #include <sys/types.h>
  24 #include <sys/socket.h>
  25 #include <uci.h>
  26
  27 #include <linux/types.h>
  28 #include <linux/netlink.h>
  29 #include <linux/genetlink.h>
  30 #include <netlink/netlink.h>
  31 #include <netlink/genl/genl.h>
  32 #include <netlink/genl/ctrl.h>
  33 #include <linux/switch.h>
  34 #include "swlib.h"
  35
  36 #ifndef ARRAY_SIZE
  37 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
  38 #endif
  39
  40 struct swlib_setting {
  41         struct switch_attr *attr;
  42         const char *name;
  43         int port_vlan;
  44         const char *val;
  45         struct swlib_setting *next;
  46 };
  47
  48 struct swlib_setting early_settings[] = {
  49         { .name = "reset" },
  50         { .name = "enable_vlan" },
  51 };
  52
  53 static struct swlib_setting *settings;
  54 static struct swlib_setting **head;
  55
  56 static int
  57 swlib_map_settings(struct switch_dev *dev, int type, int port_vlan, struct uci_section *s)
  58 {
  59         struct swlib_setting *setting;
  60         struct switch_attr *attr;
  61         struct uci_element *e;
  62         struct uci_option *o;
  63         int i;
  64
  65         uci_foreach_element(&s->options, e) {
  66                 o = uci_to_option(e);
  67
  68                 if (o->type != UCI_TYPE_STRING)
  69                         continue;
  70
  71                 if (!strcmp(e->name, "device"))
  72                         continue;
  73
  74                 /* map early settings */
  75                 if (type == SWLIB_ATTR_GROUP_GLOBAL) {
  76                         int i;
  77
  78                         for (i = 0; i < ARRAY_SIZE(early_settings); i++) {
  79                                 if (strcmp(e->name, early_settings[i].name) != 0)
  80                                         continue;
  81
  82                                 early_settings[i].val = o->v.string;
  83                                 goto skip;
  84                         }
  85                 }
  86
  87                 attr = swlib_lookup_attr(dev, type, e->name);
  88                 if (!attr)
  89                         continue;
  90
  91                 setting = malloc(sizeof(struct swlib_setting));
  92                 memset(setting, 0, sizeof(struct swlib_setting));
  93                 setting->attr = attr;
  94                 setting->port_vlan = port_vlan;
  95                 setting->val = o->v.string;
  96                 *head = setting;
  97                 head = &setting->next;
  98 skip:
  99                 continue;
 100         }
 101 }
 102
 103 int swlib_apply_from_uci(struct switch_dev *dev, struct uci_package *p)
 104 {
 105         struct switch_attr *attr;
 106         struct uci_context *ctx = p->ctx;
 107         struct uci_element *e;
 108         struct uci_section *s;
 109         struct uci_option *o;
 110         struct switch_val val;
 111         int i;
 112
 113         settings = NULL;
 114         head = &settings;
 115
 116         uci_foreach_element(&p->sections, e) {
 117                 s = uci_to_section(e);
 118
 119                 if (strcmp(s->type, "switch") != 0)
 120                         continue;
 121
 122                 if (strcmp(e->name, dev->dev_name) != 0)
 123                         continue;
 124
 125                 goto found;
 126         }
 127
 128         /* not found */
 129         return -1;
 130
 131 found:
 132         /* look up available early options, which need to be taken care
 133          * of in the correct order */
 134         for (i = 0; i < ARRAY_SIZE(early_settings); i++) {
 135                 early_settings[i].attr = swlib_lookup_attr(dev,
 136                         SWLIB_ATTR_GROUP_GLOBAL, early_settings[i].name);
 137         }
 138         swlib_map_settings(dev, SWLIB_ATTR_GROUP_GLOBAL, 0, s);
 139
 140         /* look for port or vlan sections */
 141         uci_foreach_element(&p->sections, e) {
 142                 struct uci_element *os;
 143                 s = uci_to_section(e);
 144
 145                 if (!strcmp(s->type, "switch_port")) {
 146                         char *devn, *port, *port_err = NULL;
 147                         int port_n;
 148
 149                         uci_foreach_element(&s->options, os) {
 150                                 o = uci_to_option(os);
 151                                 if (o->type != UCI_TYPE_STRING)
 152                                         continue;
 153
 154                                 if (!strcmp(os->name, "device")) {
 155                                         devn = o->v.string;
 156                                         if (strcmp(devn, dev->dev_name) != 0)
 157                                                 devn = NULL;
 158                                 } else if (!strcmp(os->name, "port")) {
 159                                         port = o->v.string;
 160                                 }
 161                         }
 162                         if (!dev || !port || !port[0])
 163                                 continue;
 164
 165                         port_n = strtoul(port, &port_err, 0);
 166                         if (port_err && port_err[0])
 167                                 continue;
 168
 169                         swlib_map_settings(dev, SWLIB_ATTR_GROUP_PORT, port_n, s);
 170                 } else if (!strcmp(s->type, "switch_vlan")) {
 171                         char *devn, *vlan, *vlan_err = NULL;
 172                         int vlan_n;
 173
 174                         uci_foreach_element(&s->options, os) {
 175                                 o = uci_to_option(os);
 176                                 if (o->type != UCI_TYPE_STRING)
 177                                         continue;
 178
 179                                 if (!strcmp(os->name, "device")) {
 180                                         devn = o->v.string;
 181                                         if (strcmp(devn, dev->dev_name) != 0)
 182                                                 devn = NULL;
 183                                 } else if (!strcmp(os->name, "vlan")) {
 184                                         vlan = o->v.string;
 185                                 }
 186                         }
 187                         if (!dev || !vlan || !vlan[0])
 188                                 continue;
 189
 190                         vlan_n = strtoul(vlan, &vlan_err, 0);
 191                         if (vlan_err && vlan_err[0])
 192                                 continue;
 193
 194                         swlib_map_settings(dev, SWLIB_ATTR_GROUP_VLAN, vlan_n, s);
 195                 }
 196         }
 197
 198         for (i = 0; i < ARRAY_SIZE(early_settings); i++) {
 199                 struct swlib_setting *st = &early_settings[i];
 200                 if (!st->attr || !st->val)
 201                         continue;
 202                 swlib_set_attr_string(dev, st->attr, st->port_vlan, st->val);
 203
 204         }
 205
 206         while (settings) {
 207                 struct swlib_setting *st = settings;
 208
 209                 swlib_set_attr_string(dev, st->attr, st->port_vlan, st->val);
 210                 st = st->next;
 211                 free(settings);
 212                 settings = st;
 213         }
 214
 215         /* Apply the config */
 216         attr = swlib_lookup_attr(dev, SWLIB_ATTR_GROUP_GLOBAL, "apply");
 217         if (!attr)
 218                 return 0;
 219
 220         memset(&val, 0, sizeof(val));
 221         swlib_set_attr(dev, attr, &val);
 222
 223         return 0;
 224 }