ucimap-example.c

   1 /*
   2  * ucimap-example - sample code for the ucimap library
   3  * Copyright (C) 2008-2009 Felix Fietkau <nbd@openwrt.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14 #include <strings.h>
  15 #include <string.h>
  16 #include <stdlib.h>
  17 #include <unistd.h>
  18 #include <ucimap.h>
  19 #include "list.h"
  20
  21 struct list_head ifs;
  22
  23 struct uci_network {
  24         struct ucimap_section_data map;
  25         struct list_head list;
  26         struct list_head alias;
  27
  28         const char *name;
  29         const char *proto;
  30         const char *ifname;
  31         unsigned char *ipaddr;
  32         int test;
  33         bool enabled;
  34         struct ucimap_list *aliases;
  35 };
  36
  37 struct uci_alias {
  38         struct ucimap_section_data map;
  39         struct list_head list;
  40
  41         const char *name;
  42         struct uci_network *interface;
  43 };
  44
  45 static int
  46 network_parse_ip(void *section, struct uci_optmap *om, union ucimap_data *data, const char *str)
  47 {
  48         unsigned char *target;
  49         int tmp[4];
  50         int i;
  51
  52         if (sscanf(str, "%d.%d.%d.%d", &tmp[0], &tmp[1], &tmp[2], &tmp[3]) != 4)
  53                 return -1;
  54
  55         target = malloc(4);
  56         if (!target)
  57                 return -1;
  58
  59         data->ptr = target;
  60         for (i = 0; i < 4; i++)
  61                 target[i] = (char) tmp[i];
  62
  63         return 0;
  64 }
  65
  66 static int
  67 network_format_ip(void *section, struct uci_optmap *om, union ucimap_data *data, char **str)
  68 {
  69         static char buf[16];
  70         unsigned char *ip = (unsigned char *) data->ptr;
  71
  72         if (ip) {
  73                 sprintf(buf, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
  74                 *str = buf;
  75         } else {
  76                 *str = NULL;
  77         }
  78
  79         return 0;
  80 }
  81
  82 static void
  83 network_free_ip(void *section, struct uci_optmap *om, void *ptr)
  84 {
  85         free(ptr);
  86 }
  87
  88 static int
  89 network_init_interface(struct uci_map *map, void *section, struct uci_section *s)
  90 {
  91         struct uci_network *net = section;
  92
  93         INIT_LIST_HEAD(&net->list);
  94         INIT_LIST_HEAD(&net->alias);
  95         net->name = s->e.name;
  96         net->test = -1;
  97         return 0;
  98 }
  99
 100 static int
 101 network_init_alias(struct uci_map *map, void *section, struct uci_section *s)
 102 {
 103         struct uci_alias *alias = section;
 104
 105         INIT_LIST_HEAD(&alias->list);
 106         alias->name = s->e.name;
 107         return 0;
 108 }
 109
 110 static int
 111 network_add_interface(struct uci_map *map, void *section)
 112 {
 113         struct uci_network *net = section;
 114
 115         list_add_tail(&net->list, &ifs);
 116
 117         return 0;
 118 }
 119
 120 static int
 121 network_add_alias(struct uci_map *map, void *section)
 122 {
 123         struct uci_alias *a = section;
 124
 125         if (a->interface)
 126                 list_add_tail(&a->list, &a->interface->alias);
 127
 128         return 0;
 129 }
 130
 131 static struct ucimap_section_data *
 132 network_allocate(struct uci_map *map, struct uci_sectionmap *sm, struct uci_section *s)
 133 {
 134         struct uci_network *p = malloc(sizeof(struct uci_network));
 135         if (!p)
 136                 return NULL;
 137         memset(p, 0, sizeof(struct uci_network));
 138         return &p->map;
 139 }
 140
 141 struct my_optmap {
 142         struct uci_optmap map;
 143         int test;
 144 };
 145
 146 static struct uci_sectionmap network_interface;
 147 static struct uci_sectionmap network_alias;
 148
 149 static struct my_optmap network_interface_options[] = {
 150         {
 151                 .map = {
 152                         UCIMAP_OPTION(struct uci_network, proto),
 153                         .type = UCIMAP_STRING,
 154                         .name = "proto",
 155                         .data.s.maxlen = 32,
 156                 }
 157         },
 158         {
 159                 .map = {
 160                         UCIMAP_OPTION(struct uci_network, ifname),
 161                         .type = UCIMAP_STRING,
 162                         .name = "ifname"
 163                 }
 164         },
 165         {
 166                 .map = {
 167                         UCIMAP_OPTION(struct uci_network, ipaddr),
 168                         .type = UCIMAP_CUSTOM,
 169                         .name = "ipaddr",
 170                         .parse = network_parse_ip,
 171                         .format = network_format_ip,
 172                         .free = network_free_ip,
 173                 }
 174         },
 175         {
 176                 .map = {
 177                         UCIMAP_OPTION(struct uci_network, enabled),
 178                         .type = UCIMAP_BOOL,
 179                         .name = "enabled",
 180                 }
 181         },
 182         {
 183                 .map = {
 184                         UCIMAP_OPTION(struct uci_network, test),
 185                         .type = UCIMAP_INT,
 186                         .name = "test"
 187                 }
 188         },
 189         {
 190                 .map = {
 191                         UCIMAP_OPTION(struct uci_network, aliases),
 192                         .type = UCIMAP_LIST | UCIMAP_SECTION | UCIMAP_LIST_AUTO,
 193                         .data.sm = &network_alias
 194                 }
 195         }
 196 };
 197
 198 static struct uci_sectionmap network_interface = {
 199         UCIMAP_SECTION(struct uci_network, map),
 200         .type = "interface",
 201         .alloc = network_allocate,
 202         .init = network_init_interface,
 203         .add = network_add_interface,
 204         .options = &network_interface_options[0].map,
 205         .n_options = ARRAY_SIZE(network_interface_options),
 206         .options_size = sizeof(struct my_optmap)
 207 };
 208
 209 static struct uci_optmap network_alias_options[] = {
 210         {
 211                 UCIMAP_OPTION(struct uci_alias, interface),
 212                 .type = UCIMAP_SECTION,
 213                 .data.sm = &network_interface
 214         }
 215 };
 216
 217 static struct uci_sectionmap network_alias = {
 218         UCIMAP_SECTION(struct uci_alias, map),
 219         .type = "alias",
 220         .options = network_alias_options,
 221         .init = network_init_alias,
 222         .add = network_add_alias,
 223         .n_options = ARRAY_SIZE(network_alias_options),
 224 };
 225
 226 static struct uci_sectionmap *network_smap[] = {
 227         &network_interface,
 228         &network_alias,
 229 };
 230
 231 static struct uci_map network_map = {
 232         .sections = network_smap,
 233         .n_sections = ARRAY_SIZE(network_smap),
 234 };
 235
 236
 237 int main(int argc, char **argv)
 238 {
 239         struct uci_context *ctx;
 240         struct uci_package *pkg;
 241         struct list_head *p;
 242         struct uci_network *net;
 243         struct uci_alias *alias;
 244         bool set = false;
 245         int i;
 246
 247         INIT_LIST_HEAD(&ifs);
 248         ctx = uci_alloc_context();
 249         if (!ctx)
 250                 return -1;
 251         ucimap_init(&network_map);
 252
 253         if ((argc >= 2) && !strcmp(argv[1], "-s")) {
 254                 uci_set_savedir(ctx, "./test/save");
 255                 set = true;
 256         }
 257
 258         uci_set_confdir(ctx, "./test/config");
 259         uci_load(ctx, "network", &pkg);
 260
 261         ucimap_parse(&network_map, pkg);
 262
 263         list_for_each(p, &ifs) {
 264                 const unsigned char *ipaddr;
 265                 int n_aliases = 0;
 266
 267                 net = list_entry(p, struct uci_network, list);
 268                 ipaddr = net->ipaddr;
 269                 if (!ipaddr)
 270                         ipaddr = (const unsigned char *) "\x00\x00\x00\x00";
 271
 272                 printf("New network section '%s'\n"
 273                         "       type: %s\n"
 274                         "       ifname: %s\n"
 275                         "       ipaddr: %d.%d.%d.%d\n"
 276                         "       test: %d\n"
 277                         "       enabled: %s\n",
 278                         net->name,
 279                         net->proto,
 280                         net->ifname,
 281                         ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3],
 282                         net->test,
 283                         (net->enabled ? "on" : "off"));
 284
 285                 if (net->aliases->n_items > 0) {
 286                         printf("Configured aliases:");
 287                         for (i = 0; i < net->aliases->n_items; i++) {
 288                                 alias = net->aliases->item[i].ptr;
 289                                 printf(" %s", alias->name);
 290                         }
 291                         printf("\n");
 292                 }
 293                 list_for_each_entry(alias, &net->alias, list) {
 294                         n_aliases++;
 295                         for (i = 0; i < net->aliases->n_items; i++) {
 296                                 if (alias == net->aliases->item[i].ptr)
 297                                         goto next_alias;
 298                         }
 299                         printf("New alias: %s\n", alias->name);
 300 next_alias:
 301                         continue;
 302                 }
 303                 if (set && !strcmp(net->name, "lan")) {
 304                         ucimap_free_item(&net->map, &net->ipaddr);
 305                         ucimap_set_changed(&net->map, &net->ipaddr);
 306                         ucimap_resize_list(&net->map, &net->aliases, n_aliases);
 307                         net->aliases->n_items = 0;
 308                         list_for_each_entry(alias, &net->alias, list) {
 309                                 net->aliases->item[net->aliases->n_items++].ptr = alias;
 310                         }
 311                         ucimap_set_changed(&net->map, &net->aliases);
 312                         ucimap_store_section(&network_map, pkg, &net->map);
 313                         uci_save(ctx, pkg);
 314                 }
 315         }
 316
 317
 318         ucimap_cleanup(&network_map);
 319         uci_free_context(ctx);
 320
 321         return 0;
 322 }