Magellan Linux

Diff of /trunk/grubby/grubby.c

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

revision 1844 by niro, Mon Jul 2 12:59:07 2012 UTC revision 2962 by niro, Wed Jun 29 14:40:57 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 56  int debug = 0; /* Currently just for tem Line 58  int debug = 0; /* Currently just for tem
58  #define NOOP_OPCODE 0x90  #define NOOP_OPCODE 0x90
59  #define JMP_SHORT_OPCODE 0xeb  #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 82  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 111  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
# Line 128  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 148  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 164  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 205  struct keywordTypes grub2Keywords[] = { Line 233  struct keywordTypes grub2Keywords[] = {
233      { "default",    LT_DEFAULT,     ' ' },      { "default",    LT_DEFAULT,     ' ' },
234      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
235      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
236        { "linuxefi",   LT_KERNEL_EFI,  ' ' },
237        { "linux16",    LT_KERNEL_16,   ' ' },
238      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
239        { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
241      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
242      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
243        { "devicetree", LT_DEVTREE,  ' ' },
244      { NULL, 0, 0 },      { NULL, 0, 0 },
245  };  };
246    
# Line 219  const char *grub2FindConfig(struct confi Line 252  const char *grub2FindConfig(struct confi
252      };      };
253      static int i = -1;      static int i = -1;
254      static const char *grub_cfg = "/boot/grub/grub.cfg";      static const char *grub_cfg = "/boot/grub/grub.cfg";
255        int rc = -1;
256    
257      if (i == -1) {      if (i == -1) {
258   for (i = 0; configFiles[i] != NULL; i++) {   for (i = 0; configFiles[i] != NULL; i++) {
259      dbgPrintf("Checking \"%s\": ", configFiles[i]);      dbgPrintf("Checking \"%s\": ", configFiles[i]);
260      if (!access(configFiles[i], R_OK)) {      if ((rc = access(configFiles[i], R_OK))) {
261     if (errno == EACCES) {
262        printf("Unable to access bootloader configuration file "
263           "\"%s\": %m\n", configFiles[i]);
264        exit(1);
265     }
266     continue;
267        } else {
268   dbgPrintf("found\n");   dbgPrintf("found\n");
269   return configFiles[i];   return configFiles[i];
270      }      }
# Line 242  const char *grub2FindConfig(struct confi Line 283  const char *grub2FindConfig(struct confi
283      return configFiles[i];      return configFiles[i];
284  }  }
285    
286    /* kind of hacky.  It'll give the first 1024 bytes, ish. */
287    static char *grub2GetEnv(struct configFileInfo *info, char *name)
288    {
289        static char buf[1025];
290        char *s = NULL;
291        char *ret = NULL;
292        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
293        int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
294    
295        if (rc < 0)
296     return NULL;
297    
298        FILE *f = popen(s, "r");
299        if (!f)
300     goto out;
301    
302        memset(buf, '\0', sizeof (buf));
303        ret = fgets(buf, 1024, f);
304        pclose(f);
305    
306        if (ret) {
307     ret += strlen(name) + 1;
308     ret[strlen(ret) - 1] = '\0';
309        }
310        dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
311    out:
312        free(s);
313        return ret;
314    }
315    
316    static int sPopCount(const char *s, const char *c)
317    {
318        int ret = 0;
319        if (!s)
320     return -1;
321        for (int i = 0; s[i] != '\0'; i++)
322     for (int j = 0; c[j] != '\0'; j++)
323        if (s[i] == c[j])
324     ret++;
325        return ret;
326    }
327    
328    static char *shellEscape(const char *s)
329    {
330        int l = strlen(s) + sPopCount(s, "'") * 2;
331    
332        char *ret = calloc(l+1, sizeof (*ret));
333        if (!ret)
334     return NULL;
335        for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
336     if (s[i] == '\'')
337        ret[j++] = '\\';
338     ret[j] = s[i];
339        }
340        return ret;
341    }
342    
343    static void unquote(char *s)
344    {
345        int l = strlen(s);
346    
347        if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
348     memmove(s, s+1, l-2);
349     s[l-2] = '\0';
350        }
351    }
352    
353    static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
354    {
355        char *s = NULL;
356        int rc = 0;
357        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
358    
359        unquote(value);
360        value = shellEscape(value);
361        if (!value)
362        return -1;
363    
364        rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
365        free(value);
366        if (rc <0)
367     return -1;
368    
369        dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
370        rc = system(s);
371        free(s);
372        return rc;
373    }
374    
375    /* this is a gigantic hack to avoid clobbering grub2 variables... */
376    static int is_special_grub2_variable(const char *name)
377    {
378        if (!strcmp(name,"\"${next_entry}\""))
379     return 1;
380        if (!strcmp(name,"\"${prev_saved_entry}\""))
381     return 1;
382        return 0;
383    }
384    
385  int sizeOfSingleLine(struct singleLine * line) {  int sizeOfSingleLine(struct singleLine * line) {
   int i;  
386    int count = 0;    int count = 0;
387    
388    for (i = 0; i < line->numElements; i++) {    for (int i = 0; i < line->numElements; i++) {
389      int indentSize = 0;      int indentSize = 0;
390    
391      count = count + strlen(line->elements[i].item);      count = count + strlen(line->elements[i].item);
# Line 272  static int isquote(char q) Line 411  static int isquote(char q)
411      return 0;      return 0;
412  }  }
413    
414    static int iskernel(enum lineType_e type) {
415        return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
416    }
417    
418    static int isinitrd(enum lineType_e type) {
419        return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
420    }
421    
422  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
423      char * current;      char * current;
424      char * current_indent;      char * current_indent;
# Line 329  char *grub2ExtractTitle(struct singleLin Line 476  char *grub2ExtractTitle(struct singleLin
476    
477  struct configFileInfo grub2ConfigType = {  struct configFileInfo grub2ConfigType = {
478      .findConfig = grub2FindConfig,      .findConfig = grub2FindConfig,
479        .getEnv = grub2GetEnv,
480        .setEnv = grub2SetEnv,
481      .keywords = grub2Keywords,      .keywords = grub2Keywords,
482      .defaultIsIndex = 1,      .defaultIsIndex = 1,
483      .defaultSupportSaved = 1,      .defaultSupportSaved = 1,
# Line 483  struct configFileInfo ziplConfigType = { Line 632  struct configFileInfo ziplConfigType = {
632  struct configFileInfo extlinuxConfigType = {  struct configFileInfo extlinuxConfigType = {
633      .defaultConfig = "/boot/extlinux/extlinux.conf",      .defaultConfig = "/boot/extlinux/extlinux.conf",
634      .keywords = extlinuxKeywords,      .keywords = extlinuxKeywords,
635        .caseInsensitive = 1,
636      .entryStart = LT_TITLE,      .entryStart = LT_TITLE,
637      .needsBootPrefix = 1,      .needsBootPrefix = 1,
638      .maxTitleLength = 255,      .maxTitleLength = 255,
639      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
640        .defaultIsUnquoted = 1,
641  };  };
642    
643  struct grubConfig {  struct grubConfig {
# Line 507  struct singleEntry * findEntryByIndex(st Line 658  struct singleEntry * findEntryByIndex(st
658  struct singleEntry * findEntryByPath(struct grubConfig * cfg,  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
659       const char * path, const char * prefix,       const char * path, const char * prefix,
660       int * index);       int * index);
661    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
662          int * index);
663  static int readFile(int fd, char ** bufPtr);  static int readFile(int fd, char ** bufPtr);
664  static void lineInit(struct singleLine * line);  static void lineInit(struct singleLine * line);
665  struct singleLine * lineDup(struct singleLine * line);  struct singleLine * lineDup(struct singleLine * line);
# Line 571  static char * sdupprintf(const char *for Line 724  static char * sdupprintf(const char *for
724      return buf;      return buf;
725  }  }
726    
727    static enum lineType_e preferredLineType(enum lineType_e type,
728     struct configFileInfo *cfi) {
729        if (isEfi && cfi == &grub2ConfigType) {
730     switch (type) {
731     case LT_KERNEL:
732        return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
733     case LT_INITRD:
734        return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
735     default:
736        return type;
737     }
738    #if defined(__i386__) || defined(__x86_64__)
739        } else if (cfi == &grub2ConfigType) {
740     switch (type) {
741     case LT_KERNEL:
742        return LT_KERNEL_16;
743     case LT_INITRD:
744        return LT_INITRD_16;
745     default:
746        return type;
747     }
748    #endif
749        }
750        return type;
751    }
752    
753  static struct keywordTypes * getKeywordByType(enum lineType_e type,  static struct keywordTypes * getKeywordByType(enum lineType_e type,
754        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
755      struct keywordTypes * kw;      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
     for (kw = cfi->keywords; kw->key; kw++) {  
756   if (kw->type == type)   if (kw->type == type)
757      return kw;      return kw;
758      }      }
# Line 604  static char * getuuidbydev(char *device) Line 782  static char * getuuidbydev(char *device)
782    
783  static enum lineType_e getTypeByKeyword(char * keyword,  static enum lineType_e getTypeByKeyword(char * keyword,
784   struct configFileInfo * cfi) {   struct configFileInfo * cfi) {
785      struct keywordTypes * kw;      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
786      for (kw = cfi->keywords; kw->key; kw++) {   if (cfi->caseInsensitive) {
787   if (!strcmp(keyword, kw->key))      if (!strcasecmp(keyword, kw->key))
788      return kw->type;                  return kw->type;
789     } else {
790        if (!strcmp(keyword, kw->key))
791            return kw->type;
792     }
793      }      }
794      return LT_UNKNOWN;      return LT_UNKNOWN;
795  }  }
# Line 646  static int isEntryStart(struct singleLin Line 828  static int isEntryStart(struct singleLin
828  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
829  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct singleLine * line) {
830      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it (leaks a byte) */
831      char * title;      char * title = NULL;
832      title = strdup(line->elements[0].item);      if (line->type == LT_TITLE) {
833      title++;   title = strdup(line->elements[0].item);
834      *(title + strlen(title) - 1) = '\0';   title++;
835     *(title + strlen(title) - 1) = '\0';
836        } else if (line->type == LT_MENUENTRY)
837     title = strdup(line->elements[1].item);
838        else
839     return NULL;
840      return title;      return title;
841  }  }
842    
# Line 692  static void lineInit(struct singleLine * Line 879  static void lineInit(struct singleLine *
879  }  }
880    
881  struct singleLine * lineDup(struct singleLine * line) {  struct singleLine * lineDup(struct singleLine * line) {
     int i;  
882      struct singleLine * newLine = malloc(sizeof(*newLine));      struct singleLine * newLine = malloc(sizeof(*newLine));
883    
884      newLine->indent = strdup(line->indent);      newLine->indent = strdup(line->indent);
# Line 702  struct singleLine * lineDup(struct singl Line 888  struct singleLine * lineDup(struct singl
888      newLine->elements = malloc(sizeof(*newLine->elements) *      newLine->elements = malloc(sizeof(*newLine->elements) *
889         newLine->numElements);         newLine->numElements);
890    
891      for (i = 0; i < newLine->numElements; i++) {      for (int i = 0; i < newLine->numElements; i++) {
892   newLine->elements[i].indent = strdup(line->elements[i].indent);   newLine->elements[i].indent = strdup(line->elements[i].indent);
893   newLine->elements[i].item = strdup(line->elements[i].item);   newLine->elements[i].item = strdup(line->elements[i].item);
894      }      }
# Line 711  struct singleLine * lineDup(struct singl Line 897  struct singleLine * lineDup(struct singl
897  }  }
898    
899  static void lineFree(struct singleLine * line) {  static void lineFree(struct singleLine * line) {
     int i;  
   
900      if (line->indent) free(line->indent);      if (line->indent) free(line->indent);
901    
902      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
903   free(line->elements[i].item);   free(line->elements[i].item);
904   free(line->elements[i].indent);   free(line->elements[i].indent);
905      }      }
# Line 726  static void lineFree(struct singleLine * Line 910  static void lineFree(struct singleLine *
910    
911  static int lineWrite(FILE * out, struct singleLine * line,  static int lineWrite(FILE * out, struct singleLine * line,
912       struct configFileInfo * cfi) {       struct configFileInfo * cfi) {
     int i;  
   
913      if (fprintf(out, "%s", line->indent) == -1) return -1;      if (fprintf(out, "%s", line->indent) == -1) return -1;
914    
915      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
916   /* Need to handle this, because we strip the quotes from   /* Need to handle this, because we strip the quotes from
917   * menuentry when read it. */   * menuentry when read it. */
918   if (line->type == LT_MENUENTRY && i == 1) {   if (line->type == LT_MENUENTRY && i == 1) {
# Line 836  static int getNextLine(char ** bufPtr, s Line 1018  static int getNextLine(char ** bufPtr, s
1018      if (*line->elements[0].item == '#') {      if (*line->elements[0].item == '#') {
1019   char * fullLine;   char * fullLine;
1020   int len;   int len;
  int i;  
1021    
1022   len = strlen(line->indent);   len = strlen(line->indent);
1023   for (i = 0; i < line->numElements; i++)   for (int i = 0; i < line->numElements; i++)
1024      len += strlen(line->elements[i].item) +      len += strlen(line->elements[i].item) +
1025     strlen(line->elements[i].indent);     strlen(line->elements[i].indent);
1026    
# Line 848  static int getNextLine(char ** bufPtr, s Line 1029  static int getNextLine(char ** bufPtr, s
1029   free(line->indent);   free(line->indent);
1030   line->indent = fullLine;   line->indent = fullLine;
1031    
1032   for (i = 0; i < line->numElements; i++) {   for (int i = 0; i < line->numElements; i++) {
1033      strcat(fullLine, line->elements[i].item);      strcat(fullLine, line->elements[i].item);
1034      strcat(fullLine, line->elements[i].indent);      strcat(fullLine, line->elements[i].indent);
1035      free(line->elements[i].item);      free(line->elements[i].item);
# Line 867  static int getNextLine(char ** bufPtr, s Line 1048  static int getNextLine(char ** bufPtr, s
1048   * elements up more   * elements up more
1049   */   */
1050   if (!isspace(kw->separatorChar)) {   if (!isspace(kw->separatorChar)) {
     int i;  
1051      char indent[2] = "";      char indent[2] = "";
1052      indent[0] = kw->separatorChar;      indent[0] = kw->separatorChar;
1053      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
1054   char *p;   char *p;
  int j;  
1055   int numNewElements;   int numNewElements;
1056    
1057   numNewElements = 0;   numNewElements = 0;
# Line 888  static int getNextLine(char ** bufPtr, s Line 1067  static int getNextLine(char ** bufPtr, s
1067      sizeof(*line->elements) * elementsAlloced);      sizeof(*line->elements) * elementsAlloced);
1068   }   }
1069    
1070   for (j = line->numElements; j > i; j--) {   for (int j = line->numElements; j > i; j--) {
1071   line->elements[j + numNewElements] = line->elements[j];   line->elements[j + numNewElements] = line->elements[j];
1072   }   }
1073   line->numElements += numNewElements;   line->numElements += numNewElements;
# Line 915  static int getNextLine(char ** bufPtr, s Line 1094  static int getNextLine(char ** bufPtr, s
1094      return 0;      return 0;
1095  }  }
1096    
1097    static int isnumber(const char *s)
1098    {
1099        int i;
1100        for (i = 0; s[i] != '\0'; i++)
1101     if (s[i] < '0' || s[i] > '9')
1102        return 0;
1103        return i;
1104    }
1105    
1106  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
1107        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
1108      int in;      int in;
# Line 926  static struct grubConfig * readConfig(co Line 1114  static struct grubConfig * readConfig(co
1114      struct singleLine * last = NULL, * line, * defaultLine = NULL;      struct singleLine * last = NULL, * line, * defaultLine = NULL;
1115      char * end;      char * end;
1116      struct singleEntry * entry = NULL;      struct singleEntry * entry = NULL;
1117      int i, len;      int len;
1118      char * buf;      char * buf;
1119    
1120      if (!strcmp(inName, "-")) {      if (inName == NULL) {
1121            printf("Could not find bootloader configuration\n");
1122            exit(1);
1123        } else if (!strcmp(inName, "-")) {
1124   in = 0;   in = 0;
1125      } else {      } else {
1126   if ((in = open(inName, O_RDONLY)) < 0) {   if ((in = open(inName, O_RDONLY)) < 0) {
# Line 989  static struct grubConfig * readConfig(co Line 1180  static struct grubConfig * readConfig(co
1180   }   }
1181    
1182   if (line->type == LT_SET_VARIABLE) {   if (line->type == LT_SET_VARIABLE) {
     int i;  
1183      dbgPrintf("found 'set' command (%d elements): ", line->numElements);      dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1184      dbgPrintf("%s", line->indent);      dbgPrintf("%s", line->indent);
1185      for (i = 0; i < line->numElements; i++)      for (int i = 0; i < line->numElements; i++)
1186   dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);   dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1187      dbgPrintf("\n");      dbgPrintf("\n");
1188      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1189      if (kwType && line->numElements == 3 &&      if (kwType && line->numElements == 3 &&
1190      !strcmp(line->elements[1].item, kwType->key)) {      !strcmp(line->elements[1].item, kwType->key) &&
1191        !is_special_grub2_variable(line->elements[2].item)) {
1192   dbgPrintf("Line sets default config\n");   dbgPrintf("Line sets default config\n");
1193   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1194   defaultLine = line;   defaultLine = line;
1195      }      }
  } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
     cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
     defaultLine = line;  
1196    
1197          } else if (line->type == LT_KERNEL) {          } else if (iskernel(line->type)) {
1198      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
1199       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
1200       * instead of LT_KERNEL now       * instead of LT_KERNEL now
1201       */       */
1202      if (entry->multiboot)      if (entry && entry->multiboot)
1203   line->type = LT_HYPER;   line->type = LT_HYPER;
1204    
1205          } else if (line->type == LT_MBMODULE) {          } else if (line->type == LT_MBMODULE) {
# Line 1020  static struct grubConfig * readConfig(co Line 1208  static struct grubConfig * readConfig(co
1208       * This only applies to grub, but that's the only place we       * This only applies to grub, but that's the only place we
1209       * should find LT_MBMODULE lines anyway.       * should find LT_MBMODULE lines anyway.
1210       */       */
1211      struct singleLine * l;      for (struct singleLine *l = entry->lines; l; l = l->next) {
     for (l = entry->lines; l; l = l->next) {  
1212   if (l->type == LT_HYPER)   if (l->type == LT_HYPER)
1213      break;      break;
1214   else if (l->type == LT_KERNEL) {   else if (iskernel(l->type)) {
1215      l->type = LT_HYPER;      l->type = LT_HYPER;
1216      break;      break;
1217   }   }
# Line 1038  static struct grubConfig * readConfig(co Line 1225  static struct grubConfig * readConfig(co
1225      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1226      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
1227    
1228   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1229      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
1230        /* make the title/default a single argument (undoing our parsing) */
1231      len = 0;      len = 0;
1232      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
1233   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
1234   len += strlen(line->elements[i].indent);   len += strlen(line->elements[i].indent);
1235      }      }
1236      buf = malloc(len + 1);      buf = malloc(len + 1);
1237      *buf = '\0';      *buf = '\0';
1238    
1239      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
1240   strcat(buf, line->elements[i].item);   strcat(buf, line->elements[i].item);
1241   free(line->elements[i].item);   free(line->elements[i].item);
1242    
# Line 1068  static struct grubConfig * readConfig(co Line 1256  static struct grubConfig * readConfig(co
1256      char *extras;      char *extras;
1257      char *title;      char *title;
1258    
1259      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
1260   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
1261   len += strlen(line->elements[i].indent);   len += strlen(line->elements[i].indent);
1262      }      }
# Line 1080  static struct grubConfig * readConfig(co Line 1268  static struct grubConfig * readConfig(co
1268      *extras = '\0';      *extras = '\0';
1269    
1270      /* get title. */      /* get title. */
1271      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
1272   if (!strcmp(line->elements[i].item, "menuentry"))   if (!strcmp(line->elements[i].item, "menuentry"))
1273      continue;      continue;
1274   if (isquote(*line->elements[i].item))   if (isquote(*line->elements[i].item))
# Line 1100  static struct grubConfig * readConfig(co Line 1288  static struct grubConfig * readConfig(co
1288    
1289      /* get extras */      /* get extras */
1290      int count = 0;      int count = 0;
1291      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
1292   if (count >= 2) {   if (count >= 2) {
1293      strcat(extras, line->elements[i].item);      strcat(extras, line->elements[i].item);
1294      strcat(extras, line->elements[i].indent);      strcat(extras, line->elements[i].indent);
# Line 1146  static struct grubConfig * readConfig(co Line 1334  static struct grubConfig * readConfig(co
1334      }      }
1335   }   }
1336    
1337     if (line->type == LT_DEFAULT && line->numElements == 2) {
1338        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1339        defaultLine = line;
1340     }
1341    
1342   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
1343     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
1344     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
# Line 1203  static struct grubConfig * readConfig(co Line 1396  static struct grubConfig * readConfig(co
1396          if (defaultLine->numElements > 2 &&          if (defaultLine->numElements > 2 &&
1397      cfi->defaultSupportSaved &&      cfi->defaultSupportSaved &&
1398      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1399      cfg->defaultImage = DEFAULT_SAVED_GRUB2;   cfg->cfi->defaultIsSaved = 1;
1400     cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1401     if (cfg->cfi->getEnv) {
1402        char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1403        if (defTitle) {
1404     int index = 0;
1405     if (isnumber(defTitle)) {
1406        index = atoi(defTitle);
1407        entry = findEntryByIndex(cfg, index);
1408     } else {
1409        entry = findEntryByTitle(cfg, defTitle, &index);
1410     }
1411     if (entry)
1412        cfg->defaultImage = index;
1413        }
1414     }
1415   } else if (cfi->defaultIsVariable) {   } else if (cfi->defaultIsVariable) {
1416      char *value = defaultLine->elements[2].item;      char *value = defaultLine->elements[2].item;
1417      while (*value && (*value == '"' || *value == '\'' ||      while (*value && (*value == '"' || *value == '\'' ||
# Line 1221  static struct grubConfig * readConfig(co Line 1429  static struct grubConfig * readConfig(co
1429      cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);      cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1430      if (*end) cfg->defaultImage = -1;      if (*end) cfg->defaultImage = -1;
1431   } else if (defaultLine->numElements >= 2) {   } else if (defaultLine->numElements >= 2) {
1432      i = 0;      int i = 0;
1433      while ((entry = findEntryByIndex(cfg, i))) {      while ((entry = findEntryByIndex(cfg, i))) {
1434   for (line = entry->lines; line; line = line->next)   for (line = entry->lines; line; line = line->next)
1435      if (line->type == LT_TITLE) break;      if (line->type == LT_TITLE) break;
# Line 1244  static struct grubConfig * readConfig(co Line 1452  static struct grubConfig * readConfig(co
1452          cfg->defaultImage = -1;          cfg->defaultImage = -1;
1453      }      }
1454   }   }
1455        } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1456     char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1457     if (defTitle) {
1458        int index = 0;
1459        if (isnumber(defTitle)) {
1460     index = atoi(defTitle);
1461     entry = findEntryByIndex(cfg, index);
1462        } else {
1463     entry = findEntryByTitle(cfg, defTitle, &index);
1464        }
1465        if (entry)
1466     cfg->defaultImage = index;
1467     }
1468      } else {      } else {
1469          cfg->defaultImage = 0;          cfg->defaultImage = 0;
1470      }      }
# Line 1261  static void writeDefault(FILE * out, cha Line 1482  static void writeDefault(FILE * out, cha
1482    
1483      if (cfg->defaultImage == DEFAULT_SAVED)      if (cfg->defaultImage == DEFAULT_SAVED)
1484   fprintf(out, "%sdefault%ssaved\n", indent, separator);   fprintf(out, "%sdefault%ssaved\n", indent, separator);
1485      else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)      else if (cfg->cfi->defaultIsSaved) {
1486   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1487      else if (cfg->defaultImage > -1) {   if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1488        char *title;
1489        entry = findEntryByIndex(cfg, cfg->defaultImage);
1490        line = getLineByType(LT_MENUENTRY, entry->lines);
1491        if (!line)
1492     line = getLineByType(LT_TITLE, entry->lines);
1493        if (line) {
1494     title = extractTitle(line);
1495     if (title)
1496        cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1497        }
1498     }
1499        } else if (cfg->defaultImage > -1) {
1500   if (cfg->cfi->defaultIsIndex) {   if (cfg->cfi->defaultIsIndex) {
1501      if (cfg->cfi->defaultIsVariable) {      if (cfg->cfi->defaultIsVariable) {
1502          fprintf(out, "%sset default=\"%d\"\n", indent,          fprintf(out, "%sset default=\"%d\"\n", indent,
# Line 1323  static int writeConfig(struct grubConfig Line 1556  static int writeConfig(struct grubConfig
1556    
1557      /* most likely the symlink is relative, so change our      /* most likely the symlink is relative, so change our
1558         directory to the dir of the symlink */         directory to the dir of the symlink */
1559              rc = chdir(dirname(strdupa(outName)));      char *dir = strdupa(outName);
1560        rc = chdir(dirname(dir));
1561      do {      do {
1562   buf = alloca(len + 1);   buf = alloca(len + 1);
1563   rc = readlink(basename(outName), buf, len);   rc = readlink(basename(outName), buf, len);
# Line 1365  static int writeConfig(struct grubConfig Line 1599  static int writeConfig(struct grubConfig
1599      while (line) {      while (line) {
1600          if (line->type == LT_SET_VARIABLE && defaultKw &&          if (line->type == LT_SET_VARIABLE && defaultKw &&
1601   line->numElements == 3 &&   line->numElements == 3 &&
1602   !strcmp(line->elements[1].item, defaultKw->key)) {   !strcmp(line->elements[1].item, defaultKw->key) &&
1603     !is_special_grub2_variable(line->elements[2].item)) {
1604      writeDefault(out, line->indent, line->elements[0].indent, cfg);      writeDefault(out, line->indent, line->elements[0].indent, cfg);
1605      needs &= ~MAIN_DEFAULT;      needs &= ~MAIN_DEFAULT;
1606   } else if (line->type == LT_DEFAULT) {   } else if (line->type == LT_DEFAULT) {
# Line 1510  static char *findDiskForRoot() Line 1745  static char *findDiskForRoot()
1745      return NULL;      return NULL;
1746  }  }
1747    
1748  void printEntry(struct singleEntry * entry) {  void printEntry(struct singleEntry * entry, FILE *f) {
1749      int i;      int i;
1750      struct singleLine * line;      struct singleLine * line;
1751    
1752      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
1753   fprintf(stderr, "DBG: %s", line->indent);   log_message(f, "DBG: %s", line->indent);
1754   for (i = 0; i < line->numElements; i++) {   for (i = 0; i < line->numElements; i++) {
1755      /* Need to handle this, because we strip the quotes from      /* Need to handle this, because we strip the quotes from
1756       * menuentry when read it. */       * menuentry when read it. */
1757      if (line->type == LT_MENUENTRY && i == 1) {      if (line->type == LT_MENUENTRY && i == 1) {
1758   if(!isquote(*line->elements[i].item))   if(!isquote(*line->elements[i].item))
1759      fprintf(stderr, "\'%s\'", line->elements[i].item);      log_message(f, "\'%s\'", line->elements[i].item);
1760   else   else
1761      fprintf(stderr, "%s", line->elements[i].item);      log_message(f, "%s", line->elements[i].item);
1762   fprintf(stderr, "%s", line->elements[i].indent);   log_message(f, "%s", line->elements[i].indent);
1763    
1764   continue;   continue;
1765      }      }
1766            
1767      fprintf(stderr, "%s%s",      log_message(f, "%s%s",
1768      line->elements[i].item, line->elements[i].indent);      line->elements[i].item, line->elements[i].indent);
1769   }   }
1770   fprintf(stderr, "\n");   log_message(f, "\n");
1771      }      }
1772  }  }
1773    
1774  void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)  void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1775  {  {
1776      va_list argp;      static int once;
1777        va_list argp, argq;
1778    
1779        va_start(argp, fmt);
1780    
1781        va_copy(argq, argp);
1782        if (!once) {
1783     log_time(NULL);
1784     log_message(NULL, "command line: %s\n", saved_command_line);
1785        }
1786        log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1787        log_vmessage(NULL, fmt, argq);
1788    
1789        printEntry(entry, NULL);
1790        va_end(argq);
1791    
1792      if (!debug)      if (!debug) {
1793     once = 1;
1794         va_end(argp);
1795   return;   return;
1796        }
1797    
1798      va_start(argp, fmt);      if (okay) {
1799     va_end(argp);
1800     return;
1801        }
1802    
1803        if (!once)
1804     log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1805        once = 1;
1806      fprintf(stderr, "DBG: Image entry failed: ");      fprintf(stderr, "DBG: Image entry failed: ");
1807      vfprintf(stderr, fmt, argp);      vfprintf(stderr, fmt, argp);
1808      printEntry(entry);      printEntry(entry, stderr);
1809      va_end(argp);      va_end(argp);
1810  }  }
1811    
# Line 1573  int suitableImage(struct singleEntry * e Line 1832  int suitableImage(struct singleEntry * e
1832      char * rootdev;      char * rootdev;
1833    
1834      if (skipRemoved && entry->skip) {      if (skipRemoved && entry->skip) {
1835   notSuitablePrintf(entry, "marked to skip\n");   notSuitablePrintf(entry, 0, "marked to skip\n");
1836   return 0;   return 0;
1837      }      }
1838    
1839      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1840      if (!line) {      if (!line) {
1841   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
1842   return 0;   return 0;
1843      }      }
1844      if (line->numElements < 2) {      if (line->numElements < 2) {
1845   notSuitablePrintf(entry, "line has only %d elements\n",   notSuitablePrintf(entry, 0, "line has only %d elements\n",
1846      line->numElements);      line->numElements);
1847   return 0;   return 0;
1848      }      }
1849    
1850      if (flags & GRUBBY_BADIMAGE_OKAY) return 1;      if (flags & GRUBBY_BADIMAGE_OKAY) {
1851        notSuitablePrintf(entry, 1, "\n");
1852        return 1;
1853        }
1854    
1855      fullName = alloca(strlen(bootPrefix) +      fullName = alloca(strlen(bootPrefix) +
1856        strlen(line->elements[1].item) + 1);        strlen(line->elements[1].item) + 1);
# Line 1599  int suitableImage(struct singleEntry * e Line 1861  int suitableImage(struct singleEntry * e
1861      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1862              line->elements[1].item + rootspec_offset);              line->elements[1].item + rootspec_offset);
1863      if (access(fullName, R_OK)) {      if (access(fullName, R_OK)) {
1864   notSuitablePrintf(entry, "access to %s failed\n", fullName);   notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1865   return 0;   return 0;
1866      }      }
1867      for (i = 2; i < line->numElements; i++)      for (i = 2; i < line->numElements; i++)
# Line 1620  int suitableImage(struct singleEntry * e Line 1882  int suitableImage(struct singleEntry * e
1882    
1883              /* failed to find one */              /* failed to find one */
1884              if (!line) {              if (!line) {
1885   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
1886   return 0;   return 0;
1887              }              }
1888    
# Line 1629  int suitableImage(struct singleEntry * e Line 1891  int suitableImage(struct singleEntry * e
1891      if (i < line->numElements)      if (i < line->numElements)
1892          dev = line->elements[i].item + 5;          dev = line->elements[i].item + 5;
1893      else {      else {
1894   notSuitablePrintf(entry, "no root= entry found\n");   notSuitablePrintf(entry, 0, "no root= entry found\n");
1895   /* it failed too...  can't find root= */   /* it failed too...  can't find root= */
1896          return 0;          return 0;
1897              }              }
# Line 1638  int suitableImage(struct singleEntry * e Line 1900  int suitableImage(struct singleEntry * e
1900    
1901      dev = getpathbyspec(dev);      dev = getpathbyspec(dev);
1902      if (!getpathbyspec(dev)) {      if (!getpathbyspec(dev)) {
1903          notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);          notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1904          return 0;          return 0;
1905      } else      } else
1906   dev = getpathbyspec(dev);   dev = getpathbyspec(dev);
1907    
1908      rootdev = findDiskForRoot();      rootdev = findDiskForRoot();
1909      if (!rootdev) {      if (!rootdev) {
1910          notSuitablePrintf(entry, "can't find root device\n");          notSuitablePrintf(entry, 0, "can't find root device\n");
1911   return 0;   return 0;
1912      }      }
1913    
1914      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1915          notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1916   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
1917          free(rootdev);          free(rootdev);
1918          return 0;          return 0;
1919      }      }
1920    
1921      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1922          notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1923   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
1924   free(rootdev);   free(rootdev);
1925          return 0;          return 0;
1926      }      }
1927    
1928      free(rootdev);      free(rootdev);
1929        notSuitablePrintf(entry, 1, "\n");
1930    
1931      return 1;      return 1;
1932  }  }
# Line 1697  struct singleEntry * findEntryByPath(str Line 1960  struct singleEntry * findEntryByPath(str
1960   }   }
1961    
1962   indexVars[i + 1] = -1;   indexVars[i + 1] = -1;
1963    
1964   i = 0;   i = 0;
1965   if (index) {   if (index) {
1966      while (i < *index) i++;      while (i < *index) {
1967      if (indexVars[i] == -1) return NULL;   i++;
1968     if (indexVars[i] == -1) return NULL;
1969        }
1970   }   }
1971    
1972   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
1973   if (!entry) return NULL;   if (!entry) return NULL;
1974    
1975   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1976   if (!line) return NULL;   if (!line) return NULL;
1977    
1978   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
# Line 1756  struct singleEntry * findEntryByPath(str Line 2021  struct singleEntry * findEntryByPath(str
2021    
2022      /* check all the lines matching checkType */      /* check all the lines matching checkType */
2023      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
2024   line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?   enum lineType_e ct = checkType;
2025       LT_KERNEL|LT_MBMODULE|LT_HYPER :   if (entry->multiboot && checkType == LT_KERNEL)
2026       checkType, line);      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2027   if (!line) break;  /* not found in this entry */   else if (checkType & LT_KERNEL)
2028        ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2029     line = getLineByType(ct, line);
2030     if (!line)
2031        break;  /* not found in this entry */
2032    
2033   if (line && line->type != LT_MENUENTRY &&   if (line && line->type != LT_MENUENTRY &&
2034   line->numElements >= 2) {   line->numElements >= 2) {
# Line 1778  struct singleEntry * findEntryByPath(str Line 2047  struct singleEntry * findEntryByPath(str
2047       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
2048       * unfortunate)       * unfortunate)
2049       */       */
2050      if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2051   break; /* found 'im! */   break; /* found 'im! */
2052   }   }
2053    
# Line 1788  struct singleEntry * findEntryByPath(str Line 2057  struct singleEntry * findEntryByPath(str
2057      return entry;      return entry;
2058  }  }
2059    
2060    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2061          int * index) {
2062        struct singleEntry * entry;
2063        struct singleLine * line;
2064        int i;
2065        char * newtitle;
2066    
2067        for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2068     if (index && i < *index)
2069        continue;
2070     line = getLineByType(LT_TITLE, entry->lines);
2071     if (!line)
2072        line = getLineByType(LT_MENUENTRY, entry->lines);
2073     if (!line)
2074        continue;
2075     newtitle = grub2ExtractTitle(line);
2076     if (!newtitle)
2077        continue;
2078     if (!strcmp(title, newtitle))
2079        break;
2080        }
2081    
2082        if (!entry)
2083     return NULL;
2084    
2085        if (index)
2086     *index = i;
2087        return entry;
2088    }
2089    
2090  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2091      struct singleEntry * entry;      struct singleEntry * entry;
2092    
# Line 1810  struct singleEntry * findTemplate(struct Line 2109  struct singleEntry * findTemplate(struct
2109      struct singleEntry * entry, * entry2;      struct singleEntry * entry, * entry2;
2110      int index;      int index;
2111    
2112      if (cfg->defaultImage > -1) {      if (cfg->cfi->defaultIsSaved) {
2113     if (cfg->cfi->getEnv) {
2114        char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2115        if (defTitle) {
2116     int index = 0;
2117     if (isnumber(defTitle)) {
2118        index = atoi(defTitle);
2119        entry = findEntryByIndex(cfg, index);
2120     } else {
2121        entry = findEntryByTitle(cfg, defTitle, &index);
2122     }
2123     if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2124        cfg->defaultImage = index;
2125        if (indexPtr)
2126     *indexPtr = index;
2127        return entry;
2128     }
2129        }
2130     }
2131        } else if (cfg->defaultImage > -1) {
2132   entry = findEntryByIndex(cfg, cfg->defaultImage);   entry = findEntryByIndex(cfg, cfg->defaultImage);
2133   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2134      if (indexPtr) *indexPtr = cfg->defaultImage;      if (indexPtr) *indexPtr = cfg->defaultImage;
# Line 1880  void markRemovedImage(struct grubConfig Line 2198  void markRemovedImage(struct grubConfig
2198    
2199  void setDefaultImage(struct grubConfig * config, int hasNew,  void setDefaultImage(struct grubConfig * config, int hasNew,
2200       const char * defaultKernelPath, int newIsDefault,       const char * defaultKernelPath, int newIsDefault,
2201       const char * prefix, int flags) {       const char * prefix, int flags, int index) {
2202      struct singleEntry * entry, * entry2, * newDefault;      struct singleEntry * entry, * entry2, * newDefault;
2203      int i, j;      int i, j;
2204    
2205      if (newIsDefault) {      if (newIsDefault) {
2206   config->defaultImage = 0;   config->defaultImage = 0;
2207   return;   return;
2208        } else if ((index >= 0) && config->cfi->defaultIsIndex) {
2209     if (findEntryByIndex(config, index))
2210        config->defaultImage = index;
2211     else
2212        config->defaultImage = -1;
2213     return;
2214      } else if (defaultKernelPath) {      } else if (defaultKernelPath) {
2215   i = 0;   i = 0;
2216   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
# Line 1958  void displayEntry(struct singleEntry * e Line 2282  void displayEntry(struct singleEntry * e
2282      struct singleLine * line;      struct singleLine * line;
2283      char * root = NULL;      char * root = NULL;
2284      int i;      int i;
2285        int j;
2286    
2287      printf("index=%d\n", index);      printf("index=%d\n", index);
2288    
2289      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2290      if (!line) {      if (!line) {
2291          printf("non linux entry\n");          printf("non linux entry\n");
2292          return;          return;
2293      }      }
2294    
2295      printf("kernel=%s%s\n", prefix, line->elements[1].item);      if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2296     printf("kernel=%s\n", line->elements[1].item);
2297        else
2298     printf("kernel=%s%s\n", prefix, line->elements[1].item);
2299    
2300      if (line->numElements >= 3) {      if (line->numElements >= 3) {
2301   printf("args=\"");   printf("args=\"");
# Line 2023  void displayEntry(struct singleEntry * e Line 2351  void displayEntry(struct singleEntry * e
2351   printf("root=%s\n", s);   printf("root=%s\n", s);
2352      }      }
2353    
2354      line = getLineByType(LT_INITRD, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2355    
2356      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
2357   printf("initrd=%s", prefix);   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2358        printf("initrd=");
2359     else
2360        printf("initrd=%s", prefix);
2361    
2362   for (i = 1; i < line->numElements; i++)   for (i = 1; i < line->numElements; i++)
2363      printf("%s%s", line->elements[i].item, line->elements[i].indent);      printf("%s%s", line->elements[i].item, line->elements[i].indent);
2364   printf("\n");   printf("\n");
# Line 2038  void displayEntry(struct singleEntry * e Line 2370  void displayEntry(struct singleEntry * e
2370      } else {      } else {
2371   char * title;   char * title;
2372   line = getLineByType(LT_MENUENTRY, entry->lines);   line = getLineByType(LT_MENUENTRY, entry->lines);
2373   title = grub2ExtractTitle(line);   if (!line) {
2374   if (title)      title = grub2ExtractTitle(line);
2375      printf("title=%s\n", title);      if (title)
2376     printf("title=%s\n", title);
2377     }
2378        }
2379    
2380        for (j = 0, line = entry->lines; line; line = line->next) {
2381     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2382        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2383     printf("mbmodule%d=", j);
2384        else
2385     printf("mbmodule%d=%s", j, prefix);
2386    
2387        for (i = 1; i < line->numElements; i++)
2388     printf("%s%s", line->elements[i].item, line->elements[i].indent);
2389        printf("\n");
2390        j++;
2391     }
2392        }
2393    }
2394    
2395    int isSuseSystem(void) {
2396        const char * path;
2397        const static char default_path[] = "/etc/SuSE-release";
2398    
2399        if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2400     path = default_path;
2401    
2402        if (!access(path, R_OK))
2403     return 1;
2404        return 0;
2405    }
2406    
2407    int isSuseGrubConf(const char * path) {
2408        FILE * grubConf;
2409        char * line = NULL;
2410        size_t len = 0, res = 0;
2411    
2412        grubConf = fopen(path, "r");
2413        if (!grubConf) {
2414            dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2415     return 0;
2416      }      }
2417    
2418        while ((res = getline(&line, &len, grubConf)) != -1) {
2419     if (!strncmp(line, "setup", 5)) {
2420        fclose(grubConf);
2421        free(line);
2422        return 1;
2423     }
2424        }
2425    
2426        dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2427          path);
2428    
2429        fclose(grubConf);
2430        free(line);
2431        return 0;
2432    }
2433    
2434    int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2435        FILE * grubConf;
2436        char * line = NULL;
2437        size_t res = 0, len = 0;
2438    
2439        if (!path) return 1;
2440        if (!lbaPtr) return 1;
2441    
2442        grubConf = fopen(path, "r");
2443        if (!grubConf) return 1;
2444    
2445        while ((res = getline(&line, &len, grubConf)) != -1) {
2446     if (line[res - 1] == '\n')
2447        line[res - 1] = '\0';
2448     else if (len > res)
2449        line[res] = '\0';
2450     else {
2451        line = realloc(line, res + 1);
2452        line[res] = '\0';
2453     }
2454    
2455     if (!strncmp(line, "setup", 5)) {
2456        if (strstr(line, "--force-lba")) {
2457            *lbaPtr = 1;
2458        } else {
2459            *lbaPtr = 0;
2460        }
2461        dbgPrintf("lba: %i\n", *lbaPtr);
2462        break;
2463     }
2464        }
2465    
2466        free(line);
2467        fclose(grubConf);
2468        return 0;
2469    }
2470    
2471    int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2472        FILE * grubConf;
2473        char * line = NULL;
2474        size_t res = 0, len = 0;
2475        char * lastParamPtr = NULL;
2476        char * secLastParamPtr = NULL;
2477        char installDeviceNumber = '\0';
2478        char * bounds = NULL;
2479    
2480        if (!path) return 1;
2481        if (!devicePtr) return 1;
2482    
2483        grubConf = fopen(path, "r");
2484        if (!grubConf) return 1;
2485    
2486        while ((res = getline(&line, &len, grubConf)) != -1) {
2487     if (strncmp(line, "setup", 5))
2488        continue;
2489    
2490     if (line[res - 1] == '\n')
2491        line[res - 1] = '\0';
2492     else if (len > res)
2493        line[res] = '\0';
2494     else {
2495        line = realloc(line, res + 1);
2496        line[res] = '\0';
2497     }
2498    
2499     lastParamPtr = bounds = line + res;
2500    
2501     /* Last parameter in grub may be an optional IMAGE_DEVICE */
2502     while (!isspace(*lastParamPtr))
2503        lastParamPtr--;
2504     lastParamPtr++;
2505    
2506     secLastParamPtr = lastParamPtr - 2;
2507     dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2508    
2509     if (lastParamPtr + 3 > bounds) {
2510        dbgPrintf("lastParamPtr going over boundary");
2511        fclose(grubConf);
2512        free(line);
2513        return 1;
2514     }
2515     if (!strncmp(lastParamPtr, "(hd", 3))
2516        lastParamPtr += 3;
2517     dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2518    
2519     /*
2520     * Second last parameter will decide wether last parameter is
2521     * an IMAGE_DEVICE or INSTALL_DEVICE
2522     */
2523     while (!isspace(*secLastParamPtr))
2524        secLastParamPtr--;
2525     secLastParamPtr++;
2526    
2527     if (secLastParamPtr + 3 > bounds) {
2528        dbgPrintf("secLastParamPtr going over boundary");
2529        fclose(grubConf);
2530        free(line);
2531        return 1;
2532     }
2533     dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2534     if (!strncmp(secLastParamPtr, "(hd", 3)) {
2535        secLastParamPtr += 3;
2536        dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2537        installDeviceNumber = *secLastParamPtr;
2538     } else {
2539        installDeviceNumber = *lastParamPtr;
2540     }
2541    
2542     *devicePtr = malloc(6);
2543     snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2544     dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2545     fclose(grubConf);
2546     free(line);
2547     return 0;
2548        }
2549    
2550        free(line);
2551        fclose(grubConf);
2552        return 1;
2553    }
2554    
2555    int grubGetBootFromDeviceMap(const char * device,
2556         char ** bootPtr) {
2557        FILE * deviceMap;
2558        char * line = NULL;
2559        size_t res = 0, len = 0;
2560        char * devicePtr;
2561        char * bounds = NULL;
2562        const char * path;
2563        const static char default_path[] = "/boot/grub/device.map";
2564    
2565        if (!device) return 1;
2566        if (!bootPtr) return 1;
2567    
2568        if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2569     path = default_path;
2570    
2571        dbgPrintf("opening grub device.map file from: %s\n", path);
2572        deviceMap = fopen(path, "r");
2573        if (!deviceMap)
2574     return 1;
2575    
2576        while ((res = getline(&line, &len, deviceMap)) != -1) {
2577            if (!strncmp(line, "#", 1))
2578        continue;
2579    
2580     if (line[res - 1] == '\n')
2581        line[res - 1] = '\0';
2582     else if (len > res)
2583        line[res] = '\0';
2584     else {
2585        line = realloc(line, res + 1);
2586        line[res] = '\0';
2587     }
2588    
2589     devicePtr = line;
2590     bounds = line + res;
2591    
2592     while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2593        devicePtr++;
2594     dbgPrintf("device: %s\n", devicePtr);
2595    
2596     if (!strncmp(devicePtr, device, strlen(device))) {
2597        devicePtr += strlen(device);
2598        while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2599            devicePtr++;
2600    
2601        *bootPtr = strdup(devicePtr);
2602        break;
2603     }
2604        }
2605    
2606        free(line);
2607        fclose(deviceMap);
2608        return 0;
2609    }
2610    
2611    int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2612        char * grubDevice;
2613    
2614        if (suseGrubConfGetInstallDevice(path, &grubDevice))
2615     dbgPrintf("error looking for grub installation device\n");
2616        else
2617     dbgPrintf("grubby installation device: %s\n", grubDevice);
2618    
2619        if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2620     dbgPrintf("error looking for grub boot device\n");
2621        else
2622     dbgPrintf("grubby boot device: %s\n", *bootPtr);
2623    
2624        free(grubDevice);
2625        return 0;
2626    }
2627    
2628    int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2629        /*
2630         * This SuSE grub configuration file at this location is not your average
2631         * grub configuration file, but instead the grub commands used to setup
2632         * grub on that system.
2633         */
2634        const char * path;
2635        const static char default_path[] = "/etc/grub.conf";
2636    
2637        if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2638     path = default_path;
2639    
2640        if (!isSuseGrubConf(path)) return 1;
2641    
2642        if (lbaPtr) {
2643            *lbaPtr = 0;
2644            if (suseGrubConfGetLba(path, lbaPtr))
2645                return 1;
2646        }
2647    
2648        if (bootPtr) {
2649            *bootPtr = NULL;
2650            suseGrubConfGetBoot(path, bootPtr);
2651        }
2652    
2653        return 0;
2654  }  }
2655    
2656  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
# Line 2092  int parseSysconfigGrub(int * lbaPtr, cha Line 2701  int parseSysconfigGrub(int * lbaPtr, cha
2701  }  }
2702    
2703  void dumpSysconfigGrub(void) {  void dumpSysconfigGrub(void) {
2704      char * boot;      char * boot = NULL;
2705      int lba;      int lba;
2706    
2707      if (!parseSysconfigGrub(&lba, &boot)) {      if (isSuseSystem()) {
2708   if (lba) printf("lba\n");          if (parseSuseGrubConf(&lba, &boot)) {
2709   if (boot) printf("boot=%s\n", boot);      free(boot);
2710        return;
2711     }
2712        } else {
2713            if (parseSysconfigGrub(&lba, &boot)) {
2714        free(boot);
2715        return;
2716     }
2717        }
2718    
2719        if (lba) printf("lba\n");
2720        if (boot) {
2721     printf("boot=%s\n", boot);
2722     free(boot);
2723      }      }
2724  }  }
2725    
# Line 2146  struct singleLine * addLineTmpl(struct s Line 2768  struct singleLine * addLineTmpl(struct s
2768  {  {
2769      struct singleLine * newLine = lineDup(tmplLine);      struct singleLine * newLine = lineDup(tmplLine);
2770    
2771        if (isEfi && cfi == &grub2ConfigType) {
2772     enum lineType_e old = newLine->type;
2773     newLine->type = preferredLineType(newLine->type, cfi);
2774     if (old != newLine->type)
2775        newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2776        }
2777    
2778      if (val) {      if (val) {
2779   /* override the inherited value with our own.   /* override the inherited value with our own.
2780   * 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 2155  struct singleLine * addLineTmpl(struct s Line 2784  struct singleLine * addLineTmpl(struct s
2784   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
2785    
2786   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
2787   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)) {
2788      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2789      if (rootspec != NULL) {      if (rootspec != NULL) {
2790   free(newLine->elements[1].item);   free(newLine->elements[1].item);
# Line 2192  struct singleLine *  addLine(struct sing Line 2821  struct singleLine *  addLine(struct sing
2821      /* 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
2822       * stack since it calls addLineTmpl which will make copies.       * stack since it calls addLineTmpl which will make copies.
2823       */       */
   
2824      if (type == LT_TITLE && cfi->titleBracketed) {      if (type == LT_TITLE && cfi->titleBracketed) {
2825   /* we're doing a bracketed title (zipl) */   /* we're doing a bracketed title (zipl) */
2826   tmpl.type = type;   tmpl.type = type;
# Line 2526  int updateActualImage(struct grubConfig Line 3154  int updateActualImage(struct grubConfig
3154      firstElement = 2;      firstElement = 2;
3155    
3156   } else {   } else {
3157      line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3158      if (!line) {      if (!line) {
3159   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
3160   continue;   continue;
# Line 2682  int updateImage(struct grubConfig * cfg, Line 3310  int updateImage(struct grubConfig * cfg,
3310      return rc;      return rc;
3311  }  }
3312    
3313    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3314     const char * image, const char * prefix, const char * initrd,
3315     const char * title) {
3316        struct singleEntry * entry;
3317        struct singleLine * line, * kernelLine, *endLine = NULL;
3318        int index = 0;
3319    
3320        if (!image) return 0;
3321    
3322        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3323            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3324            if (!kernelLine) continue;
3325    
3326     /* if title is supplied, the entry's title must match it. */
3327     if (title) {
3328        char *linetitle;
3329    
3330        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3331        if (!line)
3332     continue;
3333    
3334        linetitle = extractTitle(line);
3335        if (!linetitle)
3336     continue;
3337        if (strcmp(title, linetitle)) {
3338     free(linetitle);
3339     continue;
3340        }
3341        free(linetitle);
3342     }
3343    
3344            if (prefix) {
3345                int prefixLen = strlen(prefix);
3346                if (!strncmp(initrd, prefix, prefixLen))
3347                    initrd += prefixLen;
3348            }
3349     endLine = getLineByType(LT_ENTRY_END, entry->lines);
3350     if (endLine)
3351        removeLine(entry, endLine);
3352            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3353     kernelLine->indent, initrd);
3354            if (!line)
3355        return 1;
3356     if (endLine) {
3357        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3358                if (!line)
3359     return 1;
3360     }
3361    
3362            break;
3363        }
3364    
3365        return 0;
3366    }
3367    
3368  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
3369                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd, const char * title) {
3370      struct singleEntry * entry;      struct singleEntry * entry;
3371      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
3372      int index = 0;      int index = 0;
# Line 2691  int updateInitrd(struct grubConfig * cfg Line 3374  int updateInitrd(struct grubConfig * cfg
3374      if (!image) return 0;      if (!image) return 0;
3375    
3376      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3377          kernelLine = getLineByType(LT_KERNEL, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3378          if (!kernelLine) continue;          if (!kernelLine) continue;
3379    
3380          line = getLineByType(LT_INITRD, entry->lines);   /* if title is supplied, the entry's title must match it. */
3381     if (title) {
3382        char *linetitle;
3383    
3384        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3385        if (!line)
3386     continue;
3387    
3388        linetitle = extractTitle(line);
3389        if (!linetitle)
3390     continue;
3391        if (strcmp(title, linetitle)) {
3392     free(linetitle);
3393     continue;
3394        }
3395        free(linetitle);
3396     }
3397    
3398            line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3399          if (line)          if (line)
3400              removeLine(entry, line);              removeLine(entry, line);
3401          if (prefix) {          if (prefix) {
# Line 2705  int updateInitrd(struct grubConfig * cfg Line 3406  int updateInitrd(struct grubConfig * cfg
3406   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
3407   if (endLine)   if (endLine)
3408      removeLine(entry, endLine);      removeLine(entry, endLine);
3409          line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);   enum lineType_e lt;
3410     switch(kernelLine->type) {
3411        case LT_KERNEL:
3412            lt = LT_INITRD;
3413     break;
3414        case LT_KERNEL_EFI:
3415            lt = LT_INITRD_EFI;
3416     break;
3417        case LT_KERNEL_16:
3418            lt = LT_INITRD_16;
3419     break;
3420        default:
3421            lt = preferredLineType(LT_INITRD, cfg->cfi);
3422     }
3423            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3424          if (!line)          if (!line)
3425      return 1;      return 1;
3426   if (endLine) {   if (endLine) {
# Line 2911  int checkForGrub(struct grubConfig * con Line 3626  int checkForGrub(struct grubConfig * con
3626      int fd;      int fd;
3627      unsigned char bootSect[512];      unsigned char bootSect[512];
3628      char * boot;      char * boot;
3629        int onSuse = isSuseSystem();
3630    
3631      if (parseSysconfigGrub(NULL, &boot))  
3632   return 0;      if (onSuse) {
3633     if (parseSuseGrubConf(NULL, &boot))
3634        return 0;
3635        } else {
3636     if (parseSysconfigGrub(NULL, &boot))
3637        return 0;
3638        }
3639    
3640      /* assume grub is not installed -- not an error condition */      /* assume grub is not installed -- not an error condition */
3641      if (!boot)      if (!boot)
# Line 2932  int checkForGrub(struct grubConfig * con Line 3654  int checkForGrub(struct grubConfig * con
3654      }      }
3655      close(fd);      close(fd);
3656    
3657        /* The more elaborate checks do not work on SuSE. The checks done
3658         * seem to be reasonble (at least for now), so just return success
3659         */
3660        if (onSuse)
3661     return 2;
3662    
3663      return checkDeviceBootloader(boot, bootSect);      return checkDeviceBootloader(boot, bootSect);
3664  }  }
3665    
# Line 2965  int checkForExtLinux(struct grubConfig * Line 3693  int checkForExtLinux(struct grubConfig *
3693      return checkDeviceBootloader(boot, bootSect);      return checkDeviceBootloader(boot, bootSect);
3694  }  }
3695    
3696    int checkForYaboot(struct grubConfig * config) {
3697        /*
3698         * This is a simplistic check that we consider good enough for own puporses
3699         *
3700         * If we were to properly check if yaboot is *installed* we'd need to:
3701         * 1) get the system boot device (LT_BOOT)
3702         * 2) considering it's a raw filesystem, check if the yaboot binary matches
3703         *    the content on the boot device
3704         * 3) if not, copy the binary to a temporary file and run "addnote" on it
3705         * 4) check again if binary and boot device contents match
3706         */
3707        if (!access("/etc/yaboot.conf", R_OK))
3708     return 2;
3709    
3710        return 1;
3711    }
3712    
3713    int checkForElilo(struct grubConfig * config) {
3714        if (!access("/etc/elilo.conf", R_OK))
3715     return 2;
3716    
3717        return 1;
3718    }
3719    
3720  static char * getRootSpecifier(char * str) {  static char * getRootSpecifier(char * str) {
3721      char * idx, * rootspec = NULL;      char * idx, * rootspec = NULL;
3722    
# Line 3027  int addNewKernel(struct grubConfig * con Line 3779  int addNewKernel(struct grubConfig * con
3779   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
3780   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
3781   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
3782                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
3783     const char * newDevTreePath) {
3784      struct singleEntry * new;      struct singleEntry * new;
3785      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3786      int needs;      int needs;
# Line 3068  int addNewKernel(struct grubConfig * con Line 3821  int addNewKernel(struct grubConfig * con
3821          needs |= NEED_MB;          needs |= NEED_MB;
3822          new->multiboot = 1;          new->multiboot = 1;
3823      }      }
3824        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3825     needs |= NEED_DEVTREE;
3826    
3827      if (template) {      if (template) {
3828   for (masterLine = template->lines;   for (masterLine = template->lines;
# Line 3081  int addNewKernel(struct grubConfig * con Line 3836  int addNewKernel(struct grubConfig * con
3836      while (*chptr && isspace(*chptr)) chptr++;      while (*chptr && isspace(*chptr)) chptr++;
3837      if (*chptr == '#') continue;      if (*chptr == '#') continue;
3838    
3839      if (tmplLine->type == LT_KERNEL &&      if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
     tmplLine->numElements >= 2) {  
3840   if (!template->multiboot && (needs & NEED_MB)) {   if (!template->multiboot && (needs & NEED_MB)) {
3841      /* it's not a multiboot template and this is the kernel      /* it's not a multiboot template and this is the kernel
3842       * line.  Try to be intelligent about inserting the       * line.  Try to be intelligent about inserting the
# Line 3159  int addNewKernel(struct grubConfig * con Line 3913  int addNewKernel(struct grubConfig * con
3913      /* template is multi but new is not,      /* template is multi but new is not,
3914       * insert the kernel in the first module slot       * insert the kernel in the first module slot
3915       */       */
3916      tmplLine->type = LT_KERNEL;      tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3917      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
3918      tmplLine->elements[0].item =      tmplLine->elements[0].item =
3919   strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
3920     config->cfi)->key);
3921      newLine = addLineTmpl(new, tmplLine, newLine,      newLine = addLineTmpl(new, tmplLine, newLine,
3922    newKernelPath + strlen(prefix), config->cfi);    newKernelPath + strlen(prefix),
3923      config->cfi);
3924      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
3925   } else if (needs & NEED_INITRD) {   } else if (needs & NEED_INITRD) {
3926      char *initrdVal;      char *initrdVal;
3927      /* template is multi but new is not,      /* template is multi but new is not,
3928       * insert the initrd in the second module slot       * insert the initrd in the second module slot
3929       */       */
3930      tmplLine->type = LT_INITRD;      tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3931      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
3932      tmplLine->elements[0].item =      tmplLine->elements[0].item =
3933   strdup(getKeywordByType(LT_INITRD, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
3934     config->cfi)->key);
3935      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3936      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3937      free(initrdVal);      free(initrdVal);
3938      needs &= ~NEED_INITRD;      needs &= ~NEED_INITRD;
3939   }   }
3940    
3941      } else if (tmplLine->type == LT_INITRD &&      } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
        tmplLine->numElements >= 2) {  
3942   if (needs & NEED_INITRD &&   if (needs & NEED_INITRD &&
3943      new->multiboot && !template->multiboot &&      new->multiboot && !template->multiboot &&
3944      config->cfi->mbInitRdIsModule) {      config->cfi->mbInitRdIsModule) {
# Line 3236  int addNewKernel(struct grubConfig * con Line 3992  int addNewKernel(struct grubConfig * con
3992      static const char *prefix = "'Loading ";      static const char *prefix = "'Loading ";
3993      if (tmplLine->numElements > 1 &&      if (tmplLine->numElements > 1 &&
3994      strstr(tmplLine->elements[1].item, prefix) &&      strstr(tmplLine->elements[1].item, prefix) &&
3995      masterLine->next && masterLine->next->type == LT_KERNEL) {      masterLine->next &&
3996        iskernel(masterLine->next->type)) {
3997   char *newTitle = malloc(strlen(prefix) +   char *newTitle = malloc(strlen(prefix) +
3998   strlen(newKernelTitle) + 2);   strlen(newKernelTitle) + 2);
3999    
# Line 3251  int addNewKernel(struct grubConfig * con Line 4008  int addNewKernel(struct grubConfig * con
4008   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4009   config->cfi);   config->cfi);
4010      }      }
4011        } else if (tmplLine->type == LT_DEVTREE &&
4012           tmplLine->numElements == 2 && newDevTreePath) {
4013            newLine = addLineTmpl(new, tmplLine, newLine,
4014          newDevTreePath + strlen(prefix),
4015          config->cfi);
4016     needs &= ~NEED_DEVTREE;
4017        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4018     const char *ndtp = newDevTreePath;
4019     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4020        ndtp += strlen(prefix);
4021     newLine = addLine(new, config->cfi, LT_DEVTREE,
4022      config->secondaryIndent,
4023      ndtp);
4024     needs &= ~NEED_DEVTREE;
4025     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4026      } else {      } else {
4027   /* pass through other lines from the template */   /* pass through other lines from the template */
4028   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
# Line 3263  int addNewKernel(struct grubConfig * con Line 4035  int addNewKernel(struct grubConfig * con
4035   */   */
4036   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
4037      case LT_KERNEL:      case LT_KERNEL:
4038        case LT_KERNEL_EFI:
4039        case LT_KERNEL_16:
4040   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
4041      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
4042   } else {   } else {
4043      newLine = addLine(new, config->cfi, LT_KERNEL,      newLine = addLine(new, config->cfi,
4044              preferredLineType(LT_KERNEL, config->cfi),
4045        config->primaryIndent,        config->primaryIndent,
4046        newKernelPath + strlen(prefix));        newKernelPath + strlen(prefix));
4047      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
# Line 3323  int addNewKernel(struct grubConfig * con Line 4098  int addNewKernel(struct grubConfig * con
4098   }   }
4099      }      }
4100    
4101        struct singleLine *endLine = NULL;
4102        endLine = getLineByType(LT_ENTRY_END, new->lines);
4103        if (endLine) {
4104        removeLine(new, endLine);
4105        needs |= NEED_END;
4106        }
4107    
4108      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
4109       * 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,
4110       * all the lines following the entryStart.       * all the lines following the entryStart.
# Line 3342  int addNewKernel(struct grubConfig * con Line 4124  int addNewKernel(struct grubConfig * con
4124      if (needs & NEED_KERNEL) {      if (needs & NEED_KERNEL) {
4125   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
4126    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
4127        config->cfi)) ?        config->cfi))
4128    LT_MBMODULE : LT_KERNEL,     ? LT_MBMODULE
4129     : preferredLineType(LT_KERNEL, config->cfi),
4130    config->secondaryIndent,    config->secondaryIndent,
4131    newKernelPath + strlen(prefix));    newKernelPath + strlen(prefix));
4132   needs &= ~NEED_KERNEL;   needs &= ~NEED_KERNEL;
# Line 3359  int addNewKernel(struct grubConfig * con Line 4142  int addNewKernel(struct grubConfig * con
4142   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4143   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
4144    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
4145        config->cfi)) ?        config->cfi))
4146    LT_MBMODULE : LT_INITRD,     ? LT_MBMODULE
4147       : preferredLineType(LT_INITRD, config->cfi),
4148    config->secondaryIndent,    config->secondaryIndent,
4149    initrdVal);    initrdVal);
4150   free(initrdVal);   free(initrdVal);
4151   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
4152      }      }
4153        if (needs & NEED_DEVTREE) {
4154     newLine = addLine(new, config->cfi, LT_DEVTREE,
4155      config->secondaryIndent,
4156      newDevTreePath);
4157     needs &= ~NEED_DEVTREE;
4158        }
4159    
4160        /* NEEDS_END must be last on bootloaders that need it... */
4161      if (needs & NEED_END) {      if (needs & NEED_END) {
4162   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
4163   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
# Line 3392  static void traceback(int signum) Line 4184  static void traceback(int signum)
4184      memset(array, '\0', sizeof (array));      memset(array, '\0', sizeof (array));
4185      size = backtrace(array, 40);      size = backtrace(array, 40);
4186    
4187      fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",      fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4188              (unsigned long)size);              (unsigned long)size);
4189      backtrace_symbols_fd(array, size, STDERR_FILENO);      backtrace_symbols_fd(array, size, STDERR_FILENO);
4190      exit(1);      exit(1);
# Line 3417  int main(int argc, const char ** argv) { Line 4209  int main(int argc, const char ** argv) {
4209      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
4210      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
4211      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
4212      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
4213      char * newMBKernel = NULL;      char * newMBKernel = NULL;
4214      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
4215      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
# Line 3427  int main(int argc, const char ** argv) { Line 4219  int main(int argc, const char ** argv) {
4219      char * removeArgs = NULL;      char * removeArgs = NULL;
4220      char * kernelInfo = NULL;      char * kernelInfo = NULL;
4221      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4222        char * envPath = NULL;
4223      const char * chptr = NULL;      const char * chptr = NULL;
4224      struct configFileInfo * cfi = NULL;      struct configFileInfo * cfi = NULL;
4225      struct grubConfig * config;      struct grubConfig * config;
# Line 3435  int main(int argc, const char ** argv) { Line 4228  int main(int argc, const char ** argv) {
4228      int displayDefault = 0;      int displayDefault = 0;
4229      int displayDefaultIndex = 0;      int displayDefaultIndex = 0;
4230      int displayDefaultTitle = 0;      int displayDefaultTitle = 0;
4231        int defaultIndex = -1;
4232      struct poptOption options[] = {      struct poptOption options[] = {
4233   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4234      _("add an entry for the specified kernel"), _("kernel-path") },      _("add an entry for the specified kernel"), _("kernel-path") },
# Line 3452  int main(int argc, const char ** argv) { Line 4246  int main(int argc, const char ** argv) {
4246   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4247      _("filestystem which contains /boot directory (for testing only)"),      _("filestystem which contains /boot directory (for testing only)"),
4248      _("bootfs") },      _("bootfs") },
4249  #if defined(__i386__) || defined(__x86_64__)  #if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4250   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4251      _("check if lilo is installed on lilo.conf boot sector") },      _("check which bootloader is installed on boot sector") },
4252  #endif  #endif
4253   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4254      _("path to grub config file to update (\"-\" for stdin)"),      _("path to grub config file to update (\"-\" for stdin)"),
# Line 3473  int main(int argc, const char ** argv) { Line 4267  int main(int argc, const char ** argv) {
4267      _("display the index of the default kernel") },      _("display the index of the default kernel") },
4268   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
4269      _("display the title of the default kernel") },      _("display the title of the default kernel") },
4270     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4271        _("device tree file for new stanza"), _("dtb-path") },
4272   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4273      _("configure elilo bootloader") },      _("configure elilo bootloader") },
4274     { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4275        _("force grub2 stanzas to use efi") },
4276     { "env", 0, POPT_ARG_STRING, &envPath, 0,
4277        _("path for environment data"),
4278        _("path") },
4279   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4280      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
4281   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
# Line 3487  int main(int argc, const char ** argv) { Line 4288  int main(int argc, const char ** argv) {
4288   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4289      _("initrd image for the new kernel"), _("initrd-path") },      _("initrd image for the new kernel"), _("initrd-path") },
4290   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4291      _("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },      _("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4292   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4293      _("configure lilo bootloader") },      _("configure lilo bootloader") },
4294   { "make-default", 0, 0, &makeDefault, 0,   { "make-default", 0, 0, &makeDefault, 0,
# Line 3507  int main(int argc, const char ** argv) { Line 4308  int main(int argc, const char ** argv) {
4308   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4309      _("make the first entry referencing the specified kernel "      _("make the first entry referencing the specified kernel "
4310        "the default"), _("kernel-path") },        "the default"), _("kernel-path") },
4311     { "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4312        _("make the given entry index the default entry"),
4313        _("entry-index") },
4314   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4315      _("configure silo bootloader") },      _("configure silo bootloader") },
4316   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
# Line 3528  int main(int argc, const char ** argv) { Line 4332  int main(int argc, const char ** argv) {
4332    
4333      signal(SIGSEGV, traceback);      signal(SIGSEGV, traceback);
4334    
4335        int i = 0;
4336        for (int j = 1; j < argc; j++)
4337     i += strlen(argv[j]) + 1;
4338        saved_command_line = malloc(i);
4339        if (!saved_command_line) {
4340     fprintf(stderr, "grubby: %m\n");
4341     exit(1);
4342        }
4343        saved_command_line[0] = '\0';
4344        for (int j = 1; j < argc; j++) {
4345     strcat(saved_command_line, argv[j]);
4346     strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4347        }
4348    
4349      optCon = poptGetContext("grubby", argc, argv, options, 0);      optCon = poptGetContext("grubby", argc, argv, options, 0);
4350      poptReadDefaultConfig(optCon, 1);      poptReadDefaultConfig(optCon, 1);
4351    
# Line 3571  int main(int argc, const char ** argv) { Line 4389  int main(int argc, const char ** argv) {
4389   return 1;   return 1;
4390      } else if (configureGrub2) {      } else if (configureGrub2) {
4391   cfi = &grub2ConfigType;   cfi = &grub2ConfigType;
4392     if (envPath)
4393        cfi->envFile = envPath;
4394      } else if (configureLilo) {      } else if (configureLilo) {
4395   cfi = &liloConfigType;   cfi = &liloConfigType;
4396      } else if (configureGrub) {      } else if (configureGrub) {
# Line 3614  int main(int argc, const char ** argv) { Line 4434  int main(int argc, const char ** argv) {
4434      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
4435      }      }
4436    
4437      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
4438    newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
4439    defaultKernel || displayDefaultIndex || displayDefaultTitle)) {      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4440        (defaultIndex >= 0))) {
4441   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4442    "specified option"));    "specified option"));
4443   return 1;   return 1;
4444      }      }
4445    
4446      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
4447     removeKernelPath)) {     removeKernelPath)) {
4448   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
4449    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
# Line 3632  int main(int argc, const char ** argv) { Line 4453  int main(int argc, const char ** argv) {
4453      if (newKernelPath && !newKernelTitle) {      if (newKernelPath && !newKernelTitle) {
4454   fprintf(stderr, _("grubby: kernel title must be specified\n"));   fprintf(stderr, _("grubby: kernel title must be specified\n"));
4455   return 1;   return 1;
4456      } else if (!newKernelPath && (newKernelTitle  || copyDefault ||      } else if (!newKernelPath && (copyDefault ||
4457    (newKernelInitrd && !updateKernelPath)||    (newKernelInitrd && !updateKernelPath)||
4458    makeDefault || extraInitrdCount > 0)) {    makeDefault || extraInitrdCount > 0)) {
4459   fprintf(stderr, _("grubby: kernel path expected\n"));   fprintf(stderr, _("grubby: kernel path expected\n"));
# Line 3658  int main(int argc, const char ** argv) { Line 4479  int main(int argc, const char ** argv) {
4479   makeDefault = 1;   makeDefault = 1;
4480   defaultKernel = NULL;   defaultKernel = NULL;
4481      }      }
4482        else if (defaultKernel && (defaultIndex >= 0)) {
4483     fprintf(stderr, _("grubby: --set-default and --set-default-index "
4484      "may not be used together\n"));
4485     return 1;
4486        }
4487    
4488      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4489   fprintf(stderr, _("grubby: output file must be specified if stdin "   fprintf(stderr, _("grubby: output file must be specified if stdin "
# Line 3666  int main(int argc, const char ** argv) { Line 4492  int main(int argc, const char ** argv) {
4492      }      }
4493    
4494      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4495   && !kernelInfo && !bootloaderProbe && !updateKernelPath   && !kernelInfo && !bootloaderProbe && !updateKernelPath
4496          && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {   && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4497     && (defaultIndex == -1)) {
4498   fprintf(stderr, _("grubby: no action specified\n"));   fprintf(stderr, _("grubby: no action specified\n"));
4499   return 1;   return 1;
4500      }      }
# Line 3694  int main(int argc, const char ** argv) { Line 4521  int main(int argc, const char ** argv) {
4521      }      }
4522    
4523      if (bootloaderProbe) {      if (bootloaderProbe) {
4524   int lrc = 0, grc = 0, gr2c = 0, erc = 0;   int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4525   struct grubConfig * lconfig, * gconfig;   struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4526    
4527   const char *grub2config = grub2FindConfig(&grub2ConfigType);   const char *grub2config = grub2FindConfig(&grub2ConfigType);
4528   if (grub2config) {   if (grub2config) {
# Line 3723  int main(int argc, const char ** argv) { Line 4550  int main(int argc, const char ** argv) {
4550   lrc = checkForLilo(lconfig);   lrc = checkForLilo(lconfig);
4551   }   }
4552    
4553     if (!access(eliloConfigType.defaultConfig, F_OK)) {
4554        econfig = readConfig(eliloConfigType.defaultConfig,
4555     &eliloConfigType);
4556        if (!econfig)
4557     erc = 1;
4558        else
4559     erc = checkForElilo(econfig);
4560     }
4561    
4562   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4563      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4564      if (!lconfig)      if (!lconfig)
4565   erc = 1;   extrc = 1;
4566      else      else
4567   erc = checkForExtLinux(lconfig);   extrc = checkForExtLinux(lconfig);
4568   }   }
4569    
4570   if (lrc == 1 || grc == 1 || gr2c == 1) return 1;  
4571     if (!access(yabootConfigType.defaultConfig, F_OK)) {
4572        yconfig = readConfig(yabootConfigType.defaultConfig,
4573     &yabootConfigType);
4574        if (!yconfig)
4575     yrc = 1;
4576        else
4577     yrc = checkForYaboot(yconfig);
4578     }
4579    
4580     if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4581     erc == 1)
4582        return 1;
4583    
4584   if (lrc == 2) printf("lilo\n");   if (lrc == 2) printf("lilo\n");
4585   if (gr2c == 2) printf("grub2\n");   if (gr2c == 2) printf("grub2\n");
4586   if (grc == 2) printf("grub\n");   if (grc == 2) printf("grub\n");
4587   if (erc == 2) printf("extlinux\n");   if (extrc == 2) printf("extlinux\n");
4588     if (yrc == 2) printf("yaboot\n");
4589     if (erc == 2) printf("elilo\n");
4590    
4591   return 0;   return 0;
4592      }      }
4593    
4594        if (grubConfig == NULL) {
4595     printf("Could not find bootloader configuration file.\n");
4596     exit(1);
4597        }
4598    
4599      config = readConfig(grubConfig, cfi);      config = readConfig(grubConfig, cfi);
4600      if (!config) return 1;      if (!config) return 1;
4601    
# Line 3750  int main(int argc, const char ** argv) { Line 4605  int main(int argc, const char ** argv) {
4605          char * rootspec;          char * rootspec;
4606    
4607   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
4608     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4609     cfi->defaultIsSaved)
4610        config->defaultImage = 0;
4611   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
4612   if (!entry) return 0;   if (!entry) return 0;
4613   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4614    
4615   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4616   if (!line) return 0;   if (!line) return 0;
4617    
4618          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
# Line 3768  int main(int argc, const char ** argv) { Line 4626  int main(int argc, const char ** argv) {
4626   struct singleEntry * entry;   struct singleEntry * entry;
4627    
4628   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
4629     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4630     cfi->defaultIsSaved)
4631        config->defaultImage = 0;
4632   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
4633   if (!entry) return 0;   if (!entry) return 0;
4634    
# Line 3790  int main(int argc, const char ** argv) { Line 4651  int main(int argc, const char ** argv) {
4651    
4652      } else if (displayDefaultIndex) {      } else if (displayDefaultIndex) {
4653          if (config->defaultImage == -1) return 0;          if (config->defaultImage == -1) return 0;
4654     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4655     cfi->defaultIsSaved)
4656        config->defaultImage = 0;
4657          printf("%i\n", config->defaultImage);          printf("%i\n", config->defaultImage);
4658            return 0;
4659    
4660      } else if (kernelInfo)      } else if (kernelInfo)
4661   return displayInfo(config, kernelInfo, bootPrefix);   return displayInfo(config, kernelInfo, bootPrefix);
# Line 3803  int main(int argc, const char ** argv) { Line 4668  int main(int argc, const char ** argv) {
4668      markRemovedImage(config, removeKernelPath, bootPrefix);      markRemovedImage(config, removeKernelPath, bootPrefix);
4669      markRemovedImage(config, removeMBKernel, bootPrefix);      markRemovedImage(config, removeMBKernel, bootPrefix);
4670      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4671      bootPrefix, flags);      bootPrefix, flags, defaultIndex);
4672      setFallbackImage(config, newKernelPath != NULL);      setFallbackImage(config, newKernelPath != NULL);
4673      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4674                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4675      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
4676              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
4677                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
4678     bootPrefix, newKernelInitrd,
4679     newKernelTitle))
4680        return 1;
4681        } else {
4682        if (updateInitrd(config, updateKernelPath, bootPrefix,
4683     newKernelInitrd, newKernelTitle))
4684     return 1;
4685        }
4686      }      }
4687      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
4688                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
4689                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
4690                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4691            
4692    
4693      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {

Legend:
Removed from v.1844  
changed lines
  Added in v.2962