git.ozlabs.org Git - petitboot/blob - discover/yaboot-cfg.c

   1 /*
   2  *  cfg.c - Handling and parsing of yaboot.conf
   3  *
   4  *  Copyright (C) 1995 Werner Almesberger
   5  *                1996 Jakub Jelinek
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  */
  21
  22 #include <setjmp.h>
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <stdint.h>
  27 #include <stdio.h>
  28
  29 #define prom_printf printf
  30 #define prom_putchar putchar
  31 #define prom_vprintf vprintf
  32
  33 /* Imported functions */
  34 extern int strcasecmp(const char *s1, const char *s2);
  35
  36 typedef enum {
  37      cft_strg, cft_flag, cft_end
  38 } CONFIG_TYPE;
  39
  40 typedef struct {
  41      CONFIG_TYPE type;
  42      char *name;
  43      void *data;
  44 } CONFIG;
  45
  46 #define MAX_TOKEN 200
  47 #define MAX_VAR_NAME MAX_TOKEN
  48 char *cfg_get_default (void);
  49
  50 CONFIG cf_options[] =
  51 {
  52      {cft_strg, "device", NULL},
  53      {cft_strg, "partition", NULL},
  54      {cft_strg, "default", NULL},
  55      {cft_strg, "timeout", NULL},
  56      {cft_strg, "password", NULL},
  57      {cft_flag, "restricted", NULL},
  58      {cft_strg, "message", NULL},
  59      {cft_strg, "root", NULL},
  60      {cft_strg, "ramdisk", NULL},
  61      {cft_flag, "read-only", NULL},
  62      {cft_flag, "read-write", NULL},
  63      {cft_strg, "append", NULL},
  64      {cft_strg, "initrd", NULL},
  65      {cft_flag, "initrd-prompt", NULL},
  66      {cft_strg, "initrd-size", NULL},
  67      {cft_flag, "pause-after", NULL},
  68      {cft_strg, "pause-message", NULL},
  69      {cft_strg, "init-code", NULL},
  70      {cft_strg, "init-message", NULL},
  71      {cft_strg, "fgcolor", NULL},
  72      {cft_strg, "bgcolor", NULL},
  73      {cft_strg, "ptypewarning", NULL},
  74      {cft_end, NULL, NULL}};
  75
  76 CONFIG cf_image[] =
  77 {
  78      {cft_strg, "image", NULL},
  79      {cft_strg, "label", NULL},
  80      {cft_strg, "alias", NULL},
  81      {cft_flag, "single-key", NULL},
  82      {cft_flag, "restricted", NULL},
  83      {cft_strg, "device", NULL},
  84      {cft_strg, "partition", NULL},
  85      {cft_strg, "root", NULL},
  86      {cft_strg, "ramdisk", NULL},
  87      {cft_flag, "read-only", NULL},
  88      {cft_flag, "read-write", NULL},
  89      {cft_strg, "append", NULL},
  90      {cft_strg, "literal", NULL},
  91      {cft_strg, "initrd", NULL},
  92      {cft_flag, "initrd-prompt", NULL},
  93      {cft_strg, "initrd-size", NULL},
  94      {cft_flag, "pause-after", NULL},
  95      {cft_strg, "pause-message", NULL},
  96      {cft_flag, "novideo", NULL},
  97      {cft_strg, "sysmap", NULL},
  98      {cft_end, NULL, NULL}};
  99
 100 static char flag_set;
 101 static char *last_token = NULL, *last_item = NULL, *last_value = NULL;
 102 static int line_num;
 103 static int back = 0;            /* can go back by one char */
 104 static char *currp = NULL;
 105 static char *endp = NULL;
 106 static char *file_name = NULL;
 107 static CONFIG *curr_table = cf_options;
 108 static jmp_buf env;
 109
 110 static struct IMAGES {
 111      CONFIG table[sizeof (cf_image) / sizeof (cf_image[0])];
 112      struct IMAGES *next;
 113 } *images = NULL;
 114
 115 void cfg_error (char *msg,...)
 116 {
 117      va_list ap;
 118
 119      va_start (ap, msg);
 120      prom_printf ("Config file error: ");
 121      prom_vprintf (msg, ap);
 122      va_end (ap);
 123      prom_printf (" near line %d in file %s\n", line_num, file_name);
 124      longjmp (env, 1);
 125 }
 126
 127 void cfg_warn (char *msg,...)
 128 {
 129      va_list ap;
 130
 131      va_start (ap, msg);
 132      prom_printf ("Config file warning: ");
 133      prom_vprintf (msg, ap);
 134      va_end (ap);
 135      prom_printf (" near line %d in file %s\n", line_num, file_name);
 136 }
 137
 138 int cfg_getc ()
 139 {
 140      if (currp == endp)
 141           return EOF;
 142      return *currp++;
 143 }
 144
 145 #define next_raw next
 146 static int next (void)
 147 {
 148      int ch;
 149
 150      if (!back)
 151           return cfg_getc ();
 152      ch = back;
 153      back = 0;
 154      return ch;
 155 }
 156
 157 static void again (int ch)
 158 {
 159      back = ch;
 160 }
 161
 162 static char *cfg_get_token (void)
 163 {
 164      char buf[MAX_TOKEN + 1];
 165      char *here;
 166      int ch, escaped;
 167
 168      if (last_token) {
 169           here = last_token;
 170           last_token = NULL;
 171           return here;
 172      }
 173      while (1) {
 174           while (ch = next (), ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')
 175                if (ch == '\n' || ch == '\r')
 176                     line_num++;
 177           if (ch == EOF || ch == (int)NULL)
 178                return NULL;
 179           if (ch != '#')
 180                break;
 181           while (ch = next_raw (), (ch != '\n' && ch != '\r'))
 182                if (ch == EOF)
 183                     return NULL;
 184           line_num++;
 185      }
 186      if (ch == '=')
 187           return strdup ("=");
 188      if (ch == '"') {
 189           here = buf;
 190           while (here - buf < MAX_TOKEN) {
 191                if ((ch = next ()) == EOF)
 192                     cfg_error ("EOF in quoted string");
 193                if (ch == '"') {
 194                     *here = 0;
 195                     return strdup (buf);
 196                }
 197                if (ch == '\\') {
 198                     ch = next ();
 199                     switch (ch) {
 200                     case '"':
 201                     case '\\':
 202                          break;
 203                     case '\n':
 204                     case '\r':
 205                          while ((ch = next ()), ch == ' ' || ch == '\t');
 206                          if (!ch)
 207                               continue;
 208                          again (ch);
 209                          ch = ' ';
 210                          break;
 211                     case 'n':
 212                          ch = '\n';
 213                          break;
 214                     default:
 215                          cfg_error ("Bad use of \\ in quoted string");
 216                     }
 217                } else if ((ch == '\n') || (ch == '\r'))
 218                     cfg_error ("newline is not allowed in quoted strings");
 219                *here++ = ch;
 220           }
 221           cfg_error ("Quoted string is too long");
 222           return 0;             /* not reached */
 223      }
 224      here = buf;
 225      escaped = 0;
 226      while (here - buf < MAX_TOKEN) {
 227           if (escaped) {
 228                if (ch == EOF)
 229                     cfg_error ("\\ precedes EOF");
 230                if (ch == '\n')
 231                     line_num++;
 232                else
 233                     *here++ = ch == '\t' ? ' ' : ch;
 234                escaped = 0;
 235           } else {
 236                if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '#' ||
 237                    ch == '=' || ch == EOF) {
 238                     again (ch);
 239                     *here = 0;
 240                     return strdup (buf);
 241                }
 242                if (!(escaped = (ch == '\\')))
 243                     *here++ = ch;
 244           }
 245           ch = next ();
 246      }
 247      cfg_error ("Token is too long");
 248      return 0;                  /* not reached */
 249 }
 250
 251 static void cfg_return_token (char *token)
 252 {
 253      last_token = token;
 254 }
 255
 256 static int cfg_next (char **item, char **value)
 257 {
 258      char *this;
 259
 260      if (last_item) {
 261           *item = last_item;
 262           *value = last_value;
 263           last_item = NULL;
 264           return 1;
 265      }
 266      *value = NULL;
 267      if (!(*item = cfg_get_token ()))
 268           return 0;
 269      if (!strcmp (*item, "="))
 270           cfg_error ("Syntax error");
 271      if (!(this = cfg_get_token ()))
 272           return 1;
 273      if (strcmp (this, "=")) {
 274           cfg_return_token (this);
 275           return 1;
 276      }
 277      if (!(*value = cfg_get_token ()))
 278           cfg_error ("Value expected at EOF");
 279      if (!strcmp (*value, "="))
 280           cfg_error ("Syntax error after %s", *item);
 281      return 1;
 282 }
 283
 284 #if 0
 285 // The one and only call to this procedure is commented out
 286 // below, so we don't need this unless we decide to use it again.
 287 static void cfg_return (char *item, char *value)
 288 {
 289      last_item = item;
 290      last_value = value;
 291 }
 292 #endif
 293
 294 static int cfg_set (char *item, char *value)
 295 {
 296      CONFIG *walk;
 297
 298      if (!strcasecmp (item, "image")) {
 299           struct IMAGES **p = &images;
 300
 301           while (*p)
 302                p = &((*p)->next);
 303           *p = (struct IMAGES *)malloc (sizeof (struct IMAGES));
 304           if (*p == NULL) {
 305                prom_printf("malloc error in cfg_set\n");
 306                return -1;
 307           }
 308           (*p)->next = 0;
 309           curr_table = ((*p)->table);
 310           memcpy (curr_table, cf_image, sizeof (cf_image));
 311      }
 312      for (walk = curr_table; walk->type != cft_end; walk++) {
 313           if (walk->name && !strcasecmp (walk->name, item)) {
 314                if (value && walk->type != cft_strg)
 315                     cfg_warn ("'%s' doesn't have a value", walk->name);
 316                else if (!value && walk->type == cft_strg)
 317                     cfg_warn ("Value expected for '%s'", walk->name);
 318                else {
 319                     if (walk->data)
 320                          cfg_warn ("Duplicate entry '%s'", walk->name);
 321                     if (walk->type == cft_flag)
 322                          walk->data = &flag_set;
 323                     else if (walk->type == cft_strg)
 324                          walk->data = value;
 325                }
 326                break;
 327           }
 328      }
 329      if (walk->type != cft_end)
 330           return 1;
 331 //    cfg_return (item, value);
 332      return 0;
 333 }
 334
 335 int cfg_parse (char *cfg_file, char *buff, int len)
 336 {
 337      char *item, *value;
 338
 339      file_name = cfg_file;
 340      currp = buff;
 341      endp = currp + len;
 342
 343      if (setjmp (env))
 344           return -1;
 345      while (1) {
 346           if (!cfg_next (&item, &value))
 347                return 0;
 348           if (!cfg_set (item, value)) {
 349 #if DEBUG
 350                prom_printf("Can't set item %s to value %s\n", item, value);
 351 #endif
 352           }
 353           free (item);
 354      }
 355 }
 356
 357 static char *cfg_get_strg_i (CONFIG * table, char *item)
 358 {
 359      CONFIG *walk;
 360
 361      for (walk = table; walk->type != cft_end; walk++)
 362           if (walk->name && !strcasecmp (walk->name, item))
 363                return walk->data;
 364      return 0;
 365 }
 366
 367 char *cfg_get_strg (char *image, char *item)
 368 {
 369      struct IMAGES *p;
 370      char *label, *alias;
 371      char *ret;
 372
 373      if (!image)
 374           return cfg_get_strg_i (cf_options, item);
 375      for (p = images; p; p = p->next) {
 376           label = cfg_get_strg_i (p->table, "label");
 377           if (!label) {
 378                label = cfg_get_strg_i (p->table, "image");
 379                alias = strrchr (label, '/');
 380                if (alias)
 381                     label = alias + 1;
 382           }
 383           alias = cfg_get_strg_i (p->table, "alias");
 384           if (!strcmp (label, image) || (alias && !strcmp (alias, image))) {
 385                ret = cfg_get_strg_i (p->table, item);
 386                if (!ret)
 387                     ret = cfg_get_strg_i (cf_options, item);
 388                return ret;
 389           }
 390      }
 391      return 0;
 392 }
 393
 394 int cfg_get_flag (char *image, char *item)
 395 {
 396      return !!cfg_get_strg (image, item);
 397 }
 398
 399 static int printl_count = 0;
 400 static void printlabel (char *label, int defflag)
 401 {
 402      int len = strlen (label);
 403
 404      if (!printl_count)
 405           prom_printf ("\n");
 406      prom_printf ("%s %s",defflag?"*":" ", label);
 407      while (len++ < 25)
 408           prom_putchar (' ');
 409      printl_count++;
 410      if (printl_count == 3)
 411           printl_count = 0;
 412 }
 413
 414 void cfg_print_images (void)
 415 {
 416      struct IMAGES *p;
 417      char *label, *alias;
 418
 419      char *ret = cfg_get_default();//strg_i (cf_options, "default");
 420      int defflag=0;
 421
 422      printl_count = 0;
 423      for (p = images; p; p = p->next) {
 424           label = cfg_get_strg_i (p->table, "label");
 425           if (!label) {
 426                label = cfg_get_strg_i (p->table, "image");
 427                alias = strrchr (label, '/');
 428                if (alias)
 429                     label = alias + 1;
 430           }
 431           if(!strcmp(ret,label))
 432                defflag=1;
 433           else
 434                defflag=0;
 435           alias = cfg_get_strg_i (p->table, "alias");
 436           printlabel (label, defflag);
 437           if (alias)
 438                printlabel (alias, 0);
 439      }
 440      prom_printf("\n");
 441 }
 442
 443 char *cfg_get_default (void)
 444 {
 445      char *label;
 446      char *ret = cfg_get_strg_i (cf_options, "default");
 447
 448      if (ret)
 449           return ret;
 450      if (!images)
 451           return 0;
 452      ret = cfg_get_strg_i (images->table, "label");
 453      if (!ret) {
 454           ret = cfg_get_strg_i (images->table, "image");
 455           label = strrchr (ret, '/');
 456           if (label)
 457                ret = label + 1;
 458      }
 459      return ret;
 460 }
 461
 462 char *cfg_next_image(char *prev)
 463 {
 464      struct IMAGES *p;
 465      char *label, *alias;
 466      int wantnext = 0;
 467
 468      if (!prev)
 469           wantnext = 1;
 470
 471      for (p = images; p; p = p->next) {
 472           label = cfg_get_strg_i (p->table, "label");
 473           if (!label) {
 474                label = cfg_get_strg_i (p->table, "image");
 475                alias = strrchr (label, '/');
 476                if (alias)
 477                     label = alias + 1;
 478           }
 479           if (wantnext)
 480                return label;
 481           if (!strcmp(prev, label))
 482                wantnext = 1;
 483      }
 484      return NULL;
 485 }
 486 /*
 487  * Local variables:
 488  * c-file-style: "k&r"
 489  * c-basic-offset: 5
 490  * End:
 491  */