com32/modules/readconfig.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2004-2006 H. Peter Anvin - All Rights Reserved
   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 as published by
   7  *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
   8  *   Boston MA 02111-1307, USA; either version 2 of the License, or
   9  *   (at your option) any later version; incorporated herein by reference.
  10  *
  11  * ----------------------------------------------------------------------- */
  12
  13 #define _GNU_SOURCE             /* Needed for asprintf() on Linux */
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <minmax.h>
  18 #include <alloca.h>
  19 #include <colortbl.h>
  20 #ifdef __COM32__
  21 # include <com32.h>
  22 #endif
  23
  24 #include "menu.h"
  25
  26 int nentries     = 0;
  27 int nhidden      = 0;
  28 int defentry     = 0;
  29 int allowedit    = 1;           /* Allow edits of the command line */
  30 int timeout      = 0;
  31 int shiftkey     = 0;           /* Only display menu if shift key pressed */
  32 long long totaltimeout = 0;
  33
  34 char *menu_title  = "";
  35 char *ontimeout   = NULL;
  36 char *onerror     = NULL;
  37
  38 char *menu_master_passwd = NULL;
  39
  40 char *menu_background = NULL;
  41
  42 struct menu_entry menu_entries[MAX_ENTRIES];
  43 struct menu_entry hide_entries[MAX_ENTRIES];
  44 struct menu_entry *menu_hotkeys[256];
  45
  46 #define astrdup(x) ({ char *__x = (x); \
  47                       size_t __n = strlen(__x) + 1; \
  48                       char *__p = alloca(__n); \
  49                       if ( __p ) memcpy(__p, __x, __n); \
  50                       __p; })
  51
  52 const char *ipappends[32];
  53
  54 static void
  55 get_ipappend(void)
  56 {
  57 #ifdef __COM32__
  58   static com32sys_t r;
  59   uint16_t *ipp;
  60   int i;
  61   int nipappends;
  62
  63   r.eax.w[0] = 0x000F;
  64   __intcall(0x22, &r, &r);
  65
  66   nipappends = min(r.ecx.w[0], 32);
  67   ipp        = MK_PTR(r.es, r.ebx.w[0]);
  68   for ( i = 0 ; i < nipappends ; i++ ) {
  69     ipappends[i] = MK_PTR(r.es, *ipp++);
  70   }
  71 #else
  72   ipappends[0] = "ip=foo:bar:baz:quux";
  73   ipappends[1] = "BOOTIF=01-aa-bb-cc-dd-ee-ff";
  74 #endif
  75 }
  76
  77 static const char *
  78 get_config(void)
  79 {
  80 #ifdef __COM32__
  81   static com32sys_t r;
  82
  83   r.eax.w[0] = 0x000E;
  84   __intcall(0x22, &r, &r);
  85
  86   return MK_PTR(r.es, r.ebx.w[0]);
  87 #else
  88   return "syslinux.cfg";        /* Dummy default name */
  89 #endif
  90 }
  91
  92 #define MAX_LINE 512
  93
  94 static char *
  95 skipspace(char *p)
  96 {
  97   while (*p && my_isspace(*p))
  98     p++;
  99
 100   return p;
 101 }
 102
 103 /* Check to see if we are at a certain keyword (case insensitive) */
 104 /* Returns a pointer to the first character past the keyword */
 105 static char *
 106 looking_at(char *line, const char *kwd)
 107 {
 108   char *p = line;
 109   const char *q = kwd;
 110
 111   while ( *p && *q && ((*p^*q) & ~0x20) == 0 ) {
 112     p++;
 113     q++;
 114   }
 115
 116   if ( *q )
 117     return NULL;                /* Didn't see the keyword */
 118
 119   return my_isspace(*p) ? p : NULL; /* Must be EOL or whitespace */
 120 }
 121
 122 struct labeldata {
 123   char *label;
 124   char *kernel;
 125   char *append;
 126   char *menulabel;
 127   char *passwd;
 128   unsigned int ipappend;
 129   unsigned int menuhide;
 130   unsigned int menudefault;
 131 };
 132
 133 static void
 134 record(struct labeldata *ld, char *append)
 135 {
 136   char ipoptions[256], *ipp;
 137   int i;
 138   struct menu_entry *me = &menu_entries[nentries];
 139
 140   if ( ld->label ) {
 141     char *a, *s;
 142     me->displayname = ld->menulabel ? ld->menulabel : ld->label;
 143     me->label       = ld->label;
 144     me->passwd      = ld->passwd;
 145     me->hotkey = 0;
 146
 147     if ( ld->menulabel ) {
 148       unsigned char *p = (unsigned char *)strchr(ld->menulabel, '^');
 149       if ( p && p[1] ) {
 150         int hotkey = p[1] & ~0x20;
 151         if ( !menu_hotkeys[hotkey] ) {
 152           me->hotkey = hotkey;
 153         }
 154       }
 155     }
 156
 157     ipp = ipoptions;
 158     *ipp = '\0';
 159     for ( i = 0 ; i < 32 ; i++ ) {
 160       if ( (ld->ipappend & (1U << i)) && ipappends[i] )
 161         ipp += sprintf(ipp, " %s", ipappends[i]);
 162     }
 163
 164     a = ld->append;
 165     if ( !a ) a = append;
 166     if ( !a || (a[0] == '-' && !a[1]) ) a = "";
 167     s = a[0] ? " " : "";
 168     asprintf(&me->cmdline, "%s%s%s%s", ld->kernel, s, a, ipoptions);
 169
 170     ld->label = NULL;
 171     ld->passwd = NULL;
 172
 173     free(ld->kernel);
 174     ld->kernel = NULL;
 175
 176     if ( ld->append ) {
 177       free(ld->append);
 178       ld->append = NULL;
 179     }
 180
 181     if ( !ld->menuhide ) {
 182       if ( me->hotkey )
 183         menu_hotkeys[me->hotkey] = me;
 184
 185       if ( ld->menudefault )
 186         defentry = nentries;
 187
 188       nentries++;
 189     }
 190     else {
 191       hide_entries[nhidden].displayname = me->displayname;
 192       hide_entries[nhidden].label       = me->label;
 193       hide_entries[nhidden].cmdline     = me->cmdline;
 194       hide_entries[nhidden].passwd      = me->passwd;
 195
 196       me->displayname = NULL;
 197       me->label       = NULL;
 198       me->cmdline     = NULL;
 199       me->passwd      = NULL;
 200
 201       nhidden++;
 202     }
 203   }
 204 }
 205
 206 static char *
 207 unlabel(char *str)
 208 {
 209   /* Convert a CLI-style command line to an executable command line */
 210   const char *p;
 211   char *q;
 212   struct menu_entry *me;
 213   int i, pos;
 214
 215   p = str;
 216   while ( *p && !my_isspace(*p) )
 217     p++;
 218
 219   /* p now points to the first byte beyond the kernel name */
 220   pos = p-str;
 221
 222   for ( i = 0 ; i < nentries ; i++ ) {
 223     me = &menu_entries[i];
 224
 225     if ( !strncmp(str, me->label, pos) && !me->label[pos] ) {
 226       /* Found matching label */
 227       q = malloc(strlen(me->cmdline) + strlen(p) + 1);
 228       strcpy(q, me->cmdline);
 229       strcat(q, p);
 230
 231       free(str);
 232
 233       return q;
 234     }
 235   }
 236
 237   for ( i = 0 ; i < nhidden ; i++ ) {
 238     me = &hide_entries[i];
 239
 240     if ( !strncmp(str, me->label, pos) && !me->label[pos] ) {
 241       /* Found matching label */
 242       q = malloc(strlen(me->cmdline) + strlen(p) + 1);
 243       strcpy(q, me->cmdline);
 244       strcat(q, p);
 245
 246       free(str);
 247
 248       return q;
 249     }
 250   }
 251
 252   return str;
 253 }
 254
 255 static char *
 256 dup_word(char **p)
 257 {
 258   char *sp = *p;
 259   char *ep = sp;
 260   char *dp;
 261   size_t len;
 262
 263   while (*ep && !my_isspace(*ep))
 264     ep++;
 265
 266   *p = ep;
 267   len = ep-sp;
 268
 269   dp = malloc(len+1);
 270   memcpy(dp, sp, len);
 271   dp[len] = '\0';
 272
 273   return dp;
 274 }
 275
 276 static int my_isxdigit(char c)
 277 {
 278   unsigned char uc = c | 0x20;
 279
 280   return (uc-'0') < 10 || (uc-'a') < 6;
 281 }
 282
 283 static unsigned int hexval(char c)
 284 {
 285   unsigned char uc = c | 0x20;
 286
 287   if (uc & 0x40)
 288     return uc-'a'+10;
 289   else
 290     return uc-'0';
 291 }
 292
 293 static unsigned int hexval2(char *p)
 294 {
 295   return (hexval(p[0]) << 4)+hexval(p[1]);
 296 }
 297
 298 static unsigned int parse_argb(char **p)
 299 {
 300   char *sp = *p;
 301   char *ep;
 302   unsigned int argb;
 303   size_t len, dl;
 304
 305   if (*sp == '#')
 306     sp++;
 307
 308   ep = sp;
 309
 310   while (my_isxdigit(*ep))
 311     ep++;
 312
 313   *p = ep;
 314   len = ep-sp;
 315
 316   switch(len) {
 317   case 3:                       /* #rgb */
 318     argb =
 319       0xff000000 |
 320       (hexval(sp[0])*0x11 << 16)|
 321       (hexval(sp[1])*0x11 << 8) |
 322       (hexval(sp[2])*0x11 << 0);
 323     break;
 324   case 4:                       /* #argb */
 325     argb =
 326       (hexval(sp[0])*0x11 << 24)|
 327       (hexval(sp[1])*0x11 << 16)|
 328       (hexval(sp[2])*0x11 << 8) |
 329       (hexval(sp[3])*0x11 << 0);
 330     break;
 331   case 6:                       /* #rrggbb */
 332   case 9:                       /* #rrrgggbbb */
 333   case 12:                      /* #rrrrggggbbbb */
 334     dl = len/3;
 335     argb =
 336       0xff000000 |
 337       (hexval2(sp+0) << 16) |
 338       (hexval2(sp+dl) << 8)|
 339       (hexval2(sp+dl*2) << 0);
 340     break;
 341   case 8:                       /* #aarrggbb */
 342     /* 12 is indistinguishable from #rrrrggggbbbb,
 343        assume that is a more common format */
 344   case 16:                      /* #aaaarrrrggggbbbb */
 345     dl = len/4;
 346     argb =
 347       (hexval2(sp+0) << 24) |
 348       (hexval2(sp+dl) << 16) |
 349       (hexval2(sp+dl*2) << 8)|
 350       (hexval2(sp+dl*3) << 0);
 351     break;
 352   default:
 353     argb = 0;
 354     break;
 355   }
 356
 357   return argb;
 358 }
 359
 360 void parse_config(const char *filename)
 361 {
 362   char line[MAX_LINE], *p, *ep;
 363   FILE *f;
 364   char *append = NULL;
 365   unsigned int ipappend = 0;
 366   static struct labeldata ld;
 367
 368   get_ipappend();
 369
 370   if ( !filename )
 371     filename = get_config();
 372
 373   f = fopen(filename, "r");
 374   if ( !f )
 375     return;
 376
 377   while ( fgets(line, sizeof line, f) ) {
 378     p = strchr(line, '\r');
 379     if ( p )
 380       *p = '\0';
 381     p = strchr(line, '\n');
 382     if ( p )
 383       *p = '\0';
 384
 385     p = skipspace(line);
 386
 387     if ( looking_at(p, "menu") ) {
 388       p = skipspace(p+4);
 389
 390       if ( looking_at(p, "title") ) {
 391         menu_title = strdup(skipspace(p+5));
 392       } else if ( looking_at(p, "label") ) {
 393         if ( ld.label )
 394           ld.menulabel = strdup(skipspace(p+5));
 395       } else if ( looking_at(p, "default") ) {
 396         ld.menudefault = 1;
 397       } else if ( looking_at(p, "hide") ) {
 398         ld.menuhide = 1;
 399       } else if ( looking_at(p, "passwd") ) {
 400         ld.passwd = strdup(skipspace(p+6));
 401       } else if ( looking_at(p, "shiftkey") ) {
 402         shiftkey = 1;
 403       } else if ( looking_at(p, "onerror") ) {
 404         onerror = strdup(skipspace(p+7));
 405       } else if ( looking_at(p, "master") ) {
 406         p = skipspace(p+6);
 407         if ( looking_at(p, "passwd") ) {
 408           menu_master_passwd = strdup(skipspace(p+6));
 409         }
 410       } else if ( (ep = looking_at(p, "background")) ) {
 411         p = skipspace(ep);
 412         menu_background = dup_word(&p);
 413       } else if ((ep = looking_at(p, "color")) ||
 414                  (ep = looking_at(p, "colour"))) {
 415         int i;
 416         struct color_table *cptr;
 417         p = skipspace(ep);
 418         cptr = console_color_table;
 419         for ( i = 0; i < console_color_table_size; i++ ) {
 420           if ( (ep = looking_at(p, cptr->name)) ) {
 421             p = skipspace(ep);
 422             if (*p) {
 423               free(cptr->ansi);
 424               cptr->ansi = dup_word(&p);
 425
 426               p = skipspace(ep);
 427               if (*p) {
 428                 cptr->argb_fg = parse_argb(&p);
 429                 p = skipspace(ep);
 430                 if (*p) {
 431                   cptr->argb_bg = parse_argb(&p);
 432                 }
 433               }
 434             }
 435             break;
 436           }
 437         }
 438       } else {
 439         /* Unknown, check for layout parameters */
 440         struct menu_parameter *pp;
 441         for ( pp = mparm ; pp->name ; pp++ ) {
 442           if ( (ep = looking_at(p, pp->name)) ) {
 443             pp->value = atoi(skipspace(ep));
 444             break;
 445           }
 446         }
 447       }
 448     } else if ( looking_at(p, "append") ) {
 449       char *a = strdup(skipspace(p+6));
 450       if ( ld.label )
 451         ld.append = a;
 452       else
 453         append = a;
 454     } else if ( looking_at(p, "label") ) {
 455       p = skipspace(p+5);
 456       record(&ld, append);
 457       ld.label     = strdup(p);
 458       ld.kernel    = strdup(p);
 459       ld.passwd    = NULL;
 460       ld.append    = NULL;
 461       ld.menulabel = NULL;
 462       ld.ipappend  = ipappend;
 463       ld.menudefault = ld.menuhide = 0;
 464     } else if ( looking_at(p, "kernel") ) {
 465       if ( ld.label ) {
 466         free(ld.kernel);
 467         ld.kernel = strdup(skipspace(p+6));
 468       }
 469     } else if ( looking_at(p, "timeout") ) {
 470       timeout = (atoi(skipspace(p+7))*CLK_TCK+9)/10;
 471     } else if ( looking_at(p, "totaltimeout") ) {
 472       totaltimeout = (atoll(skipspace(p+13))*CLK_TCK+9)/10;
 473     } else if ( looking_at(p, "ontimeout") ) {
 474       ontimeout = strdup(skipspace(p+9));
 475     } else if ( looking_at(p, "allowoptions") ) {
 476       allowedit = atoi(skipspace(p+12));
 477     } else if ( looking_at(p, "ipappend") ) {
 478       if (ld.label)
 479         ld.ipappend = atoi(skipspace(p+8));
 480       else
 481         ipappend = atoi(skipspace(p+8));
 482     } else if ( looking_at(p, "localboot") ) {
 483       ld.kernel = strdup(".localboot");
 484       ld.append = strdup(skipspace(p+9));
 485     }
 486   }
 487
 488   record(&ld, append);
 489   fclose(f);
 490
 491   if ( ontimeout )
 492     ontimeout = unlabel(ontimeout);
 493   if ( onerror )
 494     onerror = unlabel(onerror);
 495 }