src/genconf/confnode.c

   1 /*
   2  * Copyright (c) 2010, Olivier MATZ <zer0@droids-corp.org>
   3  * All rights reserved.
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  *     * Redistributions of source code must retain the above copyright
   8  *       notice, this list of conditions and the following disclaimer.
   9  *     * Redistributions in binary form must reproduce the above copyright
  10  *       notice, this list of conditions and the following disclaimer in the
  11  *       documentation and/or other materials provided with the distribution.
  12  *     * Neither the name of the University of California, Berkeley nor the
  13  *       names of its contributors may be used to endorse or promote products
  14  *       derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
  20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <sys/queue.h>
  32
  33 #include "strictmalloc.h"
  34 #include "parser_common.h"
  35 #include "expression.h"
  36 #include "conf_parser.h"
  37 #include "confnode.h"
  38
  39 extern void confnode_root_register(void);
  40 extern void confnode_menu_register(void);
  41 extern void confnode_config_register(void);
  42 extern void confnode_intconfig_register(void);
  43 extern void confnode_menuconfig_register(void);
  44 extern void confnode_strconfig_register(void);
  45 extern void confnode_choice_register(void);
  46 extern void confnode_choiceconfig_register(void);
  47 extern void confnode_if_register(void);
  48 extern void confnode_comment_register(void);
  49
  50 /* global list of all configuration node types */
  51 struct confnode_type_list confnode_type_list;
  52
  53 /* alloc a new confnode */
  54 static struct confnode *confnode_alloc(void)
  55 {
  56         struct confnode *n;
  57
  58         n = strictmalloc(sizeof(struct confnode));
  59         TAILQ_INIT(&n->children);
  60         TAILQ_INIT(&n->depend);
  61         snprintf(n->name, sizeof(n->name), "NONAME");
  62         snprintf(n->name, sizeof(n->name), "No prompt");
  63         snprintf(n->help, sizeof(n->help), "No help available\n");
  64
  65         return n;
  66 }
  67
  68 /* alloc a new root node */
  69 struct confnode *confnode_new_root(void)
  70 {
  71         struct line l;
  72         struct token t;
  73
  74         /* forge a dummy line */
  75         t.str = "root";
  76         t.offset = 0;
  77         l.start_with_space = 0;
  78         l.n_token = 1;
  79         TAILQ_INIT(&l.token_list);
  80         TAILQ_INSERT_TAIL(&l.token_list, &t, next);
  81
  82         return confnode_new(&l);
  83 }
  84
  85 /* Parse the line, and return a new confnode if the line is a valid
  86  * new confnode line (example: "menuconfig FOO\n"). Else, return
  87  * NULL. */
  88 struct confnode *confnode_new(const struct line *line)
  89 {
  90         struct confnode_type *cnt;
  91         struct confnode *n;
  92
  93         n = confnode_alloc();
  94
  95         TAILQ_FOREACH(cnt, &confnode_type_list, next) {
  96                 if (cnt->ops.new == NULL) {
  97                         printf("No new() for confnode type\n");
  98                         exit(1);
  99                 }
 100                 if (cnt->ops.new(n, line) == 0)
 101                         return n;
 102         }
 103
 104         /* fail */
 105         free(n);
 106         return NULL;
 107 }
 108
 109 /* Free the node given as argument, and all its associated data */
 110 void confnode_free(struct confnode *n)
 111 {
 112         struct expr_node *e;
 113
 114         /* specific free */
 115         if (n->ops->free) {
 116                 n->ops->free(n);
 117                 return;
 118         }
 119
 120         while ( (e = TAILQ_FIRST(&n->depend)) ) {
 121                 expression_free(e);
 122         }
 123         free(n);
 124 }
 125
 126 /* Parse a line structure (and its associated line buffer) to match an
 127  * attribute of a confnode. Return 0 if the line matches, else return
 128  * -1 if we cannot match a valid attribute. */
 129 int confnode_add_attr(struct confnode *n, const struct line *line,
 130                       const char *linebuf)
 131 {
 132         struct token *tok;
 133
 134         tok = TAILQ_FIRST(&line->token_list);
 135         if (tok == NULL)
 136                 return -1; /* should not happen */
 137
 138         /* specific attribute */
 139         if (n->ops->add_attr)
 140                 return n->ops->add_attr(n, line, linebuf);
 141
 142         /* syntax is: prompt "prompt content" */
 143         if (!(n->flags & CONFNODE_F_NO_SET_PROMPT) &&
 144             !strcmp(tok->str, "prompt") &&
 145             line->n_token <= 2) {
 146                 if (line->n_token == 2) {
 147                         tok = TAILQ_NEXT(tok, next);
 148                         snprintf(n->prompt, sizeof(n->prompt),
 149                                  "%s", tok->str);
 150                 }
 151                 return 0;
 152         }
 153         /* syntax is: prompt "requires EXPRESSION" */
 154         else if (!(n->flags & CONFNODE_F_NO_SET_DEPS) &&
 155                  !strcmp(tok->str, "requires") &&
 156                  line->n_token > 1) {
 157                 struct expr_node *e;
 158                 char *tmp;
 159                 tok = TAILQ_NEXT(tok, next);
 160                 tmp = strdup(linebuf + tok->offset);
 161                 e = parse_expression(tmp);
 162                 free(tmp);
 163                 if (e == NULL)
 164                         return -1;
 165                 TAILQ_INSERT_TAIL(&n->depend, e, next);
 166                 return 0;
 167         }
 168         /* XXX we could support expression here ? */
 169         /* syntax is: prompt "default VALUE" */
 170         else if (!(n->flags & CONFNODE_F_NO_SET_DEFAULT) &&
 171                  !strcmp(tok->str, "default") &&
 172                  line->n_token == 2) {
 173                 tok = TAILQ_NEXT(tok, next);
 174                 snprintf(n->default_value,
 175                          sizeof(n->default_value),
 176                          "%s", tok->str);
 177                 return 0;
 178         }
 179
 180         return -1;
 181 }
 182
 183 /* Parse a line and check if it closes the current node ,
 184  * "endmenu" closes "menu" node): in this case return 0. Else, return
 185  * -1. */
 186 int confnode_close_dir(struct confnode *parent, const struct line *line)
 187 {
 188         if (parent->ops->close_dir)
 189                 return parent->ops->close_dir(parent, line);
 190
 191         return -1;
 192 }
 193
 194 /* write config value in file f in a dotconfig-like manner. Return 0
 195  * on success. */
 196 int confnode_dotconfig_write(const struct confnode *n, FILE *f)
 197 {
 198         int val;
 199         const struct confnode *c;
 200         char buf[BUFSIZ];
 201         const char *quote = "";
 202
 203         if (n->ops->dotconfig_write)
 204                 return n->ops->dotconfig_write(n, f);
 205
 206         if (confnode_get_value(n, buf, sizeof(buf)) < 0)
 207                 return -1;
 208         val = confnode_strvalue_to_boolvalue(n, buf);
 209         if (val < 0)
 210                 return -1;
 211
 212         if (val == 0) {
 213                 if (fprintf(f, "# CONFIG_%s is not set\n", n->name) < 0)
 214                         return -1;
 215                 return 0;
 216         }
 217
 218         if (n->flags & CONFNODE_F_QUOTE_VALUE)
 219                 quote = "\"";
 220         if (fprintf(f, "CONFIG_%s=%s%s%s\n", n->name, quote, buf, quote) < 0)
 221                 return -1;
 222
 223         TAILQ_FOREACH(c, &n->children, next) {
 224                 if (confnode_dotconfig_write(c, f) < 0)
 225                         return -1;
 226         }
 227         return 0;
 228 }
 229
 230 /* Convert string value into boolean value (mainly used for
 231  * dependancies). Return -1 on error, else return the boolean value (0
 232  * or 1). */
 233 int confnode_strvalue_to_boolvalue(const struct confnode *n, const char *strvalue)
 234 {
 235         if (n->ops->strvalue_to_boolvalue)
 236                 return n->ops->strvalue_to_boolvalue(n, strvalue);
 237
 238         if (strcmp("n", strvalue) == 0)
 239                 return 0;
 240         if (strcmp("y", strvalue) == 0)
 241                 return 1;
 242         return -1;
 243 }
 244
 245 /* Set the string value of the node n. Return 0 on success, or -1 if
 246  * the value cannot be set. */
 247 int confnode_set_user_strvalue(struct confnode *n, const char *strvalue)
 248 {
 249         int start = 0, end;
 250         char buf[BUFSIZ];
 251
 252         buf[BUFSIZ-1] = '\0';
 253         strncpy(buf, strvalue, BUFSIZ-1);
 254
 255         if (remove_quote(buf, &start, &end) == 0)
 256                 buf[end] = '\0';
 257
 258         if (n->ops->set_user_strvalue)
 259                 return n->ops->set_user_strvalue(n, buf+start);
 260
 261         return -1;
 262 }
 263
 264 /* Get the string value that the user asked to set for this node
 265  * 'n'. This function does not check if dependancies are met. Return 0
 266  * on success, in this case the string is copied in buffer 'buf' of
 267  * len 'buflen'. Return -1 if the value cannot be read. */
 268 int confnode_get_user_strvalue(const struct confnode *n, char *buf, unsigned buflen)
 269 {
 270         if (n->ops->get_user_strvalue)
 271                 return n->ops->get_user_strvalue(n, buf, buflen);
 272
 273         return -1;
 274 }
 275
 276 /* Get user boolean value of the node. Return 0 if disabled, 1 if
 277  * enabled, and -1 on error. */
 278 int confnode_get_user_boolvalue(const struct confnode *n)
 279 {
 280         char buf[BUFSIZ];
 281         int ret;
 282
 283         ret = confnode_get_user_strvalue(n, buf, sizeof(buf));
 284         if (ret < 0)
 285                 return -1;
 286         ret = confnode_strvalue_to_boolvalue(n, buf);
 287         if (ret < 0)
 288                 return -1;
 289
 290         return ret;
 291 }
 292
 293 /* Set the default string value of the node n. Return 0 on success, or
 294  * -1 if the value cannot be set. */
 295 int confnode_set_default_strvalue(struct confnode *n, const char *strvalue)
 296 {
 297         int start = 0, end;
 298         char buf[BUFSIZ];
 299
 300         buf[BUFSIZ-1] = '\0';
 301         strncpy(buf, strvalue, BUFSIZ-1);
 302
 303         if (remove_quote(buf, &start, &end) == 0)
 304                 buf[end] = '\0';
 305
 306         if (n->ops->set_default_strvalue)
 307                 return n->ops->set_default_strvalue(n, buf);
 308
 309         return -1;
 310 }
 311
 312 /* Get the default string value for this node 'n'. This function does
 313  * not check if dependancies are met. Return 0 on success, in this
 314  * case the string is copied in buffer 'buf' of len 'buflen'. Return
 315  * -1 if the value cannot be read. */
 316 int confnode_get_default_strvalue(const struct confnode *n, char *buf, unsigned buflen)
 317 {
 318         if (n->ops->get_default_strvalue)
 319                 return n->ops->get_default_strvalue(n, buf, buflen);
 320
 321         return -1;
 322 }
 323
 324 /*
 325  * Check deps to see if a node 'n' can be enabled. If yes, return 1,
 326  * else return 0. On error, return -1. If 'verbose' is true, dump an
 327  * error for each condition preventing node to be enabled.
 328  */
 329 int confnode_check_deps(const struct confnode *n, int verbose)
 330 {
 331         char buf[BUFSIZ];
 332         const struct confnode *pn = n->parent;
 333         struct expr_node *e;
 334         int ret = 1;
 335         const char *parent_name;
 336
 337         /* bypass dependency checks if this flag is set */
 338         if (n->flags & CONFNODE_F_NO_DEPS)
 339                 return 1;
 340
 341         /* check that there is no disabled "if" or "menuconfig" above
 342          * our node */
 343         for (pn = n->parent; pn; pn = pn->parent) {
 344                 if (pn->flags & CONFNODE_F_IS_ROOT)
 345                         break;
 346                 if (!(pn->flags & CONFNODE_F_FORCE_CHILD_DEPS))
 347                         continue;
 348                 if (confnode_get_boolvalue(pn) != 0)
 349                         continue;
 350
 351                 if (verbose) {
 352                         /* use value if node has no name */
 353                         if (pn->flags & CONFNODE_F_NO_NAME)
 354                                 parent_name = pn->value;
 355                         else
 356                                 parent_name = pn->name;
 357                         printf("cannot enable %s, depends on "
 358                                "%s parent %s\n",
 359                                n->name,
 360                                confnode_get_type_str(pn),
 361                                parent_name);
 362                 }
 363                 ret = 0;
 364         }
 365
 366         /* check deps */
 367         TAILQ_FOREACH(e, &n->depend, next) {
 368                 if (expression_eval(e))
 369                         continue;
 370
 371                 if (expression_to_str(e, buf, sizeof(buf)) < 0)
 372                         return -1;
 373                 if (verbose)
 374                         printf("cannot enable %s, depends on %s\n", n->name, buf);
 375                 ret = 0;
 376         }
 377
 378         return ret;
 379 }
 380
 381 /* Get string value of a node, including dep check. Return -1 on
 382  * error. Return the boolean value of the node (0 or 1) on success: in
 383  * this case, and if buf is not NULL, buf is filled with the strvalue. */
 384 int confnode_get_value(const struct confnode *n, char *buf, unsigned buflen)
 385 {
 386         int dep, ret, strvalue_len;
 387         char localbuf[BUFSIZ];
 388         char *strvalue;
 389
 390         if (buf) {
 391                 strvalue = buf;
 392                 strvalue_len = buflen;
 393         }
 394         else {
 395                 strvalue = localbuf;
 396                 strvalue_len = sizeof(localbuf);
 397         }
 398
 399         /* check deps first */
 400         dep = confnode_check_deps(n, 0);
 401         if (dep < 0)
 402                 return -1;
 403         if (dep == 0)
 404                 return 0;
 405
 406         ret = confnode_get_user_strvalue(n, strvalue, strvalue_len);
 407         if (ret < 0)
 408                 ret = confnode_get_default_strvalue(n, strvalue, strvalue_len);
 409         if (ret < 0)
 410                 return 0; /* consider the value as false */
 411
 412         ret = confnode_strvalue_to_boolvalue(n, strvalue);
 413         if (ret < 0)
 414                 return -1;
 415
 416         return ret;
 417 }
 418
 419 /* Get boolean value of a node, including dep check. Return -1 on
 420  * error. Return the boolean value of the node (0 or 1) on success. */
 421 int confnode_get_boolvalue(const struct confnode *n)
 422 {
 423         return confnode_get_value(n, NULL, 0);
 424 }
 425
 426
 427 /* Return a string identifying the node type ("config", "menuconfig",
 428  * "choice", ...) */
 429 const char *confnode_get_type_str(const struct confnode *n)
 430 {
 431         if (n->ops->get_type_str)
 432                 return n->ops->get_type_str(n);
 433         return "none";
 434 }
 435
 436 /* Print a one-line summary of the node. Used in case of 'ls'. */
 437 void confnode_display_short(const struct confnode *n)
 438 {
 439         if (n->ops->display_short)
 440                 n->ops->display_short(n);
 441         else
 442                 printf("------    %s\n", n->prompt);
 443 }
 444
 445 /* Print a detailed view of the node. */
 446 void confnode_display_long(const struct confnode *n)
 447 {
 448         const char *nodetype;
 449         char value[MAX_VALUE_SIZE];
 450         char default_value[MAX_VALUE_SIZE];
 451         const char *quote = "";
 452
 453         if (n->ops->display_long) {
 454                 n->ops->display_long(n);
 455                 return;
 456         }
 457
 458         nodetype = confnode_get_type_str(n);
 459         printf("%s <%s>\n", nodetype, n->name);
 460         printf("    path ");
 461         conf_display_path(n);
 462
 463         if (n->flags & CONFNODE_F_QUOTE_VALUE)
 464                 quote = "\"";
 465
 466         /* display real value */
 467         if (confnode_get_value(n, value, sizeof(value)) < 0)
 468                 snprintf(value, sizeof(value), "invalid");
 469         printf("    value %s%s%s\n", quote, value, quote);
 470
 471         /* display user value */
 472         if (!strcmp(n->value, ""))
 473                 printf("    user NONE\n");
 474         else
 475                 printf("    user %s%s%s\n", quote, n->value, quote);
 476
 477         /* display default value */
 478         confnode_get_default_strvalue(n, default_value, MAX_VALUE_SIZE);
 479         printf("    default %s%s%s\n", quote, default_value, quote);
 480
 481         /* check and display deps */
 482         confnode_check_deps(n, 1);
 483 }
 484
 485 static void __conf_display_path(const struct confnode *n, int first)
 486 {
 487         if (n->parent)
 488                 __conf_display_path(n->parent, 0);
 489         if (n->flags & CONFNODE_F_IS_ROOT)
 490                 printf("/");
 491         else if (!(n->flags & CONFNODE_F_INVISIBLE))
 492                 printf("%s%s", n->name, first ? "" : "/" );
 493 }
 494
 495 /* show path: used by the 'pwd' command. Nodes like 'if' are
 496  * ignored. */
 497 void conf_display_path(const struct confnode *n)
 498 {
 499         __conf_display_path(n, 1);
 500         printf("\n");
 501 }
 502
 503 void confnode_register_all(void)
 504 {
 505         TAILQ_INIT(&confnode_type_list);
 506         confnode_root_register();
 507         confnode_menu_register();
 508         confnode_config_register();
 509         confnode_intconfig_register();
 510         confnode_menuconfig_register();
 511         confnode_strconfig_register();
 512         confnode_choice_register();
 513         confnode_choiceconfig_register();
 514         confnode_if_register();
 515         confnode_comment_register();
 516 }