ucimap.c

   1 /*
   2  * ucimap - library for mapping uci sections into data structures
   3  * Copyright (C) 2008 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 <stdbool.h>
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include "ucimap.h"
  20
  21 struct uci_alloc {
  22         enum ucimap_type type;
  23         union {
  24                 void **ptr;
  25         } data;
  26 };
  27
  28 struct uci_fixup {
  29         struct list_head list;
  30         struct uci_sectmap *sm;
  31         const char *name;
  32         enum ucimap_type type;
  33         union ucimap_data *data;
  34 };
  35
  36 struct uci_sectmap_data {
  37         struct list_head list;
  38         struct uci_map *map;
  39         struct uci_sectmap *sm;
  40         const char *section_name;
  41
  42         /* list of allocations done by ucimap */
  43         struct uci_alloc *allocmap;
  44         unsigned long allocmap_len;
  45
  46         /* map for changed fields */
  47         unsigned char *cmap;
  48         bool done;
  49 };
  50
  51
  52 #define ucimap_foreach_option(_sm, _o) \
  53         if (!(_sm)->options_size) \
  54                 (_sm)->options_size = sizeof(struct uci_optmap); \
  55         for (_o = &(_sm)->options[0]; \
  56                  ((char *)(_o)) < ((char *) &(_sm)->options[0] + \
  57                         (_sm)->options_size * (_sm)->n_options); \
  58                  _o = (struct uci_optmap *) ((char *)(_o) + \
  59                         (_sm)->options_size))
  60
  61
  62 static inline bool
  63 ucimap_is_alloc(enum ucimap_type type)
  64 {
  65         switch(type & UCIMAP_SUBTYPE) {
  66         case UCIMAP_STRING:
  67                 return true;
  68         default:
  69                 return false;
  70         }
  71 }
  72
  73 static inline bool
  74 ucimap_is_fixup(enum ucimap_type type)
  75 {
  76         switch(type & UCIMAP_SUBTYPE) {
  77         case UCIMAP_SECTION:
  78                 return true;
  79         default:
  80                 return false;
  81         }
  82 }
  83
  84 static inline bool
  85 ucimap_is_simple(enum ucimap_type type)
  86 {
  87         return ((type & UCIMAP_TYPE) == UCIMAP_SIMPLE);
  88 }
  89
  90 static inline bool
  91 ucimap_is_list(enum ucimap_type type)
  92 {
  93         return ((type & UCIMAP_TYPE) == UCIMAP_LIST);
  94 }
  95
  96 static inline union ucimap_data *
  97 ucimap_get_data(struct uci_sectmap_data *sd, struct uci_optmap *om)
  98 {
  99         void *data;
 100
 101         data = (char *) sd + sizeof(struct uci_sectmap_data) + om->offset;
 102         return data;
 103 }
 104
 105 int
 106 ucimap_init(struct uci_map *map)
 107 {
 108         INIT_LIST_HEAD(&map->sdata);
 109         INIT_LIST_HEAD(&map->fixup);
 110         return 0;
 111 }
 112
 113 static void
 114 ucimap_free_item(struct uci_alloc *a)
 115 {
 116         switch(a->type & UCIMAP_TYPE) {
 117         case UCIMAP_SIMPLE:
 118         case UCIMAP_LIST:
 119                 free(a->data.ptr);
 120                 break;
 121         }
 122 }
 123
 124 static void
 125 ucimap_add_alloc(struct uci_sectmap_data *sd, void *ptr)
 126 {
 127         struct uci_alloc *a = &sd->allocmap[sd->allocmap_len++];
 128         a->type = UCIMAP_SIMPLE;
 129         a->data.ptr = ptr;
 130 }
 131
 132 static void
 133 ucimap_free_section(struct uci_map *map, struct uci_sectmap_data *sd)
 134 {
 135         void *section = sd;
 136         int i;
 137
 138         section = (char *) section + sizeof(struct uci_sectmap_data);
 139         if (!list_empty(&sd->list))
 140                 list_del(&sd->list);
 141
 142         if (sd->sm->free)
 143                 sd->sm->free(map, section);
 144
 145         for (i = 0; i < sd->allocmap_len; i++) {
 146                 ucimap_free_item(&sd->allocmap[i]);
 147         }
 148
 149         free(sd->allocmap);
 150         free(sd);
 151 }
 152
 153 void
 154 ucimap_cleanup(struct uci_map *map)
 155 {
 156         struct list_head *ptr, *tmp;
 157
 158         list_for_each_safe(ptr, tmp, &map->sdata) {
 159                 struct uci_sectmap_data *sd = list_entry(ptr, struct uci_sectmap_data, list);
 160                 ucimap_free_section(map, sd);
 161         }
 162 }
 163
 164 static void
 165 ucimap_add_fixup(struct uci_map *map, union ucimap_data *data, struct uci_optmap *om, const char *str)
 166 {
 167         struct uci_fixup *f;
 168
 169         f = malloc(sizeof(struct uci_fixup));
 170         if (!f)
 171                 return;
 172
 173         INIT_LIST_HEAD(&f->list);
 174         f->sm = om->data.sm;
 175         f->name = str;
 176         f->type = om->type;
 177         f->data = data;
 178         list_add(&f->list, &map->fixup);
 179 }
 180
 181 static void
 182 ucimap_add_value(union ucimap_data *data, struct uci_optmap *om, struct uci_sectmap_data *sd, const char *str)
 183 {
 184         union ucimap_data *tdata = data;
 185         char *eptr = NULL;
 186         char *s;
 187         int val;
 188
 189         if (ucimap_is_list(om->type) && !ucimap_is_fixup(om->type))
 190                 tdata = &data->list->item[data->list->n_items++];
 191
 192         switch(om->type & UCIMAP_SUBTYPE) {
 193         case UCIMAP_STRING:
 194                 if ((om->data.s.maxlen > 0) &&
 195                         (strlen(str) > om->data.s.maxlen))
 196                         return;
 197
 198                 s = strdup(str);
 199                 tdata->s = s;
 200                 ucimap_add_alloc(sd, s);
 201                 break;
 202         case UCIMAP_BOOL:
 203                 val = -1;
 204                 if (strcmp(str, "on"))
 205                         val = true;
 206                 else if (strcmp(str, "1"))
 207                         val = true;
 208                 else if (strcmp(str, "enabled"))
 209                         val = true;
 210                 else if (strcmp(str, "off"))
 211                         val = false;
 212                 else if (strcmp(str, "0"))
 213                         val = false;
 214                 else if (strcmp(str, "disabled"))
 215                         val = false;
 216                 if (val == -1)
 217                         return;
 218
 219                 tdata->b = val;
 220                 break;
 221         case UCIMAP_INT:
 222                 val = strtol(str, &eptr, om->data.i.base);
 223                 if (!eptr || *eptr == '\0')
 224                         tdata->i = val;
 225                 else
 226                         return;
 227                 break;
 228         case UCIMAP_SECTION:
 229                 ucimap_add_fixup(sd->map, data, om, str);
 230                 break;
 231         }
 232 }
 233
 234
 235 static int
 236 ucimap_parse_options(struct uci_map *map, struct uci_sectmap *sm, struct uci_sectmap_data *sd, struct uci_section *s)
 237 {
 238         struct uci_element *e, *l;
 239         struct uci_option *o;
 240         union ucimap_data *data;
 241
 242         uci_foreach_element(&s->options, e) {
 243                 struct uci_optmap *om = NULL, *tmp;
 244
 245                 ucimap_foreach_option(sm, tmp) {
 246                         if (strcmp(e->name, tmp->name) == 0) {
 247                                 om = tmp;
 248                                 break;
 249                         }
 250                 }
 251                 if (!om)
 252                         continue;
 253
 254                 data = ucimap_get_data(sd, om);
 255                 o = uci_to_option(e);
 256                 if ((o->type == UCI_TYPE_STRING) && ucimap_is_simple(om->type)) {
 257                         ucimap_add_value(data, om, sd, o->v.string);
 258                 } else if ((o->type == UCI_TYPE_LIST) && ucimap_is_list(om->type)) {
 259                         uci_foreach_element(&o->v.list, l) {
 260                                 ucimap_add_value(data, om, sd, l->name);
 261                         }
 262                 }
 263         }
 264
 265         return 0;
 266 }
 267
 268
 269 static int
 270 ucimap_parse_section(struct uci_map *map, struct uci_sectmap *sm, struct uci_section *s)
 271 {
 272         struct uci_sectmap_data *sd = NULL;
 273         struct uci_optmap *om;
 274         char *section_name;
 275         void *section;
 276         int n_alloc = 2;
 277         int err;
 278
 279         sd = malloc(sm->alloc_len + sizeof(struct uci_sectmap_data));
 280         if (!sd)
 281                 return UCI_ERR_MEM;
 282
 283         memset(sd, 0, sm->alloc_len + sizeof(struct uci_sectmap_data));
 284         INIT_LIST_HEAD(&sd->list);
 285
 286         ucimap_foreach_option(sm, om) {
 287                 if (ucimap_is_list(om->type)) {
 288                         union ucimap_data *data;
 289                         struct uci_element *e;
 290                         int n_elements = 0;
 291                         int size;
 292
 293                         data = ucimap_get_data(sd, om);
 294                         uci_foreach_element(&s->options, e) {
 295                                 struct uci_option *o = uci_to_option(e);
 296                                 struct uci_element *tmp;
 297
 298                                 if (strcmp(e->name, om->name) != 0)
 299                                         continue;
 300
 301                                 uci_foreach_element(&o->v.list, tmp) {
 302                                         n_elements++;
 303                                 }
 304                                 break;
 305                         }
 306                         n_alloc += n_elements + 1;
 307                         size = sizeof(struct ucimap_list) +
 308                                 n_elements * sizeof(union ucimap_data);
 309                         data->list = malloc(size);
 310                         memset(data->list, 0, size);
 311                 } else if (ucimap_is_alloc(om->type)) {
 312                         n_alloc++;
 313                 }
 314         }
 315
 316         sd->map = map;
 317         sd->sm = sm;
 318         sd->allocmap = malloc(n_alloc * sizeof(struct uci_alloc));
 319         if (!sd->allocmap)
 320                 goto error_mem;
 321
 322         section_name = strdup(s->e.name);
 323         if (!section_name)
 324                 goto error_mem;
 325
 326         sd->section_name = section_name;
 327
 328         sd->cmap = malloc(BITFIELD_SIZE(sm->n_options));
 329         if (!sd->cmap)
 330                 goto error_mem;
 331
 332         memset(sd->cmap, 0, BITFIELD_SIZE(sm->n_options));
 333         ucimap_add_alloc(sd, (void *)section_name);
 334         ucimap_add_alloc(sd, (void *)sd->cmap);
 335         ucimap_foreach_option(sm, om) {
 336                 if (!ucimap_is_list(om->type))
 337                         continue;
 338
 339                 ucimap_add_alloc(sd, ucimap_get_data(sd, om)->list);
 340         }
 341
 342         section = (char *)sd + sizeof(struct uci_sectmap_data);
 343
 344         err = sm->init(map, section, s);
 345         if (err)
 346                 goto error;
 347
 348         list_add(&sd->list, &map->sdata);
 349         err = ucimap_parse_options(map, sm, sd, s);
 350         if (err)
 351                 goto error;
 352
 353         return 0;
 354
 355 error_mem:
 356         if (sd->allocmap)
 357                 free(sd->allocmap);
 358         free(sd);
 359         return UCI_ERR_MEM;
 360
 361 error:
 362         ucimap_free_section(map, sd);
 363         return err;
 364 }
 365
 366 static int
 367 ucimap_fill_ptr(struct uci_ptr *ptr, struct uci_section *s, const char *option)
 368 {
 369         struct uci_package *p = s->package;
 370
 371         memset(ptr, 0, sizeof(struct uci_ptr));
 372
 373         ptr->package = p->e.name;
 374         ptr->p = p;
 375
 376         ptr->section = s->e.name;
 377         ptr->s = s;
 378
 379         ptr->option = option;
 380         return uci_lookup_ptr(p->ctx, ptr, NULL, false);
 381 }
 382
 383 void
 384 ucimap_set_changed(void *section, void *field)
 385 {
 386         char *sptr = (char *)section - sizeof(struct uci_sectmap_data);
 387         struct uci_sectmap_data *sd = (struct uci_sectmap_data *) sptr;
 388         struct uci_sectmap *sm = sd->sm;
 389         struct uci_optmap *om;
 390         int ofs = (char *)field - (char *)section;
 391         int i = 0;
 392
 393         ucimap_foreach_option(sm, om) {
 394                 if (om->offset == ofs) {
 395                         SET_BIT(sd->cmap, i);
 396                         break;
 397                 }
 398                 i++;
 399         }
 400 }
 401
 402 int
 403 ucimap_store_section(struct uci_map *map, struct uci_package *p, void *section)
 404 {
 405         char *sptr = (char *)section - sizeof(struct uci_sectmap_data);
 406         struct uci_sectmap_data *sd = (struct uci_sectmap_data *) sptr;
 407         struct uci_sectmap *sm = sd->sm;
 408         struct uci_section *s = NULL;
 409         struct uci_optmap *om;
 410         struct uci_element *e;
 411         struct uci_ptr ptr;
 412         int i = 0;
 413         int ret;
 414
 415         uci_foreach_element(&p->sections, e) {
 416                 if (!strcmp(e->name, sd->section_name)) {
 417                         s = uci_to_section(e);
 418                         break;
 419                 }
 420         }
 421         if (!s)
 422                 return UCI_ERR_NOTFOUND;
 423
 424         ucimap_foreach_option(sm, om) {
 425                 union ucimap_data *data;
 426                 static char buf[32];
 427                 const char *str = NULL;
 428
 429                 if (ucimap_is_list(om->type))
 430                         continue;
 431
 432                 data = ucimap_get_data(sd, om);
 433                 if (!TEST_BIT(sd->cmap, i))
 434                         continue;
 435
 436                 ucimap_fill_ptr(&ptr, s, om->name);
 437                 switch(om->type & UCIMAP_SUBTYPE) {
 438                 case UCIMAP_STRING:
 439                         str = data->s;
 440                         break;
 441                 case UCIMAP_INT:
 442                         sprintf(buf, "%d", data->i);
 443                         str = buf;
 444                         break;
 445                 case UCIMAP_BOOL:
 446                         sprintf(buf, "%d", !!data->b);
 447                         str = buf;
 448                         break;
 449                 default:
 450                         continue;
 451                 }
 452                 ptr.value = str;
 453
 454                 ret = uci_set(s->package->ctx, &ptr);
 455                 if (ret)
 456                         return ret;
 457
 458                 CLR_BIT(sd->cmap, i);
 459                 i++;
 460         }
 461
 462         return 0;
 463 }
 464
 465 void *
 466 ucimap_find_section(struct uci_map *map, struct uci_fixup *f)
 467 {
 468         struct uci_sectmap_data *sd;
 469         struct list_head *p;
 470         void *ret;
 471
 472         list_for_each(p, &map->sdata) {
 473                 sd = list_entry(p, struct uci_sectmap_data, list);
 474                 if (sd->sm != f->sm)
 475                         continue;
 476                 if (strcmp(f->name, sd->section_name) != 0)
 477                         continue;
 478                 ret = (char *)sd + sizeof(struct uci_sectmap_data);
 479                 return ret;
 480         }
 481         return NULL;
 482 }
 483
 484 void
 485 ucimap_parse(struct uci_map *map, struct uci_package *pkg)
 486 {
 487         struct uci_element *e;
 488         struct list_head *p, *tmp;
 489         int i;
 490
 491         INIT_LIST_HEAD(&map->fixup);
 492         uci_foreach_element(&pkg->sections, e) {
 493                 struct uci_section *s = uci_to_section(e);
 494
 495                 for (i = 0; i < map->n_sections; i++) {
 496                         if (strcmp(s->type, map->sections[i]->type) != 0)
 497                                 continue;
 498                         ucimap_parse_section(map, map->sections[i], s);
 499                 }
 500         }
 501         list_for_each_safe(p, tmp, &map->fixup) {
 502                 struct uci_fixup *f = list_entry(p, struct uci_fixup, list);
 503                 void *ptr = ucimap_find_section(map, f);
 504                 struct ucimap_list *list;
 505
 506                 if (!ptr)
 507                         continue;
 508
 509                 switch(f->type & UCIMAP_TYPE) {
 510                 case UCIMAP_SIMPLE:
 511                         f->data->section = ptr;
 512                         break;
 513                 case UCIMAP_LIST:
 514                         list = f->data->list;
 515                         list->item[list->n_items++].section = ptr;
 516                         break;
 517                 }
 518                 free(f);
 519         }
 520         list_for_each_safe(p, tmp, &map->sdata) {
 521                 struct uci_sectmap_data *sd = list_entry(p, struct uci_sectmap_data, list);
 522                 void *section;
 523
 524                 if (sd->done)
 525                         continue;
 526
 527                 section = (char *) sd + sizeof(struct uci_sectmap_data);
 528                 if (sd->sm->add(map, section) != 0)
 529                         ucimap_free_section(map, sd);
 530         }
 531 }