Magellan Linux

Diff of /trunk/grubby/grubby.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1717 by niro, Sat Feb 18 00:47:17 2012 UTC revision 2992 by niro, Thu Jun 30 10:35:14 2016 UTC
# Line 36  Line 36 
36  #include <signal.h>  #include <signal.h>
37  #include <blkid/blkid.h>  #include <blkid/blkid.h>
38    
39    #include "log.h"
40    
41  #ifndef DEBUG  #ifndef DEBUG
42  #define DEBUG 0  #define DEBUG 0
43  #endif  #endif
# Line 46  Line 48 
48  #define dbgPrintf(format, args...)  #define dbgPrintf(format, args...)
49  #endif  #endif
50    
51    int debug = 0; /* Currently just for template debugging */
52    
53  #define _(A) (A)  #define _(A) (A)
54    
55  #define MAX_EXTRA_INITRDS  16 /* code segment checked by --bootloader-probe */  #define MAX_EXTRA_INITRDS  16 /* code segment checked by --bootloader-probe */
56  #define CODE_SEG_SIZE  128 /* code segment checked by --bootloader-probe */  #define CODE_SEG_SIZE  128 /* code segment checked by --bootloader-probe */
57    
58    #define NOOP_OPCODE 0x90
59    #define JMP_SHORT_OPCODE 0xeb
60    
61    int isEfi = 0;
62    
63    #if defined(__aarch64__)
64    #define isEfiOnly 1
65    #else
66    #define isEfiOnly 0
67    #endif
68    
69    char *saved_command_line = NULL;
70    
71  /* comments get lumped in with indention */  /* comments get lumped in with indention */
72  struct lineElement {  struct lineElement {
73      char * item;      char * item;
# Line 77  enum lineType_e { Line 94  enum lineType_e {
94      LT_MENUENTRY    = 1 << 17,      LT_MENUENTRY    = 1 << 17,
95      LT_ENTRY_END    = 1 << 18,      LT_ENTRY_END    = 1 << 18,
96      LT_SET_VARIABLE = 1 << 19,      LT_SET_VARIABLE = 1 << 19,
97      LT_UNKNOWN      = 1 << 20,      LT_KERNEL_EFI   = 1 << 20,
98        LT_INITRD_EFI   = 1 << 21,
99        LT_KERNEL_16    = 1 << 22,
100        LT_INITRD_16    = 1 << 23,
101        LT_DEVTREE      = 1 << 24,
102        LT_UNKNOWN      = 1 << 25,
103  };  };
104    
105  struct singleLine {  struct singleLine {
# Line 106  struct singleEntry { Line 128  struct singleEntry {
128  #define NEED_ARGS    (1 << 3)  #define NEED_ARGS    (1 << 3)
129  #define NEED_MB      (1 << 4)  #define NEED_MB      (1 << 4)
130  #define NEED_END     (1 << 5)  #define NEED_END     (1 << 5)
131    #define NEED_DEVTREE (1 << 6)
132    
133  #define MAIN_DEFAULT    (1 << 0)  #define MAIN_DEFAULT    (1 << 0)
134  #define DEFAULT_SAVED       -2  #define DEFAULT_SAVED       -2
135    #define DEFAULT_SAVED_GRUB2 -3
136    
137  struct keywordTypes {  struct keywordTypes {
138      char * key;      char * key;
# Line 122  struct configFileInfo; Line 146  struct configFileInfo;
146  typedef const char *(*findConfigFunc)(struct configFileInfo *);  typedef const char *(*findConfigFunc)(struct configFileInfo *);
147  typedef const int (*writeLineFunc)(struct configFileInfo *,  typedef const int (*writeLineFunc)(struct configFileInfo *,
148   struct singleLine *line);   struct singleLine *line);
149    typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
150    typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
151    
152  struct configFileInfo {  struct configFileInfo {
153      char * defaultConfig;      char * defaultConfig;
154      findConfigFunc findConfig;      findConfigFunc findConfig;
155      writeLineFunc writeLine;      writeLineFunc writeLine;
156        getEnvFunc getEnv;
157        setEnvFunc setEnv;
158      struct keywordTypes * keywords;      struct keywordTypes * keywords;
159        int caseInsensitive;
160      int defaultIsIndex;      int defaultIsIndex;
161      int defaultIsVariable;      int defaultIsVariable;
162      int defaultSupportSaved;      int defaultSupportSaved;
163        int defaultIsSaved;
164        int defaultIsUnquoted;
165      enum lineType_e entryStart;      enum lineType_e entryStart;
166      enum lineType_e entryEnd;      enum lineType_e entryEnd;
167      int needsBootPrefix;      int needsBootPrefix;
# Line 142  struct configFileInfo { Line 173  struct configFileInfo {
173      int mbInitRdIsModule;      int mbInitRdIsModule;
174      int mbConcatArgs;      int mbConcatArgs;
175      int mbAllowExtraInitRds;      int mbAllowExtraInitRds;
176        char *envFile;
177  };  };
178    
179  struct keywordTypes grubKeywords[] = {  struct keywordTypes grubKeywords[] = {
# Line 158  struct keywordTypes grubKeywords[] = { Line 190  struct keywordTypes grubKeywords[] = {
190    
191  const char *grubFindConfig(struct configFileInfo *cfi) {  const char *grubFindConfig(struct configFileInfo *cfi) {
192      static const char *configFiles[] = {      static const char *configFiles[] = {
  "/etc/grub.conf",  
193   "/boot/grub/grub.conf",   "/boot/grub/grub.conf",
194   "/boot/grub/menu.lst",   "/boot/grub/menu.lst",
195     "/etc/grub.conf",
196     "/boot/grub2/grub.cfg",
197     "/boot/grub2-efi/grub.cfg",
198   NULL   NULL
199      };      };
200      static int i = -1;      static int i = -1;
# Line 188  struct configFileInfo grubConfigType = { Line 222  struct configFileInfo grubConfigType = {
222      .mbHyperFirst = 1,      .mbHyperFirst = 1,
223      .mbInitRdIsModule = 1,      .mbInitRdIsModule = 1,
224      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
225        .titlePosition = 1,
226  };  };
227    
228  struct keywordTypes grub2Keywords[] = {  struct keywordTypes grub2Keywords[] = {
# Line 199  struct keywordTypes grub2Keywords[] = { Line 234  struct keywordTypes grub2Keywords[] = {
234      { "default",    LT_DEFAULT,     ' ' },      { "default",    LT_DEFAULT,     ' ' },
235      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
236      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
237        { "linuxefi",   LT_KERNEL_EFI,  ' ' },
238        { "linux16",    LT_KERNEL_16,   ' ' },
239      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
240        { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
241        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
242      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
243      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
244        { "devicetree", LT_DEVTREE,  ' ' },
245      { NULL, 0, 0 },      { NULL, 0, 0 },
246  };  };
247    
# Line 213  const char *grub2FindConfig(struct confi Line 253  const char *grub2FindConfig(struct confi
253      };      };
254      static int i = -1;      static int i = -1;
255      static const char *grub_cfg = "/boot/grub/grub.cfg";      static const char *grub_cfg = "/boot/grub/grub.cfg";
256        int rc = -1;
257    
258      if (i == -1) {      if (i == -1) {
259   for (i = 0; configFiles[i] != NULL; i++) {   for (i = 0; configFiles[i] != NULL; i++) {
260      dbgPrintf("Checking \"%s\": ", configFiles[i]);      dbgPrintf("Checking \"%s\": ", configFiles[i]);
261      if (!access(configFiles[i], R_OK)) {      if ((rc = access(configFiles[i], R_OK))) {
262     if (errno == EACCES) {
263        printf("Unable to access bootloader configuration file "
264           "\"%s\": %m\n", configFiles[i]);
265        exit(1);
266     }
267     continue;
268        } else {
269   dbgPrintf("found\n");   dbgPrintf("found\n");
270   return configFiles[i];   return configFiles[i];
271      }      }
# Line 236  const char *grub2FindConfig(struct confi Line 284  const char *grub2FindConfig(struct confi
284      return configFiles[i];      return configFiles[i];
285  }  }
286    
287    /* kind of hacky.  It'll give the first 1024 bytes, ish. */
288    static char *grub2GetEnv(struct configFileInfo *info, char *name)
289    {
290        static char buf[1025];
291        char *s = NULL;
292        char *ret = NULL;
293        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
294        int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
295    
296        if (rc < 0)
297     return NULL;
298    
299        FILE *f = popen(s, "r");
300        if (!f)
301     goto out;
302    
303        memset(buf, '\0', sizeof (buf));
304        ret = fgets(buf, 1024, f);
305        pclose(f);
306    
307        if (ret) {
308     ret += strlen(name) + 1;
309     ret[strlen(ret) - 1] = '\0';
310        }
311        dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
312    out:
313        free(s);
314        return ret;
315    }
316    
317    static int sPopCount(const char *s, const char *c)
318    {
319        int ret = 0;
320        if (!s)
321     return -1;
322        for (int i = 0; s[i] != '\0'; i++)
323     for (int j = 0; c[j] != '\0'; j++)
324        if (s[i] == c[j])
325     ret++;
326        return ret;
327    }
328    
329    static char *shellEscape(const char *s)
330    {
331        int l = strlen(s) + sPopCount(s, "'") * 2;
332    
333        char *ret = calloc(l+1, sizeof (*ret));
334        if (!ret)
335     return NULL;
336        for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
337     if (s[i] == '\'')
338        ret[j++] = '\\';
339     ret[j] = s[i];
340        }
341        return ret;
342    }
343    
344    static void unquote(char *s)
345    {
346        int l = strlen(s);
347    
348        if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
349     memmove(s, s+1, l-2);
350     s[l-2] = '\0';
351        }
352    }
353    
354    static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
355    {
356        char *s = NULL;
357        int rc = 0;
358        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
359    
360        unquote(value);
361        value = shellEscape(value);
362        if (!value)
363        return -1;
364    
365        rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
366        free(value);
367        if (rc <0)
368     return -1;
369    
370        dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
371        rc = system(s);
372        free(s);
373        return rc;
374    }
375    
376    /* this is a gigantic hack to avoid clobbering grub2 variables... */
377    static int is_special_grub2_variable(const char *name)
378    {
379        if (!strcmp(name,"\"${next_entry}\""))
380     return 1;
381        if (!strcmp(name,"\"${prev_saved_entry}\""))
382     return 1;
383        return 0;
384    }
385    
386    int sizeOfSingleLine(struct singleLine * line) {
387      int count = 0;
388    
389      for (int i = 0; i < line->numElements; i++) {
390        int indentSize = 0;
391    
392        count = count + strlen(line->elements[i].item);
393    
394        indentSize = strlen(line->elements[i].indent);
395        if (indentSize > 0)
396          count = count + indentSize;
397        else
398          /* be extra safe and add room for whitespaces */
399          count = count + 1;
400      }
401    
402      /* room for trailing terminator */
403      count = count + 1;
404    
405      return count;
406    }
407    
408    static int isquote(char q)
409    {
410        if (q == '\'' || q == '\"')
411     return 1;
412        return 0;
413    }
414    
415    static int iskernel(enum lineType_e type) {
416        return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
417    }
418    
419    static int isinitrd(enum lineType_e type) {
420        return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
421    }
422    
423    char *grub2ExtractTitle(struct singleLine * line) {
424        char * current;
425        char * current_indent;
426        int current_len;
427        int current_indent_len;
428        int i;
429    
430        /* bail out if line does not start with menuentry */
431        if (strcmp(line->elements[0].item, "menuentry"))
432     return NULL;
433    
434        i = 1;
435        current = line->elements[i].item;
436        current_len = strlen(current);
437    
438        /* if second word is quoted, strip the quotes and return single word */
439        if (isquote(*current) && isquote(current[current_len - 1])) {
440     char *tmp;
441    
442     tmp = strdup(current+1);
443     if (!tmp)
444        return NULL;
445     tmp[strlen(tmp)-1] = '\0';
446     return tmp;
447        }
448    
449        /* if no quotes, return second word verbatim */
450        if (!isquote(*current))
451     return current;
452    
453        /* second element start with a quote, so we have to find the element
454         * whose last character is also quote (assuming it's the closing one) */
455        int resultMaxSize;
456        char * result;
457        /* need to ensure that ' does not match " as we search */
458        char quote_char = *current;
459    
460        resultMaxSize = sizeOfSingleLine(line);
461        result = malloc(resultMaxSize);
462        snprintf(result, resultMaxSize, "%s", ++current);
463    
464        i++;
465        for (; i < line->numElements; ++i) {
466     current = line->elements[i].item;
467     current_len = strlen(current);
468     current_indent = line->elements[i].indent;
469     current_indent_len = strlen(current_indent);
470    
471     strncat(result, current_indent, current_indent_len);
472     if (current[current_len-1] != quote_char) {
473        strncat(result, current, current_len);
474     } else {
475        strncat(result, current, current_len - 1);
476        break;
477     }
478        }
479        return result;
480    }
481    
482  struct configFileInfo grub2ConfigType = {  struct configFileInfo grub2ConfigType = {
483      .findConfig = grub2FindConfig,      .findConfig = grub2FindConfig,
484        .getEnv = grub2GetEnv,
485        .setEnv = grub2SetEnv,
486      .keywords = grub2Keywords,      .keywords = grub2Keywords,
487      .defaultIsIndex = 1,      .defaultIsIndex = 1,
488      .defaultSupportSaved = 0,      .defaultSupportSaved = 1,
489      .defaultIsVariable = 1,      .defaultIsVariable = 1,
490      .entryStart = LT_MENUENTRY,      .entryStart = LT_MENUENTRY,
491      .entryEnd = LT_ENTRY_END,      .entryEnd = LT_ENTRY_END,
# Line 342  struct keywordTypes extlinuxKeywords[] = Line 587  struct keywordTypes extlinuxKeywords[] =
587      { "initrd",    LT_INITRD,      ' ', ',' },      { "initrd",    LT_INITRD,      ' ', ',' },
588      { "append",    LT_KERNELARGS,  ' ' },      { "append",    LT_KERNELARGS,  ' ' },
589      { "prompt",     LT_UNKNOWN,     ' ' },      { "prompt",     LT_UNKNOWN,     ' ' },
590        { "fdt",        LT_DEVTREE,     ' ' },
591        { "fdtdir",     LT_DEVTREE,     ' ' },
592      { NULL,    0, 0 },      { NULL,    0, 0 },
593  };  };
594  int useextlinuxmenu;  int useextlinuxmenu;
# Line 352  struct configFileInfo eliloConfigType = Line 599  struct configFileInfo eliloConfigType =
599      .needsBootPrefix = 1,      .needsBootPrefix = 1,
600      .argsInQuotes = 1,      .argsInQuotes = 1,
601      .mbConcatArgs = 1,      .mbConcatArgs = 1,
602        .titlePosition = 1,
603  };  };
604    
605  struct configFileInfo liloConfigType = {  struct configFileInfo liloConfigType = {
# Line 360  struct configFileInfo liloConfigType = { Line 608  struct configFileInfo liloConfigType = {
608      .entryStart = LT_KERNEL,      .entryStart = LT_KERNEL,
609      .argsInQuotes = 1,      .argsInQuotes = 1,
610      .maxTitleLength = 15,      .maxTitleLength = 15,
611        .titlePosition = 1,
612  };  };
613    
614  struct configFileInfo yabootConfigType = {  struct configFileInfo yabootConfigType = {
# Line 370  struct configFileInfo yabootConfigType = Line 619  struct configFileInfo yabootConfigType =
619      .argsInQuotes = 1,      .argsInQuotes = 1,
620      .maxTitleLength = 15,      .maxTitleLength = 15,
621      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
622        .titlePosition = 1,
623  };  };
624    
625  struct configFileInfo siloConfigType = {  struct configFileInfo siloConfigType = {
# Line 379  struct configFileInfo siloConfigType = { Line 629  struct configFileInfo siloConfigType = {
629      .needsBootPrefix = 1,      .needsBootPrefix = 1,
630      .argsInQuotes = 1,      .argsInQuotes = 1,
631      .maxTitleLength = 15,      .maxTitleLength = 15,
632        .titlePosition = 1,
633  };  };
634    
635  struct configFileInfo ziplConfigType = {  struct configFileInfo ziplConfigType = {
# Line 392  struct configFileInfo ziplConfigType = { Line 643  struct configFileInfo ziplConfigType = {
643  struct configFileInfo extlinuxConfigType = {  struct configFileInfo extlinuxConfigType = {
644      .defaultConfig = "/boot/extlinux/extlinux.conf",      .defaultConfig = "/boot/extlinux/extlinux.conf",
645      .keywords = extlinuxKeywords,      .keywords = extlinuxKeywords,
646        .caseInsensitive = 1,
647      .entryStart = LT_TITLE,      .entryStart = LT_TITLE,
648      .needsBootPrefix = 1,      .needsBootPrefix = 1,
649      .maxTitleLength = 255,      .maxTitleLength = 255,
650      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
651        .defaultIsUnquoted = 1,
652        .titlePosition = 1,
653  };  };
654    
655  struct grubConfig {  struct grubConfig {
# Line 416  struct singleEntry * findEntryByIndex(st Line 670  struct singleEntry * findEntryByIndex(st
670  struct singleEntry * findEntryByPath(struct grubConfig * cfg,  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
671       const char * path, const char * prefix,       const char * path, const char * prefix,
672       int * index);       int * index);
673    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
674          int * index);
675  static int readFile(int fd, char ** bufPtr);  static int readFile(int fd, char ** bufPtr);
676  static void lineInit(struct singleLine * line);  static void lineInit(struct singleLine * line);
677  struct singleLine * lineDup(struct singleLine * line);  struct singleLine * lineDup(struct singleLine * line);
# Line 480  static char * sdupprintf(const char *for Line 736  static char * sdupprintf(const char *for
736      return buf;      return buf;
737  }  }
738    
739    static enum lineType_e preferredLineType(enum lineType_e type,
740     struct configFileInfo *cfi) {
741        if (isEfi && cfi == &grub2ConfigType) {
742     switch (type) {
743     case LT_KERNEL:
744        return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
745     case LT_INITRD:
746        return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
747     default:
748        return type;
749     }
750    #if defined(__i386__) || defined(__x86_64__)
751        } else if (cfi == &grub2ConfigType) {
752     switch (type) {
753     case LT_KERNEL:
754        return LT_KERNEL_16;
755     case LT_INITRD:
756        return LT_INITRD_16;
757     default:
758        return type;
759     }
760    #endif
761        }
762        return type;
763    }
764    
765  static struct keywordTypes * getKeywordByType(enum lineType_e type,  static struct keywordTypes * getKeywordByType(enum lineType_e type,
766        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
767      struct keywordTypes * kw;      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
     for (kw = cfi->keywords; kw->key; kw++) {  
768   if (kw->type == type)   if (kw->type == type)
769      return kw;      return kw;
770      }      }
# Line 513  static char * getuuidbydev(char *device) Line 794  static char * getuuidbydev(char *device)
794    
795  static enum lineType_e getTypeByKeyword(char * keyword,  static enum lineType_e getTypeByKeyword(char * keyword,
796   struct configFileInfo * cfi) {   struct configFileInfo * cfi) {
797      struct keywordTypes * kw;      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
798      for (kw = cfi->keywords; kw->key; kw++) {   if (cfi->caseInsensitive) {
799   if (!strcmp(keyword, kw->key))      if (!strcasecmp(keyword, kw->key))
800      return kw->type;                  return kw->type;
801     } else {
802        if (!strcmp(keyword, kw->key))
803            return kw->type;
804     }
805      }      }
806      return LT_UNKNOWN;      return LT_UNKNOWN;
807  }  }
# Line 553  static int isEntryStart(struct singleLin Line 838  static int isEntryStart(struct singleLin
838  }  }
839    
840  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
841  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
842      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it */
843      char * title;      char * title = NULL;
844      title = strdup(line->elements[0].item);      if (line->type == LT_TITLE) {
845      title++;   char *tmp = line->elements[cfg->cfi->titlePosition].item;
846      *(title + strlen(title) - 1) = '\0';   if (cfg->cfi->titleBracketed) {
847        tmp++;
848        title = strdup(tmp);
849        *(title + strlen(title) - 1) = '\0';
850     } else {
851        title = strdup(tmp);
852     }
853        } else if (line->type == LT_MENUENTRY)
854     title = strdup(line->elements[1].item);
855        else
856     return NULL;
857      return title;      return title;
858  }  }
859    
# Line 601  static void lineInit(struct singleLine * Line 896  static void lineInit(struct singleLine *
896  }  }
897    
898  struct singleLine * lineDup(struct singleLine * line) {  struct singleLine * lineDup(struct singleLine * line) {
     int i;  
899      struct singleLine * newLine = malloc(sizeof(*newLine));      struct singleLine * newLine = malloc(sizeof(*newLine));
900    
901      newLine->indent = strdup(line->indent);      newLine->indent = strdup(line->indent);
# Line 611  struct singleLine * lineDup(struct singl Line 905  struct singleLine * lineDup(struct singl
905      newLine->elements = malloc(sizeof(*newLine->elements) *      newLine->elements = malloc(sizeof(*newLine->elements) *
906         newLine->numElements);         newLine->numElements);
907    
908      for (i = 0; i < newLine->numElements; i++) {      for (int i = 0; i < newLine->numElements; i++) {
909   newLine->elements[i].indent = strdup(line->elements[i].indent);   newLine->elements[i].indent = strdup(line->elements[i].indent);
910   newLine->elements[i].item = strdup(line->elements[i].item);   newLine->elements[i].item = strdup(line->elements[i].item);
911      }      }
# Line 620  struct singleLine * lineDup(struct singl Line 914  struct singleLine * lineDup(struct singl
914  }  }
915    
916  static void lineFree(struct singleLine * line) {  static void lineFree(struct singleLine * line) {
     int i;  
   
917      if (line->indent) free(line->indent);      if (line->indent) free(line->indent);
918    
919      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
920   free(line->elements[i].item);   free(line->elements[i].item);
921   free(line->elements[i].indent);   free(line->elements[i].indent);
922      }      }
# Line 635  static void lineFree(struct singleLine * Line 927  static void lineFree(struct singleLine *
927    
928  static int lineWrite(FILE * out, struct singleLine * line,  static int lineWrite(FILE * out, struct singleLine * line,
929       struct configFileInfo * cfi) {       struct configFileInfo * cfi) {
     int i;  
   
930      if (fprintf(out, "%s", line->indent) == -1) return -1;      if (fprintf(out, "%s", line->indent) == -1) return -1;
931    
932      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
933     /* Need to handle this, because we strip the quotes from
934     * menuentry when read it. */
935     if (line->type == LT_MENUENTRY && i == 1) {
936        if(!isquote(*line->elements[i].item)) {
937     int substring = 0;
938     /* If the line contains nested quotes, we did not strip
939     * the "interna" quotes and we must use the right quotes
940     * again when writing the updated file. */
941     for (int j = i; j < line->numElements; j++) {
942        if (strchr(line->elements[i].item, '\'') != NULL) {
943           substring = 1;
944           fprintf(out, "\"%s\"", line->elements[i].item);
945           break;
946        }
947     }
948     if (!substring)
949        fprintf(out, "\'%s\'", line->elements[i].item);
950        } else {
951     fprintf(out, "%s", line->elements[i].item);
952        }
953        fprintf(out, "%s", line->elements[i].indent);
954    
955        continue;
956     }
957    
958   if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)   if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
959      if (fputc('"', out) == EOF) return -1;      if (fputc('"', out) == EOF) return -1;
960    
# Line 733  static int getNextLine(char ** bufPtr, s Line 1048  static int getNextLine(char ** bufPtr, s
1048      if (*line->elements[0].item == '#') {      if (*line->elements[0].item == '#') {
1049   char * fullLine;   char * fullLine;
1050   int len;   int len;
  int i;  
1051    
1052   len = strlen(line->indent);   len = strlen(line->indent);
1053   for (i = 0; i < line->numElements; i++)   for (int i = 0; i < line->numElements; i++)
1054      len += strlen(line->elements[i].item) +      len += strlen(line->elements[i].item) +
1055     strlen(line->elements[i].indent);     strlen(line->elements[i].indent);
1056    
# Line 745  static int getNextLine(char ** bufPtr, s Line 1059  static int getNextLine(char ** bufPtr, s
1059   free(line->indent);   free(line->indent);
1060   line->indent = fullLine;   line->indent = fullLine;
1061    
1062   for (i = 0; i < line->numElements; i++) {   for (int i = 0; i < line->numElements; i++) {
1063      strcat(fullLine, line->elements[i].item);      strcat(fullLine, line->elements[i].item);
1064      strcat(fullLine, line->elements[i].indent);      strcat(fullLine, line->elements[i].indent);
1065      free(line->elements[i].item);      free(line->elements[i].item);
# Line 764  static int getNextLine(char ** bufPtr, s Line 1078  static int getNextLine(char ** bufPtr, s
1078   * elements up more   * elements up more
1079   */   */
1080   if (!isspace(kw->separatorChar)) {   if (!isspace(kw->separatorChar)) {
     int i;  
1081      char indent[2] = "";      char indent[2] = "";
1082      indent[0] = kw->separatorChar;      indent[0] = kw->separatorChar;
1083      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
1084   char *p;   char *p;
  int j;  
1085   int numNewElements;   int numNewElements;
1086    
1087   numNewElements = 0;   numNewElements = 0;
# Line 785  static int getNextLine(char ** bufPtr, s Line 1097  static int getNextLine(char ** bufPtr, s
1097      sizeof(*line->elements) * elementsAlloced);      sizeof(*line->elements) * elementsAlloced);
1098   }   }
1099    
1100   for (j = line->numElements; j > i; j--) {   for (int j = line->numElements; j > i; j--) {
1101   line->elements[j + numNewElements] = line->elements[j];   line->elements[j + numNewElements] = line->elements[j];
1102   }   }
1103   line->numElements += numNewElements;   line->numElements += numNewElements;
# Line 798  static int getNextLine(char ** bufPtr, s Line 1110  static int getNextLine(char ** bufPtr, s
1110   break;   break;
1111   }   }
1112    
1113   free(line->elements[i].indent);   line->elements[i + 1].indent = line->elements[i].indent;
1114   line->elements[i].indent = strdup(indent);   line->elements[i].indent = strdup(indent);
1115   *p++ = '\0';   *p++ = '\0';
1116   i++;   i++;
1117   line->elements[i].item = strdup(p);   line->elements[i].item = strdup(p);
  line->elements[i].indent = strdup("");  
  p = line->elements[i].item;  
1118   }   }
1119      }      }
1120   }   }
# Line 814  static int getNextLine(char ** bufPtr, s Line 1124  static int getNextLine(char ** bufPtr, s
1124      return 0;      return 0;
1125  }  }
1126    
1127    static int isnumber(const char *s)
1128    {
1129        int i;
1130        for (i = 0; s[i] != '\0'; i++)
1131     if (s[i] < '0' || s[i] > '9')
1132        return 0;
1133        return i;
1134    }
1135    
1136  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
1137        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
1138      int in;      int in;
# Line 825  static struct grubConfig * readConfig(co Line 1144  static struct grubConfig * readConfig(co
1144      struct singleLine * last = NULL, * line, * defaultLine = NULL;      struct singleLine * last = NULL, * line, * defaultLine = NULL;
1145      char * end;      char * end;
1146      struct singleEntry * entry = NULL;      struct singleEntry * entry = NULL;
1147      int i, len;      int len;
1148      char * buf;      char * buf;
1149    
1150      if (!strcmp(inName, "-")) {      if (inName == NULL) {
1151            printf("Could not find bootloader configuration\n");
1152            exit(1);
1153        } else if (!strcmp(inName, "-")) {
1154   in = 0;   in = 0;
1155      } else {      } else {
1156   if ((in = open(inName, O_RDONLY)) < 0) {   if ((in = open(inName, O_RDONLY)) < 0) {
# Line 871  static struct grubConfig * readConfig(co Line 1193  static struct grubConfig * readConfig(co
1193      cfg->secondaryIndent = strdup(line->indent);      cfg->secondaryIndent = strdup(line->indent);
1194   }   }
1195    
1196   if (isEntryStart(line, cfi)) {   if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1197      sawEntry = 1;      sawEntry = 1;
1198      if (!entry) {      if (!entry) {
1199   cfg->entries = malloc(sizeof(*entry));   cfg->entries = malloc(sizeof(*entry));
# Line 888  static struct grubConfig * readConfig(co Line 1210  static struct grubConfig * readConfig(co
1210   }   }
1211    
1212   if (line->type == LT_SET_VARIABLE) {   if (line->type == LT_SET_VARIABLE) {
     int i;  
1213      dbgPrintf("found 'set' command (%d elements): ", line->numElements);      dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1214      dbgPrintf("%s", line->indent);      dbgPrintf("%s", line->indent);
1215      for (i = 0; i < line->numElements; i++)      for (int i = 0; i < line->numElements; i++)
1216   dbgPrintf("%s\"%s\"", line->elements[i].indent, line->elements[i].item);   dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1217      dbgPrintf("\n");      dbgPrintf("\n");
1218      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1219      if (kwType && line->numElements == 3 &&      if (kwType && line->numElements == 3 &&
1220      !strcmp(line->elements[1].item, kwType->key)) {      !strcmp(line->elements[1].item, kwType->key) &&
1221        !is_special_grub2_variable(line->elements[2].item)) {
1222   dbgPrintf("Line sets default config\n");   dbgPrintf("Line sets default config\n");
1223   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1224   defaultLine = line;   defaultLine = line;
1225      }      }
  } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
     cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
     defaultLine = line;  
1226    
1227          } else if (line->type == LT_KERNEL) {          } else if (iskernel(line->type)) {
1228      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
1229       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
1230       * instead of LT_KERNEL now       * instead of LT_KERNEL now
1231       */       */
1232      if (entry->multiboot)      if (entry && entry->multiboot)
1233   line->type = LT_HYPER;   line->type = LT_HYPER;
1234    
1235          } else if (line->type == LT_MBMODULE) {          } else if (line->type == LT_MBMODULE) {
# Line 919  static struct grubConfig * readConfig(co Line 1238  static struct grubConfig * readConfig(co
1238       * This only applies to grub, but that's the only place we       * This only applies to grub, but that's the only place we
1239       * should find LT_MBMODULE lines anyway.       * should find LT_MBMODULE lines anyway.
1240       */       */
1241      struct singleLine * l;      for (struct singleLine *l = entry->lines; l; l = l->next) {
     for (l = entry->lines; l; l = l->next) {  
1242   if (l->type == LT_HYPER)   if (l->type == LT_HYPER)
1243      break;      break;
1244   else if (l->type == LT_KERNEL) {   else if (iskernel(l->type)) {
1245      l->type = LT_HYPER;      l->type = LT_HYPER;
1246      break;      break;
1247   }   }
# Line 937  static struct grubConfig * readConfig(co Line 1255  static struct grubConfig * readConfig(co
1255      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1256      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
1257    
1258   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1259      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
1260        /* make the title/default a single argument (undoing our parsing) */
1261      len = 0;      len = 0;
1262      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
1263   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
1264   len += strlen(line->elements[i].indent);   len += strlen(line->elements[i].indent);
1265      }      }
1266      buf = malloc(len + 1);      buf = malloc(len + 1);
1267      *buf = '\0';      *buf = '\0';
1268    
1269      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
1270   strcat(buf, line->elements[i].item);   strcat(buf, line->elements[i].item);
1271   free(line->elements[i].item);   free(line->elements[i].item);
1272    
# Line 961  static struct grubConfig * readConfig(co Line 1280  static struct grubConfig * readConfig(co
1280      line->elements[line->numElements - 1].indent;      line->elements[line->numElements - 1].indent;
1281      line->elements[1].item = buf;      line->elements[1].item = buf;
1282      line->numElements = 2;      line->numElements = 2;
1283     } else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1284        /* let --remove-kernel="TITLE=what" work */
1285        len = 0;
1286        char *extras;
1287        char *title;
1288        /* initially unseen value */
1289        char quote_char = '\0';
1290    
1291        for (int i = 1; i < line->numElements; i++) {
1292     len += strlen(line->elements[i].item);
1293     len += strlen(line->elements[i].indent);
1294        }
1295        buf = malloc(len + 1);
1296        *buf = '\0';
1297    
1298        /* allocate mem for extra flags. */
1299        extras = malloc(len + 1);
1300        *extras = '\0';
1301    
1302        /* get title. */
1303        for (int i = 0; i < line->numElements; i++) {
1304     if (!strcmp(line->elements[i].item, "menuentry"))
1305        continue;
1306     if (isquote(*line->elements[i].item) && quote_char == '\0') {
1307        /* ensure we properly pair off quotes */
1308        quote_char = *line->elements[i].item;
1309        title = line->elements[i].item + 1;
1310     } else {
1311        title = line->elements[i].item;
1312     }
1313    
1314     len = strlen(title);
1315            if (title[len-1] == quote_char) {
1316        strncat(buf, title,len-1);
1317        break;
1318     } else {
1319        strcat(buf, title);
1320        strcat(buf, line->elements[i].indent);
1321     }
1322        }
1323    
1324        /* get extras */
1325        int count = 0;
1326        quote_char = '\0';
1327        for (int i = 0; i < line->numElements; i++) {
1328     if (count >= 2) {
1329        strcat(extras, line->elements[i].item);
1330        strcat(extras, line->elements[i].indent);
1331     }
1332    
1333     if (!strcmp(line->elements[i].item, "menuentry"))
1334        continue;
1335    
1336     /* count ' or ", there should be two in menuentry line. */
1337     if (isquote(*line->elements[i].item) && quote_char == '\0') {
1338        /* ensure we properly pair off quotes */
1339                quote_char = *line->elements[i].item;
1340        count++;
1341     }
1342    
1343     len = strlen(line->elements[i].item);
1344    
1345     if (line->elements[i].item[len -1] == quote_char)
1346        count++;
1347    
1348     /* ok, we get the final ' or ", others are extras. */
1349                }
1350        line->elements[1].indent =
1351     line->elements[line->numElements - 2].indent;
1352        line->elements[1].item = buf;
1353        line->elements[2].indent =
1354     line->elements[line->numElements - 2].indent;
1355        line->elements[2].item = extras;
1356        line->numElements = 3;
1357   } else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {   } else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1358      /* Strip off any " which may be present; they'll be put back      /* Strip off any " which may be present; they'll be put back
1359         on write. This is one of the few (the only?) places that grubby         on write. This is one of the few (the only?) places that grubby
# Line 970  static struct grubConfig * readConfig(co Line 1362  static struct grubConfig * readConfig(co
1362      if (line->numElements >= 2) {      if (line->numElements >= 2) {
1363   int last, len;   int last, len;
1364    
1365   if (*line->elements[1].item == '"')   if (isquote(*line->elements[1].item))
1366      memmove(line->elements[1].item, line->elements[1].item + 1,      memmove(line->elements[1].item, line->elements[1].item + 1,
1367      strlen(line->elements[1].item + 1) + 1);      strlen(line->elements[1].item + 1) + 1);
1368    
1369   last = line->numElements - 1;   last = line->numElements - 1;
1370   len = strlen(line->elements[last].item) - 1;   len = strlen(line->elements[last].item) - 1;
1371   if (line->elements[last].item[len] == '"')   if (isquote(line->elements[last].item[len]))
1372      line->elements[last].item[len] = '\0';      line->elements[last].item[len] = '\0';
1373      }      }
1374   }   }
1375    
1376     if (line->type == LT_DEFAULT && line->numElements == 2) {
1377        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1378        defaultLine = line;
1379     }
1380    
1381   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
1382     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
1383     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
# Line 1035  static struct grubConfig * readConfig(co Line 1432  static struct grubConfig * readConfig(co
1432    
1433      dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");      dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1434      if (defaultLine) {      if (defaultLine) {
1435   if (cfi->defaultIsVariable) {          if (defaultLine->numElements > 2 &&
1436        cfi->defaultSupportSaved &&
1437        !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1438     cfg->cfi->defaultIsSaved = 1;
1439     cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1440     if (cfg->cfi->getEnv) {
1441        char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1442        if (defTitle) {
1443     int index = 0;
1444     if (isnumber(defTitle)) {
1445        index = atoi(defTitle);
1446        entry = findEntryByIndex(cfg, index);
1447     } else {
1448        entry = findEntryByTitle(cfg, defTitle, &index);
1449     }
1450     if (entry)
1451        cfg->defaultImage = index;
1452        }
1453     }
1454     } else if (cfi->defaultIsVariable) {
1455      char *value = defaultLine->elements[2].item;      char *value = defaultLine->elements[2].item;
1456      while (*value && (*value == '"' || *value == '\'' ||      while (*value && (*value == '"' || *value == '\'' ||
1457      *value == ' ' || *value == '\t'))      *value == ' ' || *value == '\t'))
# Line 1052  static struct grubConfig * readConfig(co Line 1468  static struct grubConfig * readConfig(co
1468      cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);      cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1469      if (*end) cfg->defaultImage = -1;      if (*end) cfg->defaultImage = -1;
1470   } else if (defaultLine->numElements >= 2) {   } else if (defaultLine->numElements >= 2) {
1471      i = 0;      int i = 0;
1472      while ((entry = findEntryByIndex(cfg, i))) {      while ((entry = findEntryByIndex(cfg, i))) {
1473   for (line = entry->lines; line; line = line->next)   for (line = entry->lines; line; line = line->next)
1474      if (line->type == LT_TITLE) break;      if (line->type == LT_TITLE) break;
# Line 1063  static struct grubConfig * readConfig(co Line 1479  static struct grubConfig * readConfig(co
1479                                  line->elements[1].item)) break;                                  line->elements[1].item)) break;
1480                  } else if (line) {                  } else if (line) {
1481                      if (!strcmp(defaultLine->elements[1].item,                      if (!strcmp(defaultLine->elements[1].item,
1482                                  extractTitle(line))) break;                                  extractTitle(cfg, line))) break;
1483                  }                  }
1484   i++;   i++;
1485   entry = NULL;   entry = NULL;
# Line 1075  static struct grubConfig * readConfig(co Line 1491  static struct grubConfig * readConfig(co
1491          cfg->defaultImage = -1;          cfg->defaultImage = -1;
1492      }      }
1493   }   }
1494        } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1495     char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1496     if (defTitle) {
1497        int index = 0;
1498        if (isnumber(defTitle)) {
1499     index = atoi(defTitle);
1500     entry = findEntryByIndex(cfg, index);
1501        } else {
1502     entry = findEntryByTitle(cfg, defTitle, &index);
1503        }
1504        if (entry)
1505     cfg->defaultImage = index;
1506     }
1507      } else {      } else {
1508          cfg->defaultImage = 0;          cfg->defaultImage = 0;
1509      }      }
# Line 1092  static void writeDefault(FILE * out, cha Line 1521  static void writeDefault(FILE * out, cha
1521    
1522      if (cfg->defaultImage == DEFAULT_SAVED)      if (cfg->defaultImage == DEFAULT_SAVED)
1523   fprintf(out, "%sdefault%ssaved\n", indent, separator);   fprintf(out, "%sdefault%ssaved\n", indent, separator);
1524      else if (cfg->defaultImage > -1) {      else if (cfg->cfi->defaultIsSaved) {
1525     fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1526     if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1527        char *title;
1528        entry = findEntryByIndex(cfg, cfg->defaultImage);
1529        line = getLineByType(LT_MENUENTRY, entry->lines);
1530        if (!line)
1531     line = getLineByType(LT_TITLE, entry->lines);
1532        if (line) {
1533     title = extractTitle(cfg, line);
1534     if (title)
1535        cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1536        }
1537     }
1538        } else if (cfg->defaultImage > -1) {
1539   if (cfg->cfi->defaultIsIndex) {   if (cfg->cfi->defaultIsIndex) {
1540      if (cfg->cfi->defaultIsVariable) {      if (cfg->cfi->defaultIsVariable) {
1541          fprintf(out, "%sset default=\"%d\"\n", indent,          fprintf(out, "%sset default=\"%d\"\n", indent,
# Line 1125  static void writeDefault(FILE * out, cha Line 1568  static void writeDefault(FILE * out, cha
1568              else if (line && (line->numElements == 1) &&              else if (line && (line->numElements == 1) &&
1569                       cfg->cfi->titleBracketed) {                       cfg->cfi->titleBracketed) {
1570   fprintf(out, "%sdefault%s%s\n", indent, separator,   fprintf(out, "%sdefault%s%s\n", indent, separator,
1571                          extractTitle(line));                          extractTitle(cfg, line));
1572              }              }
1573   }   }
1574      }      }
# Line 1152  static int writeConfig(struct grubConfig Line 1595  static int writeConfig(struct grubConfig
1595    
1596      /* most likely the symlink is relative, so change our      /* most likely the symlink is relative, so change our
1597         directory to the dir of the symlink */         directory to the dir of the symlink */
1598              rc = chdir(dirname(strdupa(outName)));      char *dir = strdupa(outName);
1599        rc = chdir(dirname(dir));
1600      do {      do {
1601   buf = alloca(len + 1);   buf = alloca(len + 1);
1602   rc = readlink(basename(outName), buf, len);   rc = readlink(basename(outName), buf, len);
# Line 1194  static int writeConfig(struct grubConfig Line 1638  static int writeConfig(struct grubConfig
1638      while (line) {      while (line) {
1639          if (line->type == LT_SET_VARIABLE && defaultKw &&          if (line->type == LT_SET_VARIABLE && defaultKw &&
1640   line->numElements == 3 &&   line->numElements == 3 &&
1641   !strcmp(line->elements[1].item, defaultKw->key)) {   !strcmp(line->elements[1].item, defaultKw->key) &&
1642     !is_special_grub2_variable(line->elements[2].item)) {
1643      writeDefault(out, line->indent, line->elements[0].indent, cfg);      writeDefault(out, line->indent, line->elements[0].indent, cfg);
1644      needs &= ~MAIN_DEFAULT;      needs &= ~MAIN_DEFAULT;
1645   } else if (line->type == LT_DEFAULT) {   } else if (line->type == LT_DEFAULT) {
# Line 1290  static char *findDiskForRoot() Line 1735  static char *findDiskForRoot()
1735      buf[rc] = '\0';      buf[rc] = '\0';
1736      chptr = buf;      chptr = buf;
1737    
1738        char *foundanswer = NULL;
1739    
1740      while (chptr && chptr != buf+rc) {      while (chptr && chptr != buf+rc) {
1741          devname = chptr;          devname = chptr;
1742    
# Line 1317  static char *findDiskForRoot() Line 1764  static char *findDiskForRoot()
1764           * for '/' obviously.           * for '/' obviously.
1765           */           */
1766          if (*(++chptr) == '/' && *(++chptr) == ' ') {          if (*(++chptr) == '/' && *(++chptr) == ' ') {
1767              /*              /* remember the last / entry in mtab */
1768               * Move back 2, which is the first space after the device name, set             foundanswer = devname;
              * it to \0 so strdup will just get the devicename.  
              */  
             chptr -= 2;  
             *chptr = '\0';  
             return strdup(devname);  
1769          }          }
1770    
1771          /* Next line */          /* Next line */
# Line 1332  static char *findDiskForRoot() Line 1774  static char *findDiskForRoot()
1774              chptr++;              chptr++;
1775      }      }
1776    
1777        /* Return the last / entry found */
1778        if (foundanswer) {
1779            chptr = strchr(foundanswer, ' ');
1780            *chptr = '\0';
1781            return strdup(foundanswer);
1782        }
1783    
1784      return NULL;      return NULL;
1785  }  }
1786    
1787    void printEntry(struct singleEntry * entry, FILE *f) {
1788        int i;
1789        struct singleLine * line;
1790    
1791        for (line = entry->lines; line; line = line->next) {
1792     log_message(f, "DBG: %s", line->indent);
1793     for (i = 0; i < line->numElements; i++) {
1794        /* Need to handle this, because we strip the quotes from
1795         * menuentry when read it. */
1796        if (line->type == LT_MENUENTRY && i == 1) {
1797     if(!isquote(*line->elements[i].item))
1798        log_message(f, "\'%s\'", line->elements[i].item);
1799     else
1800        log_message(f, "%s", line->elements[i].item);
1801     log_message(f, "%s", line->elements[i].indent);
1802    
1803     continue;
1804        }
1805        
1806        log_message(f, "%s%s",
1807        line->elements[i].item, line->elements[i].indent);
1808     }
1809     log_message(f, "\n");
1810        }
1811    }
1812    
1813    void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1814    {
1815        static int once;
1816        va_list argp, argq;
1817    
1818        va_start(argp, fmt);
1819    
1820        va_copy(argq, argp);
1821        if (!once) {
1822     log_time(NULL);
1823     log_message(NULL, "command line: %s\n", saved_command_line);
1824        }
1825        log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1826        log_vmessage(NULL, fmt, argq);
1827    
1828        printEntry(entry, NULL);
1829        va_end(argq);
1830    
1831        if (!debug) {
1832     once = 1;
1833         va_end(argp);
1834     return;
1835        }
1836    
1837        if (okay) {
1838     va_end(argp);
1839     return;
1840        }
1841    
1842        if (!once)
1843     log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1844        once = 1;
1845        fprintf(stderr, "DBG: Image entry failed: ");
1846        vfprintf(stderr, fmt, argp);
1847        printEntry(entry, stderr);
1848        va_end(argp);
1849    }
1850    
1851    #define beginswith(s, c) ((s) && (s)[0] == (c))
1852    
1853    static int endswith(const char *s, char c)
1854    {
1855     int slen;
1856    
1857     if (!s || !s[0])
1858     return 0;
1859     slen = strlen(s) - 1;
1860    
1861     return s[slen] == c;
1862    }
1863    
1864  int suitableImage(struct singleEntry * entry, const char * bootPrefix,  int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1865    int skipRemoved, int flags) {    int skipRemoved, int flags) {
1866      struct singleLine * line;      struct singleLine * line;
# Line 1344  int suitableImage(struct singleEntry * e Line 1870  int suitableImage(struct singleEntry * e
1870      char * rootspec;      char * rootspec;
1871      char * rootdev;      char * rootdev;
1872    
1873      if (skipRemoved && entry->skip) return 0;      if (skipRemoved && entry->skip) {
1874     notSuitablePrintf(entry, 0, "marked to skip\n");
1875     return 0;
1876        }
1877    
1878      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1879      if (!line || line->numElements < 2) return 0;      if (!line) {
1880     notSuitablePrintf(entry, 0, "no line found\n");
1881     return 0;
1882        }
1883        if (line->numElements < 2) {
1884     notSuitablePrintf(entry, 0, "line has only %d elements\n",
1885        line->numElements);
1886     return 0;
1887        }
1888    
1889      if (flags & GRUBBY_BADIMAGE_OKAY) return 1;      if (flags & GRUBBY_BADIMAGE_OKAY) {
1890        notSuitablePrintf(entry, 1, "\n");
1891        return 1;
1892        }
1893    
1894      fullName = alloca(strlen(bootPrefix) +      fullName = alloca(strlen(bootPrefix) +
1895        strlen(line->elements[1].item) + 1);        strlen(line->elements[1].item) + 1);
1896      rootspec = getRootSpecifier(line->elements[1].item);      rootspec = getRootSpecifier(line->elements[1].item);
1897      sprintf(fullName, "%s%s", bootPrefix,      int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1898              line->elements[1].item + (rootspec ? strlen(rootspec) : 0));      int hasslash = endswith(bootPrefix, '/') ||
1899      if (access(fullName, R_OK)) return 0;       beginswith(line->elements[1].item + rootspec_offset, '/');
1900        sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1901                line->elements[1].item + rootspec_offset);
1902        if (access(fullName, R_OK)) {
1903     notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1904     return 0;
1905        }
1906      for (i = 2; i < line->numElements; i++)      for (i = 2; i < line->numElements; i++)
1907   if (!strncasecmp(line->elements[i].item, "root=", 5)) break;   if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1908      if (i < line->numElements) {      if (i < line->numElements) {
# Line 1375  int suitableImage(struct singleEntry * e Line 1920  int suitableImage(struct singleEntry * e
1920      line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);      line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
1921    
1922              /* failed to find one */              /* failed to find one */
1923              if (!line) return 0;              if (!line) {
1924     notSuitablePrintf(entry, 0, "no line found\n");
1925     return 0;
1926                }
1927    
1928      for (i = 1; i < line->numElements; i++)      for (i = 1; i < line->numElements; i++)
1929          if (!strncasecmp(line->elements[i].item, "root=", 5)) break;          if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1930      if (i < line->numElements)      if (i < line->numElements)
1931          dev = line->elements[i].item + 5;          dev = line->elements[i].item + 5;
1932      else {      else {
1933     notSuitablePrintf(entry, 0, "no root= entry found\n");
1934   /* it failed too...  can't find root= */   /* it failed too...  can't find root= */
1935          return 0;          return 0;
1936              }              }
# Line 1389  int suitableImage(struct singleEntry * e Line 1938  int suitableImage(struct singleEntry * e
1938      }      }
1939    
1940      dev = getpathbyspec(dev);      dev = getpathbyspec(dev);
1941      if (!dev)      if (!getpathbyspec(dev)) {
1942            notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1943          return 0;          return 0;
1944        } else
1945     dev = getpathbyspec(dev);
1946    
1947      rootdev = findDiskForRoot();      rootdev = findDiskForRoot();
1948      if (!rootdev)      if (!rootdev) {
1949            notSuitablePrintf(entry, 0, "can't find root device\n");
1950   return 0;   return 0;
1951        }
1952    
1953      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1954            notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1955     getuuidbydev(rootdev), getuuidbydev(dev));
1956          free(rootdev);          free(rootdev);
1957          return 0;          return 0;
1958      }      }
1959    
1960      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1961            notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1962     getuuidbydev(rootdev), getuuidbydev(dev));
1963   free(rootdev);   free(rootdev);
1964          return 0;          return 0;
1965      }      }
1966    
1967      free(rootdev);      free(rootdev);
1968        notSuitablePrintf(entry, 1, "\n");
1969    
1970      return 1;      return 1;
1971  }  }
# Line 1440  struct singleEntry * findEntryByPath(str Line 1999  struct singleEntry * findEntryByPath(str
1999   }   }
2000    
2001   indexVars[i + 1] = -1;   indexVars[i + 1] = -1;
2002    
2003   i = 0;   i = 0;
2004   if (index) {   if (index) {
2005      while (i < *index) i++;      while (i < *index) {
2006      if (indexVars[i] == -1) return NULL;   i++;
2007     if (indexVars[i] == -1) return NULL;
2008        }
2009   }   }
2010    
2011   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
2012   if (!entry) return NULL;   if (!entry) return NULL;
2013    
2014   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2015   if (!line) return NULL;   if (!line) return NULL;
2016    
2017   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
# Line 1488  struct singleEntry * findEntryByPath(str Line 2049  struct singleEntry * findEntryByPath(str
2049    
2050   if (!strncmp(kernel, "TITLE=", 6)) {   if (!strncmp(kernel, "TITLE=", 6)) {
2051      prefix = "";      prefix = "";
2052      checkType = LT_TITLE;      checkType = LT_TITLE|LT_MENUENTRY;
2053      kernel += 6;      kernel += 6;
2054   }   }
2055    
# Line 1499  struct singleEntry * findEntryByPath(str Line 2060  struct singleEntry * findEntryByPath(str
2060    
2061      /* check all the lines matching checkType */      /* check all the lines matching checkType */
2062      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
2063   line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?   enum lineType_e ct = checkType;
2064       LT_KERNEL|LT_MBMODULE|LT_HYPER :   if (entry->multiboot && checkType == LT_KERNEL)
2065       checkType, line);      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2066   if (!line) break;  /* not found in this entry */   else if (checkType & LT_KERNEL)
2067        ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2068     line = getLineByType(ct, line);
2069     if (!line)
2070        break;  /* not found in this entry */
2071    
2072   if (line && line->numElements >= 2) {   if (line && line->type != LT_MENUENTRY &&
2073     line->numElements >= 2) {
2074      rootspec = getRootSpecifier(line->elements[1].item);      rootspec = getRootSpecifier(line->elements[1].item);
2075      if (!strcmp(line->elements[1].item +      if (!strcmp(line->elements[1].item +
2076   ((rootspec != NULL) ? strlen(rootspec) : 0),   ((rootspec != NULL) ? strlen(rootspec) : 0),
2077   kernel + strlen(prefix)))   kernel + strlen(prefix)))
2078   break;   break;
2079   }   }
2080     if(line->type == LT_MENUENTRY &&
2081     !strcmp(line->elements[1].item, kernel))
2082        break;
2083      }      }
2084    
2085      /* make sure this entry has a kernel identifier; this skips      /* make sure this entry has a kernel identifier; this skips
2086       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
2087       * unfortunate)       * unfortunate)
2088       */       */
2089      if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2090   break; /* found 'im! */   break; /* found 'im! */
2091   }   }
2092    
# Line 1527  struct singleEntry * findEntryByPath(str Line 2096  struct singleEntry * findEntryByPath(str
2096      return entry;      return entry;
2097  }  }
2098    
2099    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2100          int * index) {
2101        struct singleEntry * entry;
2102        struct singleLine * line;
2103        int i;
2104        char * newtitle;
2105    
2106        for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2107     if (index && i < *index)
2108        continue;
2109     line = getLineByType(LT_TITLE, entry->lines);
2110     if (!line)
2111        line = getLineByType(LT_MENUENTRY, entry->lines);
2112     if (!line)
2113        continue;
2114     newtitle = grub2ExtractTitle(line);
2115     if (!newtitle)
2116        continue;
2117     if (!strcmp(title, newtitle))
2118        break;
2119        }
2120    
2121        if (!entry)
2122     return NULL;
2123    
2124        if (index)
2125     *index = i;
2126        return entry;
2127    }
2128    
2129  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2130      struct singleEntry * entry;      struct singleEntry * entry;
2131    
# Line 1549  struct singleEntry * findTemplate(struct Line 2148  struct singleEntry * findTemplate(struct
2148      struct singleEntry * entry, * entry2;      struct singleEntry * entry, * entry2;
2149      int index;      int index;
2150    
2151      if (cfg->defaultImage > -1) {      if (cfg->cfi->defaultIsSaved) {
2152     if (cfg->cfi->getEnv) {
2153        char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2154        if (defTitle) {
2155     int index = 0;
2156     if (isnumber(defTitle)) {
2157        index = atoi(defTitle);
2158        entry = findEntryByIndex(cfg, index);
2159     } else {
2160        entry = findEntryByTitle(cfg, defTitle, &index);
2161     }
2162     if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2163        cfg->defaultImage = index;
2164        if (indexPtr)
2165     *indexPtr = index;
2166        return entry;
2167     }
2168        }
2169     }
2170        } else if (cfg->defaultImage > -1) {
2171   entry = findEntryByIndex(cfg, cfg->defaultImage);   entry = findEntryByIndex(cfg, cfg->defaultImage);
2172   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2173      if (indexPtr) *indexPtr = cfg->defaultImage;      if (indexPtr) *indexPtr = cfg->defaultImage;
# Line 1602  void markRemovedImage(struct grubConfig Line 2220  void markRemovedImage(struct grubConfig
2220        const char * prefix) {        const char * prefix) {
2221      struct singleEntry * entry;      struct singleEntry * entry;
2222    
2223      if (!image) return;      if (!image)
2224     return;
2225    
2226        /* check and see if we're removing the default image */
2227        if (isdigit(*image)) {
2228     entry = findEntryByPath(cfg, image, prefix, NULL);
2229     if(entry)
2230        entry->skip = 1;
2231     return;
2232        }
2233    
2234      while ((entry = findEntryByPath(cfg, image, prefix, NULL)))      while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2235   entry->skip = 1;   entry->skip = 1;
# Line 1610  void markRemovedImage(struct grubConfig Line 2237  void markRemovedImage(struct grubConfig
2237    
2238  void setDefaultImage(struct grubConfig * config, int hasNew,  void setDefaultImage(struct grubConfig * config, int hasNew,
2239       const char * defaultKernelPath, int newIsDefault,       const char * defaultKernelPath, int newIsDefault,
2240       const char * prefix, int flags) {       const char * prefix, int flags, int index) {
2241      struct singleEntry * entry, * entry2, * newDefault;      struct singleEntry * entry, * entry2, * newDefault;
2242      int i, j;      int i, j;
2243    
2244      if (newIsDefault) {      if (newIsDefault) {
2245   config->defaultImage = 0;   config->defaultImage = 0;
2246   return;   return;
2247        } else if ((index >= 0) && config->cfi->defaultIsIndex) {
2248     if (findEntryByIndex(config, index))
2249        config->defaultImage = index;
2250     else
2251        config->defaultImage = -1;
2252     return;
2253      } else if (defaultKernelPath) {      } else if (defaultKernelPath) {
2254   i = 0;   i = 0;
2255   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
# Line 1629  void setDefaultImage(struct grubConfig * Line 2262  void setDefaultImage(struct grubConfig *
2262    
2263      /* defaultImage now points to what we'd like to use, but before any order      /* defaultImage now points to what we'd like to use, but before any order
2264         changes */         changes */
2265      if (config->defaultImage == DEFAULT_SAVED)      if ((config->defaultImage == DEFAULT_SAVED) ||
2266     (config->defaultImage == DEFAULT_SAVED_GRUB2))
2267        /* default is set to saved, we don't want to change it */        /* default is set to saved, we don't want to change it */
2268        return;        return;
2269    
# Line 1687  void displayEntry(struct singleEntry * e Line 2321  void displayEntry(struct singleEntry * e
2321      struct singleLine * line;      struct singleLine * line;
2322      char * root = NULL;      char * root = NULL;
2323      int i;      int i;
2324        int j;
2325    
2326      printf("index=%d\n", index);      printf("index=%d\n", index);
2327    
2328      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2329      if (!line) {      if (!line) {
2330          printf("non linux entry\n");          printf("non linux entry\n");
2331          return;          return;
2332      }      }
2333    
2334      printf("kernel=%s\n", line->elements[1].item);      if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2335     printf("kernel=%s\n", line->elements[1].item);
2336        else
2337     printf("kernel=%s%s\n", prefix, line->elements[1].item);
2338    
2339      if (line->numElements >= 3) {      if (line->numElements >= 3) {
2340   printf("args=\"");   printf("args=\"");
# Line 1752  void displayEntry(struct singleEntry * e Line 2390  void displayEntry(struct singleEntry * e
2390   printf("root=%s\n", s);   printf("root=%s\n", s);
2391      }      }
2392    
2393      line = getLineByType(LT_INITRD, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2394    
2395      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
2396   printf("initrd=%s", prefix);   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2397        printf("initrd=");
2398     else
2399        printf("initrd=%s", prefix);
2400    
2401   for (i = 1; i < line->numElements; i++)   for (i = 1; i < line->numElements; i++)
2402      printf("%s%s", line->elements[i].item, line->elements[i].indent);      printf("%s%s", line->elements[i].item, line->elements[i].indent);
2403   printf("\n");   printf("\n");
2404      }      }
2405    
2406        line = getLineByType(LT_TITLE, entry->lines);
2407        if (line) {
2408     printf("title=%s\n", line->elements[1].item);
2409        } else {
2410     char * title;
2411     line = getLineByType(LT_MENUENTRY, entry->lines);
2412     if (line) {
2413        title = grub2ExtractTitle(line);
2414        if (title)
2415     printf("title=%s\n", title);
2416     }
2417        }
2418    
2419        for (j = 0, line = entry->lines; line; line = line->next) {
2420     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2421        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2422     printf("mbmodule%d=", j);
2423        else
2424     printf("mbmodule%d=%s", j, prefix);
2425    
2426        for (i = 1; i < line->numElements; i++)
2427     printf("%s%s", line->elements[i].item, line->elements[i].indent);
2428        printf("\n");
2429        j++;
2430     }
2431        }
2432    }
2433    
2434    int isSuseSystem(void) {
2435        const char * path;
2436        const static char default_path[] = "/etc/SuSE-release";
2437    
2438        if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2439     path = default_path;
2440    
2441        if (!access(path, R_OK))
2442     return 1;
2443        return 0;
2444    }
2445    
2446    int isSuseGrubConf(const char * path) {
2447        FILE * grubConf;
2448        char * line = NULL;
2449        size_t len = 0, res = 0;
2450    
2451        grubConf = fopen(path, "r");
2452        if (!grubConf) {
2453            dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2454     return 0;
2455        }
2456    
2457        while ((res = getline(&line, &len, grubConf)) != -1) {
2458     if (!strncmp(line, "setup", 5)) {
2459        fclose(grubConf);
2460        free(line);
2461        return 1;
2462     }
2463        }
2464    
2465        dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2466          path);
2467    
2468        fclose(grubConf);
2469        free(line);
2470        return 0;
2471    }
2472    
2473    int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2474        FILE * grubConf;
2475        char * line = NULL;
2476        size_t res = 0, len = 0;
2477    
2478        if (!path) return 1;
2479        if (!lbaPtr) return 1;
2480    
2481        grubConf = fopen(path, "r");
2482        if (!grubConf) return 1;
2483    
2484        while ((res = getline(&line, &len, grubConf)) != -1) {
2485     if (line[res - 1] == '\n')
2486        line[res - 1] = '\0';
2487     else if (len > res)
2488        line[res] = '\0';
2489     else {
2490        line = realloc(line, res + 1);
2491        line[res] = '\0';
2492     }
2493    
2494     if (!strncmp(line, "setup", 5)) {
2495        if (strstr(line, "--force-lba")) {
2496            *lbaPtr = 1;
2497        } else {
2498            *lbaPtr = 0;
2499        }
2500        dbgPrintf("lba: %i\n", *lbaPtr);
2501        break;
2502     }
2503        }
2504    
2505        free(line);
2506        fclose(grubConf);
2507        return 0;
2508    }
2509    
2510    int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2511        FILE * grubConf;
2512        char * line = NULL;
2513        size_t res = 0, len = 0;
2514        char * lastParamPtr = NULL;
2515        char * secLastParamPtr = NULL;
2516        char installDeviceNumber = '\0';
2517        char * bounds = NULL;
2518    
2519        if (!path) return 1;
2520        if (!devicePtr) return 1;
2521    
2522        grubConf = fopen(path, "r");
2523        if (!grubConf) return 1;
2524    
2525        while ((res = getline(&line, &len, grubConf)) != -1) {
2526     if (strncmp(line, "setup", 5))
2527        continue;
2528    
2529     if (line[res - 1] == '\n')
2530        line[res - 1] = '\0';
2531     else if (len > res)
2532        line[res] = '\0';
2533     else {
2534        line = realloc(line, res + 1);
2535        line[res] = '\0';
2536     }
2537    
2538     lastParamPtr = bounds = line + res;
2539    
2540     /* Last parameter in grub may be an optional IMAGE_DEVICE */
2541     while (!isspace(*lastParamPtr))
2542        lastParamPtr--;
2543     lastParamPtr++;
2544    
2545     secLastParamPtr = lastParamPtr - 2;
2546     dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2547    
2548     if (lastParamPtr + 3 > bounds) {
2549        dbgPrintf("lastParamPtr going over boundary");
2550        fclose(grubConf);
2551        free(line);
2552        return 1;
2553     }
2554     if (!strncmp(lastParamPtr, "(hd", 3))
2555        lastParamPtr += 3;
2556     dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2557    
2558     /*
2559     * Second last parameter will decide wether last parameter is
2560     * an IMAGE_DEVICE or INSTALL_DEVICE
2561     */
2562     while (!isspace(*secLastParamPtr))
2563        secLastParamPtr--;
2564     secLastParamPtr++;
2565    
2566     if (secLastParamPtr + 3 > bounds) {
2567        dbgPrintf("secLastParamPtr going over boundary");
2568        fclose(grubConf);
2569        free(line);
2570        return 1;
2571     }
2572     dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2573     if (!strncmp(secLastParamPtr, "(hd", 3)) {
2574        secLastParamPtr += 3;
2575        dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2576        installDeviceNumber = *secLastParamPtr;
2577     } else {
2578        installDeviceNumber = *lastParamPtr;
2579     }
2580    
2581     *devicePtr = malloc(6);
2582     snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2583     dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2584     fclose(grubConf);
2585     free(line);
2586     return 0;
2587        }
2588    
2589        free(line);
2590        fclose(grubConf);
2591        return 1;
2592    }
2593    
2594    int grubGetBootFromDeviceMap(const char * device,
2595         char ** bootPtr) {
2596        FILE * deviceMap;
2597        char * line = NULL;
2598        size_t res = 0, len = 0;
2599        char * devicePtr;
2600        char * bounds = NULL;
2601        const char * path;
2602        const static char default_path[] = "/boot/grub/device.map";
2603    
2604        if (!device) return 1;
2605        if (!bootPtr) return 1;
2606    
2607        if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2608     path = default_path;
2609    
2610        dbgPrintf("opening grub device.map file from: %s\n", path);
2611        deviceMap = fopen(path, "r");
2612        if (!deviceMap)
2613     return 1;
2614    
2615        while ((res = getline(&line, &len, deviceMap)) != -1) {
2616            if (!strncmp(line, "#", 1))
2617        continue;
2618    
2619     if (line[res - 1] == '\n')
2620        line[res - 1] = '\0';
2621     else if (len > res)
2622        line[res] = '\0';
2623     else {
2624        line = realloc(line, res + 1);
2625        line[res] = '\0';
2626     }
2627    
2628     devicePtr = line;
2629     bounds = line + res;
2630    
2631     while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2632        devicePtr++;
2633     dbgPrintf("device: %s\n", devicePtr);
2634    
2635     if (!strncmp(devicePtr, device, strlen(device))) {
2636        devicePtr += strlen(device);
2637        while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2638            devicePtr++;
2639    
2640        *bootPtr = strdup(devicePtr);
2641        break;
2642     }
2643        }
2644    
2645        free(line);
2646        fclose(deviceMap);
2647        return 0;
2648    }
2649    
2650    int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2651        char * grubDevice;
2652    
2653        if (suseGrubConfGetInstallDevice(path, &grubDevice))
2654     dbgPrintf("error looking for grub installation device\n");
2655        else
2656     dbgPrintf("grubby installation device: %s\n", grubDevice);
2657    
2658        if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2659     dbgPrintf("error looking for grub boot device\n");
2660        else
2661     dbgPrintf("grubby boot device: %s\n", *bootPtr);
2662    
2663        free(grubDevice);
2664        return 0;
2665    }
2666    
2667    int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2668        /*
2669         * This SuSE grub configuration file at this location is not your average
2670         * grub configuration file, but instead the grub commands used to setup
2671         * grub on that system.
2672         */
2673        const char * path;
2674        const static char default_path[] = "/etc/grub.conf";
2675    
2676        if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2677     path = default_path;
2678    
2679        if (!isSuseGrubConf(path)) return 1;
2680    
2681        if (lbaPtr) {
2682            *lbaPtr = 0;
2683            if (suseGrubConfGetLba(path, lbaPtr))
2684                return 1;
2685        }
2686    
2687        if (bootPtr) {
2688            *bootPtr = NULL;
2689            suseGrubConfGetBoot(path, bootPtr);
2690        }
2691    
2692        return 0;
2693  }  }
2694    
2695  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
# Line 1810  int parseSysconfigGrub(int * lbaPtr, cha Line 2740  int parseSysconfigGrub(int * lbaPtr, cha
2740  }  }
2741    
2742  void dumpSysconfigGrub(void) {  void dumpSysconfigGrub(void) {
2743      char * boot;      char * boot = NULL;
2744      int lba;      int lba;
2745    
2746      if (!parseSysconfigGrub(&lba, &boot)) {      if (isSuseSystem()) {
2747   if (lba) printf("lba\n");          if (parseSuseGrubConf(&lba, &boot)) {
2748   if (boot) printf("boot=%s\n", boot);      free(boot);
2749        return;
2750     }
2751        } else {
2752            if (parseSysconfigGrub(&lba, &boot)) {
2753        free(boot);
2754        return;
2755     }
2756        }
2757    
2758        if (lba) printf("lba\n");
2759        if (boot) {
2760     printf("boot=%s\n", boot);
2761     free(boot);
2762      }      }
2763  }  }
2764    
# Line 1864  struct singleLine * addLineTmpl(struct s Line 2807  struct singleLine * addLineTmpl(struct s
2807  {  {
2808      struct singleLine * newLine = lineDup(tmplLine);      struct singleLine * newLine = lineDup(tmplLine);
2809    
2810        if (isEfi && cfi == &grub2ConfigType) {
2811     enum lineType_e old = newLine->type;
2812     newLine->type = preferredLineType(newLine->type, cfi);
2813     if (old != newLine->type)
2814        newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2815        }
2816    
2817      if (val) {      if (val) {
2818   /* override the inherited value with our own.   /* override the inherited value with our own.
2819   * This is a little weak because it only applies to elements[1]   * This is a little weak because it only applies to elements[1]
# Line 1873  struct singleLine * addLineTmpl(struct s Line 2823  struct singleLine * addLineTmpl(struct s
2823   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
2824    
2825   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
2826   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
2827      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2828      if (rootspec != NULL) {      if (rootspec != NULL) {
2829   free(newLine->elements[1].item);   free(newLine->elements[1].item);
# Line 1910  struct singleLine *  addLine(struct sing Line 2860  struct singleLine *  addLine(struct sing
2860      /* NB: This function shouldn't allocate items on the heap, rather on the      /* NB: This function shouldn't allocate items on the heap, rather on the
2861       * stack since it calls addLineTmpl which will make copies.       * stack since it calls addLineTmpl which will make copies.
2862       */       */
   
2863      if (type == LT_TITLE && cfi->titleBracketed) {      if (type == LT_TITLE && cfi->titleBracketed) {
2864   /* we're doing a bracketed title (zipl) */   /* we're doing a bracketed title (zipl) */
2865   tmpl.type = type;   tmpl.type = type;
# Line 2014  void removeLine(struct singleEntry * ent Line 2963  void removeLine(struct singleEntry * ent
2963      free(line);      free(line);
2964  }  }
2965    
 static int isquote(char q)  
 {  
     if (q == '\'' || q == '\"')  
  return 1;  
     return 0;  
 }  
   
2966  static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)  static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2967  {  {
2968      struct singleLine newLine = {      struct singleLine newLine = {
# Line 2251  int updateActualImage(struct grubConfig Line 3193  int updateActualImage(struct grubConfig
3193      firstElement = 2;      firstElement = 2;
3194    
3195   } else {   } else {
3196      line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3197      if (!line) {      if (!line) {
3198   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
3199   continue;   continue;
# Line 2407  int updateImage(struct grubConfig * cfg, Line 3349  int updateImage(struct grubConfig * cfg,
3349      return rc;      return rc;
3350  }  }
3351    
3352    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3353     const char * image, const char * prefix, const char * initrd,
3354     const char * title) {
3355        struct singleEntry * entry;
3356        struct singleLine * line, * kernelLine, *endLine = NULL;
3357        int index = 0;
3358    
3359        if (!image) return 0;
3360    
3361        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3362            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3363            if (!kernelLine) continue;
3364    
3365     /* if title is supplied, the entry's title must match it. */
3366     if (title) {
3367        char *linetitle;
3368    
3369        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3370        if (!line)
3371     continue;
3372    
3373        linetitle = extractTitle(cfg, line);
3374        if (!linetitle)
3375     continue;
3376        if (strcmp(title, linetitle)) {
3377     free(linetitle);
3378     continue;
3379        }
3380        free(linetitle);
3381     }
3382    
3383            if (prefix) {
3384                int prefixLen = strlen(prefix);
3385                if (!strncmp(initrd, prefix, prefixLen))
3386                    initrd += prefixLen;
3387            }
3388     endLine = getLineByType(LT_ENTRY_END, entry->lines);
3389     if (endLine)
3390        removeLine(entry, endLine);
3391            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3392     kernelLine->indent, initrd);
3393            if (!line)
3394        return 1;
3395     if (endLine) {
3396        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3397                if (!line)
3398     return 1;
3399     }
3400    
3401            break;
3402        }
3403    
3404        return 0;
3405    }
3406    
3407  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
3408                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd, const char * title) {
3409      struct singleEntry * entry;      struct singleEntry * entry;
3410      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
3411      int index = 0;      int index = 0;
# Line 2416  int updateInitrd(struct grubConfig * cfg Line 3413  int updateInitrd(struct grubConfig * cfg
3413      if (!image) return 0;      if (!image) return 0;
3414    
3415      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3416          kernelLine = getLineByType(LT_KERNEL, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3417          if (!kernelLine) continue;          if (!kernelLine) continue;
3418    
3419          line = getLineByType(LT_INITRD, entry->lines);   /* if title is supplied, the entry's title must match it. */
3420     if (title) {
3421        char *linetitle;
3422    
3423        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3424        if (!line)
3425     continue;
3426    
3427        linetitle = extractTitle(cfg, line);
3428        if (!linetitle)
3429     continue;
3430        if (strcmp(title, linetitle)) {
3431     free(linetitle);
3432     continue;
3433        }
3434        free(linetitle);
3435     }
3436    
3437            line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3438          if (line)          if (line)
3439              removeLine(entry, line);              removeLine(entry, line);
3440          if (prefix) {          if (prefix) {
# Line 2430  int updateInitrd(struct grubConfig * cfg Line 3445  int updateInitrd(struct grubConfig * cfg
3445   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
3446   if (endLine)   if (endLine)
3447      removeLine(entry, endLine);      removeLine(entry, endLine);
3448          line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);   enum lineType_e lt;
3449     switch(kernelLine->type) {
3450        case LT_KERNEL:
3451            lt = LT_INITRD;
3452     break;
3453        case LT_KERNEL_EFI:
3454            lt = LT_INITRD_EFI;
3455     break;
3456        case LT_KERNEL_16:
3457            lt = LT_INITRD_16;
3458     break;
3459        default:
3460            lt = preferredLineType(LT_INITRD, cfg->cfi);
3461     }
3462            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3463          if (!line)          if (!line)
3464      return 1;      return 1;
3465   if (endLine) {   if (endLine) {
# Line 2468  int checkDeviceBootloader(const char * d Line 3497  int checkDeviceBootloader(const char * d
3497      if (memcmp(boot, bootSect, 3))      if (memcmp(boot, bootSect, 3))
3498   return 0;   return 0;
3499    
3500      if (boot[1] == 0xeb) {      if (boot[1] == JMP_SHORT_OPCODE) {
3501   offset = boot[2] + 2;   offset = boot[2] + 2;
3502      } else if (boot[1] == 0xe8 || boot[1] == 0xe9) {      } else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3503   offset = (boot[3] << 8) + boot[2] + 2;   offset = (boot[3] << 8) + boot[2] + 2;
3504      } else if (boot[0] == 0xeb) {      } else if (boot[0] == JMP_SHORT_OPCODE) {
3505   offset = boot[1] + 2;        offset = boot[1] + 2;
3506            /*
3507     * it looks like grub, when copying stage1 into the mbr, patches stage1
3508     * right after the JMP location, replacing other instructions such as
3509     * JMPs for NOOPs. So, relax the check a little bit by skipping those
3510     * different bytes.
3511     */
3512          if ((bootSect[offset + 1] == NOOP_OPCODE)
3513      && (bootSect[offset + 2] == NOOP_OPCODE)) {
3514     offset = offset + 3;
3515          }
3516      } else if (boot[0] == 0xe8 || boot[0] == 0xe9) {      } else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
3517   offset = (boot[2] << 8) + boot[1] + 2;   offset = (boot[2] << 8) + boot[1] + 2;
3518      } else {      } else {
# Line 2626  int checkForGrub(struct grubConfig * con Line 3665  int checkForGrub(struct grubConfig * con
3665      int fd;      int fd;
3666      unsigned char bootSect[512];      unsigned char bootSect[512];
3667      char * boot;      char * boot;
3668        int onSuse = isSuseSystem();
3669    
3670      if (parseSysconfigGrub(NULL, &boot))  
3671   return 0;      if (onSuse) {
3672     if (parseSuseGrubConf(NULL, &boot))
3673        return 0;
3674        } else {
3675     if (parseSysconfigGrub(NULL, &boot))
3676        return 0;
3677        }
3678    
3679      /* assume grub is not installed -- not an error condition */      /* assume grub is not installed -- not an error condition */
3680      if (!boot)      if (!boot)
# Line 2647  int checkForGrub(struct grubConfig * con Line 3693  int checkForGrub(struct grubConfig * con
3693      }      }
3694      close(fd);      close(fd);
3695    
3696        /* The more elaborate checks do not work on SuSE. The checks done
3697         * seem to be reasonble (at least for now), so just return success
3698         */
3699        if (onSuse)
3700     return 2;
3701    
3702      return checkDeviceBootloader(boot, bootSect);      return checkDeviceBootloader(boot, bootSect);
3703  }  }
3704    
# Line 2680  int checkForExtLinux(struct grubConfig * Line 3732  int checkForExtLinux(struct grubConfig *
3732      return checkDeviceBootloader(boot, bootSect);      return checkDeviceBootloader(boot, bootSect);
3733  }  }
3734    
3735    int checkForYaboot(struct grubConfig * config) {
3736        /*
3737         * This is a simplistic check that we consider good enough for own puporses
3738         *
3739         * If we were to properly check if yaboot is *installed* we'd need to:
3740         * 1) get the system boot device (LT_BOOT)
3741         * 2) considering it's a raw filesystem, check if the yaboot binary matches
3742         *    the content on the boot device
3743         * 3) if not, copy the binary to a temporary file and run "addnote" on it
3744         * 4) check again if binary and boot device contents match
3745         */
3746        if (!access("/etc/yaboot.conf", R_OK))
3747     return 2;
3748    
3749        return 1;
3750    }
3751    
3752    int checkForElilo(struct grubConfig * config) {
3753        if (!access("/etc/elilo.conf", R_OK))
3754     return 2;
3755    
3756        return 1;
3757    }
3758    
3759  static char * getRootSpecifier(char * str) {  static char * getRootSpecifier(char * str) {
3760      char * idx, * rootspec = NULL;      char * idx, * rootspec = NULL;
3761    
# Line 2694  static char * getRootSpecifier(char * st Line 3770  static char * getRootSpecifier(char * st
3770  static char * getInitrdVal(struct grubConfig * config,  static char * getInitrdVal(struct grubConfig * config,
3771     const char * prefix, struct singleLine *tmplLine,     const char * prefix, struct singleLine *tmplLine,
3772     const char * newKernelInitrd,     const char * newKernelInitrd,
3773     char ** extraInitrds, int extraInitrdCount)     const char ** extraInitrds, int extraInitrdCount)
3774  {  {
3775      char *initrdVal, *end;      char *initrdVal, *end;
3776      int i;      int i;
# Line 2739  static char * getInitrdVal(struct grubCo Line 3815  static char * getInitrdVal(struct grubCo
3815    
3816  int addNewKernel(struct grubConfig * config, struct singleEntry * template,  int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3817           const char * prefix,           const char * prefix,
3818   char * newKernelPath, char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
3819   char * newKernelArgs, char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
3820   char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
3821                   char * newMBKernel, char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
3822     const char * newDevTreePath) {
3823      struct singleEntry * new;      struct singleEntry * new;
3824      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3825      int needs;      int needs;
# Line 2783  int addNewKernel(struct grubConfig * con Line 3860  int addNewKernel(struct grubConfig * con
3860          needs |= NEED_MB;          needs |= NEED_MB;
3861          new->multiboot = 1;          new->multiboot = 1;
3862      }      }
3863        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3864     needs |= NEED_DEVTREE;
3865    
3866      if (template) {      if (template) {
3867   for (masterLine = template->lines;   for (masterLine = template->lines;
# Line 2796  int addNewKernel(struct grubConfig * con Line 3875  int addNewKernel(struct grubConfig * con
3875      while (*chptr && isspace(*chptr)) chptr++;      while (*chptr && isspace(*chptr)) chptr++;
3876      if (*chptr == '#') continue;      if (*chptr == '#') continue;
3877    
3878      if (tmplLine->type == LT_KERNEL &&      if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
     tmplLine->numElements >= 2) {  
3879   if (!template->multiboot && (needs & NEED_MB)) {   if (!template->multiboot && (needs & NEED_MB)) {
3880      /* it's not a multiboot template and this is the kernel      /* it's not a multiboot template and this is the kernel
3881       * line.  Try to be intelligent about inserting the       * line.  Try to be intelligent about inserting the
# Line 2874  int addNewKernel(struct grubConfig * con Line 3952  int addNewKernel(struct grubConfig * con
3952      /* template is multi but new is not,      /* template is multi but new is not,
3953       * insert the kernel in the first module slot       * insert the kernel in the first module slot
3954       */       */
3955      tmplLine->type = LT_KERNEL;      tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3956      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
3957      tmplLine->elements[0].item =      tmplLine->elements[0].item =
3958   strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
3959     config->cfi)->key);
3960      newLine = addLineTmpl(new, tmplLine, newLine,      newLine = addLineTmpl(new, tmplLine, newLine,
3961    newKernelPath + strlen(prefix), config->cfi);    newKernelPath + strlen(prefix),
3962      config->cfi);
3963      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
3964   } else if (needs & NEED_INITRD) {   } else if (needs & NEED_INITRD) {
3965      char *initrdVal;      char *initrdVal;
3966      /* template is multi but new is not,      /* template is multi but new is not,
3967       * insert the initrd in the second module slot       * insert the initrd in the second module slot
3968       */       */
3969      tmplLine->type = LT_INITRD;      tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3970      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
3971      tmplLine->elements[0].item =      tmplLine->elements[0].item =
3972   strdup(getKeywordByType(LT_INITRD, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
3973     config->cfi)->key);
3974      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3975      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3976      free(initrdVal);      free(initrdVal);
3977      needs &= ~NEED_INITRD;      needs &= ~NEED_INITRD;
3978   }   }
3979    
3980      } else if (tmplLine->type == LT_INITRD &&      } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
        tmplLine->numElements >= 2) {  
3981   if (needs & NEED_INITRD &&   if (needs & NEED_INITRD &&
3982      new->multiboot && !template->multiboot &&      new->multiboot && !template->multiboot &&
3983      config->cfi->mbInitRdIsModule) {      config->cfi->mbInitRdIsModule) {
# Line 2948  int addNewKernel(struct grubConfig * con Line 4028  int addNewKernel(struct grubConfig * con
4028   }   }
4029      } else if (tmplLine->type == LT_ECHO) {      } else if (tmplLine->type == LT_ECHO) {
4030      requote(tmplLine, config->cfi);      requote(tmplLine, config->cfi);
4031        static const char *prefix = "'Loading ";
4032      if (tmplLine->numElements > 1 &&      if (tmplLine->numElements > 1 &&
4033      strstr(tmplLine->elements[1].item, "'Loading Linux ")) {      strstr(tmplLine->elements[1].item, prefix) &&
4034   char *prefix = "'Loading ";      masterLine->next &&
4035        iskernel(masterLine->next->type)) {
4036   char *newTitle = malloc(strlen(prefix) +   char *newTitle = malloc(strlen(prefix) +
4037   strlen(newKernelTitle) + 2);   strlen(newKernelTitle) + 2);
4038    
# Line 2965  int addNewKernel(struct grubConfig * con Line 4047  int addNewKernel(struct grubConfig * con
4047   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4048   config->cfi);   config->cfi);
4049      }      }
4050        } else if (tmplLine->type == LT_DEVTREE &&
4051           tmplLine->numElements == 2 && newDevTreePath) {
4052            newLine = addLineTmpl(new, tmplLine, newLine,
4053          newDevTreePath + strlen(prefix),
4054          config->cfi);
4055     needs &= ~NEED_DEVTREE;
4056        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4057     const char *ndtp = newDevTreePath;
4058     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4059        ndtp += strlen(prefix);
4060     newLine = addLine(new, config->cfi, LT_DEVTREE,
4061      config->secondaryIndent,
4062      ndtp);
4063     needs &= ~NEED_DEVTREE;
4064     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4065      } else {      } else {
4066   /* pass through other lines from the template */   /* pass through other lines from the template */
4067   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
# Line 2977  int addNewKernel(struct grubConfig * con Line 4074  int addNewKernel(struct grubConfig * con
4074   */   */
4075   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
4076      case LT_KERNEL:      case LT_KERNEL:
4077        case LT_KERNEL_EFI:
4078        case LT_KERNEL_16:
4079   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
4080      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
4081   } else {   } else {
4082      newLine = addLine(new, config->cfi, LT_KERNEL,      newLine = addLine(new, config->cfi,
4083              preferredLineType(LT_KERNEL, config->cfi),
4084        config->primaryIndent,        config->primaryIndent,
4085        newKernelPath + strlen(prefix));        newKernelPath + strlen(prefix));
4086      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
# Line 3037  int addNewKernel(struct grubConfig * con Line 4137  int addNewKernel(struct grubConfig * con
4137   }   }
4138      }      }
4139    
4140        struct singleLine *endLine = NULL;
4141        endLine = getLineByType(LT_ENTRY_END, new->lines);
4142        if (endLine) {
4143        removeLine(new, endLine);
4144        needs |= NEED_END;
4145        }
4146    
4147      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
4148       * weren't present in the template, or in the case of no template,       * weren't present in the template, or in the case of no template,
4149       * all the lines following the entryStart.       * all the lines following the entryStart.
# Line 3056  int addNewKernel(struct grubConfig * con Line 4163  int addNewKernel(struct grubConfig * con
4163      if (needs & NEED_KERNEL) {      if (needs & NEED_KERNEL) {
4164   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
4165    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
4166        config->cfi)) ?        config->cfi))
4167    LT_MBMODULE : LT_KERNEL,     ? LT_MBMODULE
4168     : preferredLineType(LT_KERNEL, config->cfi),
4169    config->secondaryIndent,    config->secondaryIndent,
4170    newKernelPath + strlen(prefix));    newKernelPath + strlen(prefix));
4171   needs &= ~NEED_KERNEL;   needs &= ~NEED_KERNEL;
# Line 3073  int addNewKernel(struct grubConfig * con Line 4181  int addNewKernel(struct grubConfig * con
4181   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4182   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
4183    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
4184        config->cfi)) ?        config->cfi))
4185    LT_MBMODULE : LT_INITRD,     ? LT_MBMODULE
4186       : preferredLineType(LT_INITRD, config->cfi),
4187    config->secondaryIndent,    config->secondaryIndent,
4188    initrdVal);    initrdVal);
4189   free(initrdVal);   free(initrdVal);
4190   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
4191      }      }
4192        if (needs & NEED_DEVTREE) {
4193     newLine = addLine(new, config->cfi, LT_DEVTREE,
4194      config->secondaryIndent,
4195      newDevTreePath);
4196     needs &= ~NEED_DEVTREE;
4197        }
4198    
4199        /* NEEDS_END must be last on bootloaders that need it... */
4200      if (needs & NEED_END) {      if (needs & NEED_END) {
4201   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
4202   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
# Line 3097  int addNewKernel(struct grubConfig * con Line 4214  int addNewKernel(struct grubConfig * con
4214      return 0;      return 0;
4215  }  }
4216    
 static void traceback(int signum)  
 {  
     void *array[40];  
     size_t size;  
   
     signal(SIGSEGV, SIG_DFL);  
     memset(array, '\0', sizeof (array));  
     size = backtrace(array, 40);  
   
     fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",  
             (unsigned long)size);  
     backtrace_symbols_fd(array, size, STDERR_FILENO);  
     exit(1);  
 }  
   
4217  int main(int argc, const char ** argv) {  int main(int argc, const char ** argv) {
4218      poptContext optCon;      poptContext optCon;
4219      const char * grubConfig = NULL;      const char * grubConfig = NULL;
# Line 3131  int main(int argc, const char ** argv) { Line 4233  int main(int argc, const char ** argv) {
4233      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
4234      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
4235      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
4236      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
4237      char * newMBKernel = NULL;      char * newMBKernel = NULL;
4238      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
4239      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
# Line 3141  int main(int argc, const char ** argv) { Line 4243  int main(int argc, const char ** argv) {
4243      char * removeArgs = NULL;      char * removeArgs = NULL;
4244      char * kernelInfo = NULL;      char * kernelInfo = NULL;
4245      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4246        char * envPath = NULL;
4247      const char * chptr = NULL;      const char * chptr = NULL;
4248      struct configFileInfo * cfi = NULL;      struct configFileInfo * cfi = NULL;
4249      struct grubConfig * config;      struct grubConfig * config;
4250      struct singleEntry * template = NULL;      struct singleEntry * template = NULL;
4251      int copyDefault = 0, makeDefault = 0;      int copyDefault = 0, makeDefault = 0;
4252      int displayDefault = 0;      int displayDefault = 0;
4253        int displayDefaultIndex = 0;
4254        int displayDefaultTitle = 0;
4255        int defaultIndex = -1;
4256      struct poptOption options[] = {      struct poptOption options[] = {
4257   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4258      _("add an entry for the specified kernel"), _("kernel-path") },      _("add an entry for the specified kernel"), _("kernel-path") },
# Line 3164  int main(int argc, const char ** argv) { Line 4270  int main(int argc, const char ** argv) {
4270   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4271      _("filestystem which contains /boot directory (for testing only)"),      _("filestystem which contains /boot directory (for testing only)"),
4272      _("bootfs") },      _("bootfs") },
4273  #if defined(__i386__) || defined(__x86_64__)  #if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4274   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4275      _("check if lilo is installed on lilo.conf boot sector") },      _("check which bootloader is installed on boot sector") },
4276  #endif  #endif
4277   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4278      _("path to grub config file to update (\"-\" for stdin)"),      _("path to grub config file to update (\"-\" for stdin)"),
# Line 3177  int main(int argc, const char ** argv) { Line 4283  int main(int argc, const char ** argv) {
4283        "the kernel referenced by the default image does not exist, "        "the kernel referenced by the default image does not exist, "
4284        "the first linux entry whose kernel does exist is used as the "        "the first linux entry whose kernel does exist is used as the "
4285        "template"), NULL },        "template"), NULL },
4286     { "debug", 0, 0, &debug, 0,
4287        _("print debugging information for failures") },
4288   { "default-kernel", 0, 0, &displayDefault, 0,   { "default-kernel", 0, 0, &displayDefault, 0,
4289      _("display the path of the default kernel") },      _("display the path of the default kernel") },
4290     { "default-index", 0, 0, &displayDefaultIndex, 0,
4291        _("display the index of the default kernel") },
4292     { "default-title", 0, 0, &displayDefaultTitle, 0,
4293        _("display the title of the default kernel") },
4294     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4295        _("device tree file for new stanza"), _("dtb-path") },
4296     { "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4297        _("device tree directory for new stanza"), _("dtb-path") },
4298   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4299      _("configure elilo bootloader") },      _("configure elilo bootloader") },
4300     { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4301        _("force grub2 stanzas to use efi") },
4302     { "env", 0, POPT_ARG_STRING, &envPath, 0,
4303        _("path for environment data"),
4304        _("path") },
4305   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4306      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
4307   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
# Line 3193  int main(int argc, const char ** argv) { Line 4314  int main(int argc, const char ** argv) {
4314   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4315      _("initrd image for the new kernel"), _("initrd-path") },      _("initrd image for the new kernel"), _("initrd-path") },
4316   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4317      _("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },      _("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4318   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4319      _("configure lilo bootloader") },      _("configure lilo bootloader") },
4320   { "make-default", 0, 0, &makeDefault, 0,   { "make-default", 0, 0, &makeDefault, 0,
# Line 3213  int main(int argc, const char ** argv) { Line 4334  int main(int argc, const char ** argv) {
4334   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4335      _("make the first entry referencing the specified kernel "      _("make the first entry referencing the specified kernel "
4336        "the default"), _("kernel-path") },        "the default"), _("kernel-path") },
4337     { "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4338        _("make the given entry index the default entry"),
4339        _("entry-index") },
4340   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4341      _("configure silo bootloader") },      _("configure silo bootloader") },
4342   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
# Line 3232  int main(int argc, const char ** argv) { Line 4356  int main(int argc, const char ** argv) {
4356    
4357      useextlinuxmenu=0;      useextlinuxmenu=0;
4358    
4359      signal(SIGSEGV, traceback);      int i = 0;
4360        for (int j = 1; j < argc; j++)
4361     i += strlen(argv[j]) + 1;
4362        saved_command_line = malloc(i);
4363        if (!saved_command_line) {
4364     fprintf(stderr, "grubby: %m\n");
4365     exit(1);
4366        }
4367        saved_command_line[0] = '\0';
4368        for (int j = 1; j < argc; j++) {
4369     strcat(saved_command_line, argv[j]);
4370     strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4371        }
4372    
4373      optCon = poptGetContext("grubby", argc, argv, options, 0);      optCon = poptGetContext("grubby", argc, argv, options, 0);
4374      poptReadDefaultConfig(optCon, 1);      poptReadDefaultConfig(optCon, 1);
# Line 3277  int main(int argc, const char ** argv) { Line 4413  int main(int argc, const char ** argv) {
4413   return 1;   return 1;
4414      } else if (configureGrub2) {      } else if (configureGrub2) {
4415   cfi = &grub2ConfigType;   cfi = &grub2ConfigType;
4416     if (envPath)
4417        cfi->envFile = envPath;
4418      } else if (configureLilo) {      } else if (configureLilo) {
4419   cfi = &liloConfigType;   cfi = &liloConfigType;
4420      } else if (configureGrub) {      } else if (configureGrub) {
# Line 3295  int main(int argc, const char ** argv) { Line 4433  int main(int argc, const char ** argv) {
4433      }      }
4434    
4435      if (!cfi) {      if (!cfi) {
4436            if (grub2FindConfig(&grub2ConfigType)) {
4437        cfi = &grub2ConfigType;
4438        if (envPath)
4439     cfi->envFile = envPath;
4440            } else
4441        #ifdef __ia64__        #ifdef __ia64__
4442   cfi = &eliloConfigType;      cfi = &eliloConfigType;
4443        #elif __powerpc__        #elif __powerpc__
4444   cfi = &yabootConfigType;      cfi = &yabootConfigType;
4445        #elif __sparc__        #elif __sparc__
4446          cfi = &siloConfigType;              cfi = &siloConfigType;
4447        #elif __s390__        #elif __s390__
4448          cfi = &ziplConfigType;              cfi = &ziplConfigType;
4449        #elif __s390x__        #elif __s390x__
4450          cfi = &ziplConfigtype;              cfi = &ziplConfigtype;
4451        #else        #else
         if (grub2FindConfig(&grub2ConfigType))  
     cfi = &grub2ConfigType;  
  else  
4452      cfi = &grubConfigType;      cfi = &grubConfigType;
4453        #endif        #endif
4454      }      }
# Line 3320  int main(int argc, const char ** argv) { Line 4460  int main(int argc, const char ** argv) {
4460      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
4461      }      }
4462    
4463      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
4464    newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
4465    defaultKernel)) {      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4466        (defaultIndex >= 0))) {
4467   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4468    "specified option"));    "specified option"));
4469   return 1;   return 1;
4470      }      }
4471    
4472      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
4473     removeKernelPath)) {     removeKernelPath)) {
4474   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
4475    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
# Line 3338  int main(int argc, const char ** argv) { Line 4479  int main(int argc, const char ** argv) {
4479      if (newKernelPath && !newKernelTitle) {      if (newKernelPath && !newKernelTitle) {
4480   fprintf(stderr, _("grubby: kernel title must be specified\n"));   fprintf(stderr, _("grubby: kernel title must be specified\n"));
4481   return 1;   return 1;
4482      } else if (!newKernelPath && (newKernelTitle  || copyDefault ||      } else if (!newKernelPath && (copyDefault ||
4483    (newKernelInitrd && !updateKernelPath)||    (newKernelInitrd && !updateKernelPath)||
4484    makeDefault || extraInitrdCount > 0)) {    makeDefault || extraInitrdCount > 0)) {
4485   fprintf(stderr, _("grubby: kernel path expected\n"));   fprintf(stderr, _("grubby: kernel path expected\n"));
# Line 3364  int main(int argc, const char ** argv) { Line 4505  int main(int argc, const char ** argv) {
4505   makeDefault = 1;   makeDefault = 1;
4506   defaultKernel = NULL;   defaultKernel = NULL;
4507      }      }
4508        else if (defaultKernel && (defaultIndex >= 0)) {
4509     fprintf(stderr, _("grubby: --set-default and --set-default-index "
4510      "may not be used together\n"));
4511     return 1;
4512        }
4513    
4514      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4515   fprintf(stderr, _("grubby: output file must be specified if stdin "   fprintf(stderr, _("grubby: output file must be specified if stdin "
# Line 3372  int main(int argc, const char ** argv) { Line 4518  int main(int argc, const char ** argv) {
4518      }      }
4519    
4520      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4521   && !kernelInfo && !bootloaderProbe && !updateKernelPath   && !kernelInfo && !bootloaderProbe && !updateKernelPath
4522          && !removeMBKernel) {   && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4523     && (defaultIndex == -1)) {
4524   fprintf(stderr, _("grubby: no action specified\n"));   fprintf(stderr, _("grubby: no action specified\n"));
4525   return 1;   return 1;
4526      }      }
# Line 3400  int main(int argc, const char ** argv) { Line 4547  int main(int argc, const char ** argv) {
4547      }      }
4548    
4549      if (bootloaderProbe) {      if (bootloaderProbe) {
4550   int lrc = 0, grc = 0, gr2c = 0, erc = 0;   int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4551   struct grubConfig * lconfig, * gconfig;   struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4552    
4553   const char *grub2config = grub2FindConfig(&grub2ConfigType);   const char *grub2config = grub2FindConfig(&grub2ConfigType);
4554   if (grub2config) {   if (grub2config) {
# Line 3429  int main(int argc, const char ** argv) { Line 4576  int main(int argc, const char ** argv) {
4576   lrc = checkForLilo(lconfig);   lrc = checkForLilo(lconfig);
4577   }   }
4578    
4579     if (!access(eliloConfigType.defaultConfig, F_OK)) {
4580        econfig = readConfig(eliloConfigType.defaultConfig,
4581     &eliloConfigType);
4582        if (!econfig)
4583     erc = 1;
4584        else
4585     erc = checkForElilo(econfig);
4586     }
4587    
4588   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4589      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4590      if (!lconfig)      if (!lconfig)
4591   erc = 1;   extrc = 1;
4592      else      else
4593   erc = checkForExtLinux(lconfig);   extrc = checkForExtLinux(lconfig);
4594   }   }
4595    
4596   if (lrc == 1 || grc == 1 || gr2c == 1) return 1;  
4597     if (!access(yabootConfigType.defaultConfig, F_OK)) {
4598        yconfig = readConfig(yabootConfigType.defaultConfig,
4599     &yabootConfigType);
4600        if (!yconfig)
4601     yrc = 1;
4602        else
4603     yrc = checkForYaboot(yconfig);
4604     }
4605    
4606     if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4607     erc == 1)
4608        return 1;
4609    
4610   if (lrc == 2) printf("lilo\n");   if (lrc == 2) printf("lilo\n");
4611   if (gr2c == 2) printf("grub2\n");   if (gr2c == 2) printf("grub2\n");
4612   if (grc == 2) printf("grub\n");   if (grc == 2) printf("grub\n");
4613   if (erc == 2) printf("extlinux\n");   if (extrc == 2) printf("extlinux\n");
4614     if (yrc == 2) printf("yaboot\n");
4615     if (erc == 2) printf("elilo\n");
4616    
4617   return 0;   return 0;
4618      }      }
4619    
4620        if (grubConfig == NULL) {
4621     printf("Could not find bootloader configuration file.\n");
4622     exit(1);
4623        }
4624    
4625      config = readConfig(grubConfig, cfi);      config = readConfig(grubConfig, cfi);
4626      if (!config) return 1;      if (!config) return 1;
4627    
# Line 3456  int main(int argc, const char ** argv) { Line 4631  int main(int argc, const char ** argv) {
4631          char * rootspec;          char * rootspec;
4632    
4633   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
4634     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4635     cfi->defaultIsSaved)
4636        config->defaultImage = 0;
4637   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
4638   if (!entry) return 0;   if (!entry) return 0;
4639   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4640    
4641   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4642   if (!line) return 0;   if (!line) return 0;
4643    
4644          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
# Line 3468  int main(int argc, const char ** argv) { Line 4646  int main(int argc, const char ** argv) {
4646                 ((rootspec != NULL) ? strlen(rootspec) : 0));                 ((rootspec != NULL) ? strlen(rootspec) : 0));
4647    
4648   return 0;   return 0;
4649    
4650        } else if (displayDefaultTitle) {
4651     struct singleLine * line;
4652     struct singleEntry * entry;
4653    
4654     if (config->defaultImage == -1)
4655        return 0;
4656     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4657     cfi->defaultIsSaved)
4658        config->defaultImage = 0;
4659     entry = findEntryByIndex(config, config->defaultImage);
4660     if (!entry)
4661     return 0;
4662    
4663     if (!configureGrub2) {
4664        char *title;
4665        line = getLineByType(LT_TITLE, entry->lines);
4666        if (!line)
4667     return 0;
4668        title = extractTitle(config, line);
4669        if (!title)
4670     return 0;
4671        printf("%s\n", title);
4672        free(title);
4673     } else {
4674        char * title;
4675    
4676        dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4677        line = getLineByType(LT_MENUENTRY, entry->lines);
4678        if (!line)
4679     return 0;
4680        title = grub2ExtractTitle(line);
4681        if (title)
4682     printf("%s\n", title);
4683     }
4684     return 0;
4685    
4686        } else if (displayDefaultIndex) {
4687            if (config->defaultImage == -1) return 0;
4688     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4689     cfi->defaultIsSaved)
4690        config->defaultImage = 0;
4691            printf("%i\n", config->defaultImage);
4692            return 0;
4693    
4694      } else if (kernelInfo)      } else if (kernelInfo)
4695   return displayInfo(config, kernelInfo, bootPrefix);   return displayInfo(config, kernelInfo, bootPrefix);
4696    
# Line 3479  int main(int argc, const char ** argv) { Line 4702  int main(int argc, const char ** argv) {
4702      markRemovedImage(config, removeKernelPath, bootPrefix);      markRemovedImage(config, removeKernelPath, bootPrefix);
4703      markRemovedImage(config, removeMBKernel, bootPrefix);      markRemovedImage(config, removeMBKernel, bootPrefix);
4704      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4705      bootPrefix, flags);      bootPrefix, flags, defaultIndex);
4706      setFallbackImage(config, newKernelPath != NULL);      setFallbackImage(config, newKernelPath != NULL);
4707      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4708                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4709      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
4710              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
4711                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
4712     bootPrefix, newKernelInitrd,
4713     newKernelTitle))
4714        return 1;
4715        } else {
4716        if (updateInitrd(config, updateKernelPath, bootPrefix,
4717     newKernelInitrd, newKernelTitle))
4718     return 1;
4719        }
4720      }      }
4721      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
4722                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
4723                       extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
4724                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4725            
4726    
4727      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {

Legend:
Removed from v.1717  
changed lines
  Added in v.2992