Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/grubby/grubby.c

    Diff of /trunk/grubby/grubby.c

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

    revision 2058 by niro, Wed Feb 20 14:06:30 2013 UTC revision 2991 by niro, Thu Jun 30 10:34:31 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 58  int debug = 0; /* Currently just for tem Line 60  int debug = 0; /* Currently just for tem
    60    
    61  int isEfi = 0;  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 86  enum lineType_e { Line 96  enum lineType_e {
    96      LT_SET_VARIABLE = 1 << 19,      LT_SET_VARIABLE = 1 << 19,
    97      LT_KERNEL_EFI   = 1 << 20,      LT_KERNEL_EFI   = 1 << 20,
    98      LT_INITRD_EFI   = 1 << 21,      LT_INITRD_EFI   = 1 << 21,
    99      LT_UNKNOWN      = 1 << 22,      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 115  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 132  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;      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 153  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 172  const char *grubFindConfig(struct config Line 193  const char *grubFindConfig(struct config
    193   "/boot/grub/grub.conf",   "/boot/grub/grub.conf",
    194   "/boot/grub/menu.lst",   "/boot/grub/menu.lst",
    195   "/etc/grub.conf",   "/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 199  struct configFileInfo grubConfigType = { Line 222  struct configFileInfo grubConfigType = {
    222      .mbHyperFirst = 1,      .mbHyperFirst = 1,
    223      .mbInitRdIsModule = 1,      .mbInitRdIsModule = 1,
    224      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    225        .titlePosition = 1,
    226  };  };
    227    
    228  struct keywordTypes grub2Keywords[] = {  struct keywordTypes grub2Keywords[] = {
    # Line 211  struct keywordTypes grub2Keywords[] = { Line 235  struct keywordTypes grub2Keywords[] = {
    235      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    236      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    237      { "linuxefi",   LT_KERNEL_EFI,  ' ' },      { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    238        { "linux16",    LT_KERNEL_16,   ' ' },
    239      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    240      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
    241        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
    242      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
    243      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
    244        { "devicetree", LT_DEVTREE,  ' ' },
    245      { NULL, 0, 0 },      { NULL, 0, 0 },
    246  };  };
    247    
    # Line 226  const char *grub2FindConfig(struct confi Line 253  const char *grub2FindConfig(struct confi
    253      };      };
    254      static int i = -1;      static int i = -1;
    255      static const char *grub_cfg = "/boot/grub/grub.cfg";      static const char *grub_cfg = "/boot/grub/grub.cfg";
    256        int rc = -1;
    257    
    258      if (i == -1) {      if (i == -1) {
    259   for (i = 0; configFiles[i] != NULL; i++) {   for (i = 0; configFiles[i] != NULL; i++) {
    260      dbgPrintf("Checking \"%s\": ", configFiles[i]);      dbgPrintf("Checking \"%s\": ", configFiles[i]);
    261      if (!access(configFiles[i], R_OK)) {      if ((rc = access(configFiles[i], R_OK))) {
    262     if (errno == EACCES) {
    263        printf("Unable to access bootloader configuration file "
    264           "\"%s\": %m\n", configFiles[i]);
    265        exit(1);
    266     }
    267     continue;
    268        } else {
    269   dbgPrintf("found\n");   dbgPrintf("found\n");
    270   return configFiles[i];   return configFiles[i];
    271      }      }
    # Line 249  const char *grub2FindConfig(struct confi Line 284  const char *grub2FindConfig(struct confi
    284      return configFiles[i];      return configFiles[i];
    285  }  }
    286    
    287    /* kind of hacky.  It'll give the first 1024 bytes, ish. */
    288    static char *grub2GetEnv(struct configFileInfo *info, char *name)
    289    {
    290        static char buf[1025];
    291        char *s = NULL;
    292        char *ret = NULL;
    293        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    294        int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
    295    
    296        if (rc < 0)
    297     return NULL;
    298    
    299        FILE *f = popen(s, "r");
    300        if (!f)
    301     goto out;
    302    
    303        memset(buf, '\0', sizeof (buf));
    304        ret = fgets(buf, 1024, f);
    305        pclose(f);
    306    
    307        if (ret) {
    308     ret += strlen(name) + 1;
    309     ret[strlen(ret) - 1] = '\0';
    310        }
    311        dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
    312    out:
    313        free(s);
    314        return ret;
    315    }
    316    
    317    static int sPopCount(const char *s, const char *c)
    318    {
    319        int ret = 0;
    320        if (!s)
    321     return -1;
    322        for (int i = 0; s[i] != '\0'; i++)
    323     for (int j = 0; c[j] != '\0'; j++)
    324        if (s[i] == c[j])
    325     ret++;
    326        return ret;
    327    }
    328    
    329    static char *shellEscape(const char *s)
    330    {
    331        int l = strlen(s) + sPopCount(s, "'") * 2;
    332    
    333        char *ret = calloc(l+1, sizeof (*ret));
    334        if (!ret)
    335     return NULL;
    336        for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
    337     if (s[i] == '\'')
    338        ret[j++] = '\\';
    339     ret[j] = s[i];
    340        }
    341        return ret;
    342    }
    343    
    344    static void unquote(char *s)
    345    {
    346        int l = strlen(s);
    347    
    348        if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
    349     memmove(s, s+1, l-2);
    350     s[l-2] = '\0';
    351        }
    352    }
    353    
    354    static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
    355    {
    356        char *s = NULL;
    357        int rc = 0;
    358        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    359    
    360        unquote(value);
    361        value = shellEscape(value);
    362        if (!value)
    363        return -1;
    364    
    365        rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
    366        free(value);
    367        if (rc <0)
    368     return -1;
    369    
    370        dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
    371        rc = system(s);
    372        free(s);
    373        return rc;
    374    }
    375    
    376    /* this is a gigantic hack to avoid clobbering grub2 variables... */
    377    static int is_special_grub2_variable(const char *name)
    378    {
    379        if (!strcmp(name,"\"${next_entry}\""))
    380     return 1;
    381        if (!strcmp(name,"\"${prev_saved_entry}\""))
    382     return 1;
    383        return 0;
    384    }
    385    
    386  int sizeOfSingleLine(struct singleLine * line) {  int sizeOfSingleLine(struct singleLine * line) {
    387    int count = 0;    int count = 0;
    388    
    # Line 279  static int isquote(char q) Line 413  static int isquote(char q)
    413  }  }
    414    
    415  static int iskernel(enum lineType_e type) {  static int iskernel(enum lineType_e type) {
    416      return (type == LT_KERNEL || type == LT_KERNEL_EFI);      return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    417  }  }
    418    
    419  static int isinitrd(enum lineType_e type) {  static int isinitrd(enum lineType_e type) {
    420      return (type == LT_INITRD || type == LT_INITRD_EFI);      return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
    421  }  }
    422    
    423  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
    # Line 318  char *grub2ExtractTitle(struct singleLin Line 452  char *grub2ExtractTitle(struct singleLin
    452       * whose last character is also quote (assuming it's the closing one) */       * whose last character is also quote (assuming it's the closing one) */
    453      int resultMaxSize;      int resultMaxSize;
    454      char * result;      char * result;
    455        /* need to ensure that ' does not match " as we search */
    456        char quote_char = *current;
    457            
    458      resultMaxSize = sizeOfSingleLine(line);      resultMaxSize = sizeOfSingleLine(line);
    459      result = malloc(resultMaxSize);      result = malloc(resultMaxSize);
    # Line 331  char *grub2ExtractTitle(struct singleLin Line 467  char *grub2ExtractTitle(struct singleLin
    467   current_indent_len = strlen(current_indent);   current_indent_len = strlen(current_indent);
    468    
    469   strncat(result, current_indent, current_indent_len);   strncat(result, current_indent, current_indent_len);
    470   if (!isquote(current[current_len-1])) {   if (current[current_len-1] != quote_char) {
    471      strncat(result, current, current_len);      strncat(result, current, current_len);
    472   } else {   } else {
    473      strncat(result, current, current_len - 1);      strncat(result, current, current_len - 1);
    # Line 343  char *grub2ExtractTitle(struct singleLin Line 479  char *grub2ExtractTitle(struct singleLin
    479    
    480  struct configFileInfo grub2ConfigType = {  struct configFileInfo grub2ConfigType = {
    481      .findConfig = grub2FindConfig,      .findConfig = grub2FindConfig,
    482        .getEnv = grub2GetEnv,
    483        .setEnv = grub2SetEnv,
    484      .keywords = grub2Keywords,      .keywords = grub2Keywords,
    485      .defaultIsIndex = 1,      .defaultIsIndex = 1,
    486      .defaultSupportSaved = 1,      .defaultSupportSaved = 1,
    # Line 447  struct keywordTypes extlinuxKeywords[] = Line 585  struct keywordTypes extlinuxKeywords[] =
    585      { "initrd",    LT_INITRD,      ' ', ',' },      { "initrd",    LT_INITRD,      ' ', ',' },
    586      { "append",    LT_KERNELARGS,  ' ' },      { "append",    LT_KERNELARGS,  ' ' },
    587      { "prompt",     LT_UNKNOWN,     ' ' },      { "prompt",     LT_UNKNOWN,     ' ' },
    588        { "fdt",        LT_DEVTREE,     ' ' },
    589        { "fdtdir",     LT_DEVTREE,     ' ' },
    590      { NULL,    0, 0 },      { NULL,    0, 0 },
    591  };  };
    592  int useextlinuxmenu;  int useextlinuxmenu;
    # Line 457  struct configFileInfo eliloConfigType = Line 597  struct configFileInfo eliloConfigType =
    597      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    598      .argsInQuotes = 1,      .argsInQuotes = 1,
    599      .mbConcatArgs = 1,      .mbConcatArgs = 1,
    600        .titlePosition = 1,
    601  };  };
    602    
    603  struct configFileInfo liloConfigType = {  struct configFileInfo liloConfigType = {
    # Line 465  struct configFileInfo liloConfigType = { Line 606  struct configFileInfo liloConfigType = {
    606      .entryStart = LT_KERNEL,      .entryStart = LT_KERNEL,
    607      .argsInQuotes = 1,      .argsInQuotes = 1,
    608      .maxTitleLength = 15,      .maxTitleLength = 15,
    609        .titlePosition = 1,
    610  };  };
    611    
    612  struct configFileInfo yabootConfigType = {  struct configFileInfo yabootConfigType = {
    # Line 475  struct configFileInfo yabootConfigType = Line 617  struct configFileInfo yabootConfigType =
    617      .argsInQuotes = 1,      .argsInQuotes = 1,
    618      .maxTitleLength = 15,      .maxTitleLength = 15,
    619      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    620        .titlePosition = 1,
    621  };  };
    622    
    623  struct configFileInfo siloConfigType = {  struct configFileInfo siloConfigType = {
    # Line 484  struct configFileInfo siloConfigType = { Line 627  struct configFileInfo siloConfigType = {
    627      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    628      .argsInQuotes = 1,      .argsInQuotes = 1,
    629      .maxTitleLength = 15,      .maxTitleLength = 15,
    630        .titlePosition = 1,
    631  };  };
    632    
    633  struct configFileInfo ziplConfigType = {  struct configFileInfo ziplConfigType = {
    # Line 502  struct configFileInfo extlinuxConfigType Line 646  struct configFileInfo extlinuxConfigType
    646      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    647      .maxTitleLength = 255,      .maxTitleLength = 255,
    648      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    649        .defaultIsUnquoted = 1,
    650        .titlePosition = 1,
    651  };  };
    652    
    653  struct grubConfig {  struct grubConfig {
    # Line 522  struct singleEntry * findEntryByIndex(st Line 668  struct singleEntry * findEntryByIndex(st
    668  struct singleEntry * findEntryByPath(struct grubConfig * cfg,  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
    669       const char * path, const char * prefix,       const char * path, const char * prefix,
    670       int * index);       int * index);
    671    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    672          int * index);
    673  static int readFile(int fd, char ** bufPtr);  static int readFile(int fd, char ** bufPtr);
    674  static void lineInit(struct singleLine * line);  static void lineInit(struct singleLine * line);
    675  struct singleLine * lineDup(struct singleLine * line);  struct singleLine * lineDup(struct singleLine * line);
    # Line 591  static enum lineType_e preferredLineType Line 739  static enum lineType_e preferredLineType
    739      if (isEfi && cfi == &grub2ConfigType) {      if (isEfi && cfi == &grub2ConfigType) {
    740   switch (type) {   switch (type) {
    741   case LT_KERNEL:   case LT_KERNEL:
    742      return LT_KERNEL_EFI;      return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
    743   case LT_INITRD:   case LT_INITRD:
    744      return LT_INITRD_EFI;      return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
    745   default:   default:
    746      return type;      return type;
    747   }   }
    748    #if defined(__i386__) || defined(__x86_64__)
    749        } else if (cfi == &grub2ConfigType) {
    750     switch (type) {
    751     case LT_KERNEL:
    752        return LT_KERNEL_16;
    753     case LT_INITRD:
    754        return LT_INITRD_16;
    755     default:
    756        return type;
    757     }
    758    #endif
    759      }      }
    760      return type;      return type;
    761  }  }
    # Line 677  static int isEntryStart(struct singleLin Line 836  static int isEntryStart(struct singleLin
    836  }  }
    837    
    838  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
    839  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
    840      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it */
    841      char * title;      char * title = NULL;
    842      title = strdup(line->elements[0].item);      if (line->type == LT_TITLE) {
    843      title++;   char *tmp = line->elements[cfg->cfi->titlePosition].item;
    844      *(title + strlen(title) - 1) = '\0';   if (cfg->cfi->titleBracketed) {
    845        tmp++;
    846        title = strdup(tmp);
    847        *(title + strlen(title) - 1) = '\0';
    848     } else {
    849        title = strdup(tmp);
    850     }
    851        } else if (line->type == LT_MENUENTRY)
    852     title = strdup(line->elements[1].item);
    853        else
    854     return NULL;
    855      return title;      return title;
    856  }  }
    857    
    # Line 762  static int lineWrite(FILE * out, struct Line 931  static int lineWrite(FILE * out, struct
    931   /* Need to handle this, because we strip the quotes from   /* Need to handle this, because we strip the quotes from
    932   * menuentry when read it. */   * menuentry when read it. */
    933   if (line->type == LT_MENUENTRY && i == 1) {   if (line->type == LT_MENUENTRY && i == 1) {
    934      if(!isquote(*line->elements[i].item))      if(!isquote(*line->elements[i].item)) {
    935   fprintf(out, "\'%s\'", line->elements[i].item);   int substring = 0;
    936      else   /* If the line contains nested quotes, we did not strip
    937     * the "interna" quotes and we must use the right quotes
    938     * again when writing the updated file. */
    939     for (int j = i; j < line->numElements; j++) {
    940        if (strchr(line->elements[i].item, '\'') != NULL) {
    941           substring = 1;
    942           fprintf(out, "\"%s\"", line->elements[i].item);
    943           break;
    944        }
    945     }
    946     if (!substring)
    947        fprintf(out, "\'%s\'", line->elements[i].item);
    948        } else {
    949   fprintf(out, "%s", line->elements[i].item);   fprintf(out, "%s", line->elements[i].item);
    950        }
    951      fprintf(out, "%s", line->elements[i].indent);      fprintf(out, "%s", line->elements[i].indent);
    952    
    953      continue;      continue;
    # Line 940  static int getNextLine(char ** bufPtr, s Line 1122  static int getNextLine(char ** bufPtr, s
    1122      return 0;      return 0;
    1123  }  }
    1124    
    1125    static int isnumber(const char *s)
    1126    {
    1127        int i;
    1128        for (i = 0; s[i] != '\0'; i++)
    1129     if (s[i] < '0' || s[i] > '9')
    1130        return 0;
    1131        return i;
    1132    }
    1133    
    1134  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1135        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1136      int in;      int in;
    # Line 954  static struct grubConfig * readConfig(co Line 1145  static struct grubConfig * readConfig(co
    1145      int len;      int len;
    1146      char * buf;      char * buf;
    1147    
    1148      if (!strcmp(inName, "-")) {      if (inName == NULL) {
    1149            printf("Could not find bootloader configuration\n");
    1150            exit(1);
    1151        } else if (!strcmp(inName, "-")) {
    1152   in = 0;   in = 0;
    1153      } else {      } else {
    1154   if ((in = open(inName, O_RDONLY)) < 0) {   if ((in = open(inName, O_RDONLY)) < 0) {
    # Line 1021  static struct grubConfig * readConfig(co Line 1215  static struct grubConfig * readConfig(co
    1215      dbgPrintf("\n");      dbgPrintf("\n");
    1216      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
    1217      if (kwType && line->numElements == 3 &&      if (kwType && line->numElements == 3 &&
    1218      !strcmp(line->elements[1].item, kwType->key)) {      !strcmp(line->elements[1].item, kwType->key) &&
    1219        !is_special_grub2_variable(line->elements[2].item)) {
    1220   dbgPrintf("Line sets default config\n");   dbgPrintf("Line sets default config\n");
    1221   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1222   defaultLine = line;   defaultLine = line;
    1223      }      }
      } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
         cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
         defaultLine = line;  
    1224    
    1225          } else if (iskernel(line->type)) {          } else if (iskernel(line->type)) {
    1226      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
    1227       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
    1228       * instead of LT_KERNEL now       * instead of LT_KERNEL now
    1229       */       */
    1230      if (entry->multiboot)      if (entry && entry->multiboot)
    1231   line->type = LT_HYPER;   line->type = LT_HYPER;
    1232    
    1233          } else if (line->type == LT_MBMODULE) {          } else if (line->type == LT_MBMODULE) {
    # Line 1061  static struct grubConfig * readConfig(co Line 1253  static struct grubConfig * readConfig(co
    1253      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
    1254      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
    1255    
    1256   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
    1257      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
    1258        /* make the title/default a single argument (undoing our parsing) */
    1259      len = 0;      len = 0;
    1260      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1261   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1090  static struct grubConfig * readConfig(co Line 1283  static struct grubConfig * readConfig(co
    1283      len = 0;      len = 0;
    1284      char *extras;      char *extras;
    1285      char *title;      char *title;
    1286        /* initially unseen value */
    1287        char quote_char = '\0';
    1288    
    1289      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1290   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1106  static struct grubConfig * readConfig(co Line 1301  static struct grubConfig * readConfig(co
    1301      for (int i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    1302   if (!strcmp(line->elements[i].item, "menuentry"))   if (!strcmp(line->elements[i].item, "menuentry"))
    1303      continue;      continue;
    1304   if (isquote(*line->elements[i].item))   if (isquote(*line->elements[i].item) && quote_char == '\0') {
    1305        /* ensure we properly pair off quotes */
    1306        quote_char = *line->elements[i].item;
    1307      title = line->elements[i].item + 1;      title = line->elements[i].item + 1;
    1308   else   } else {
    1309      title = line->elements[i].item;      title = line->elements[i].item;
    1310     }
    1311    
    1312   len = strlen(title);   len = strlen(title);
    1313          if (isquote(title[len-1])) {          if (title[len-1] == quote_char) {
    1314      strncat(buf, title,len-1);      strncat(buf, title,len-1);
    1315      break;      break;
    1316   } else {   } else {
    # Line 1123  static struct grubConfig * readConfig(co Line 1321  static struct grubConfig * readConfig(co
    1321    
    1322      /* get extras */      /* get extras */
    1323      int count = 0;      int count = 0;
    1324        quote_char = '\0';
    1325      for (int i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    1326   if (count >= 2) {   if (count >= 2) {
    1327      strcat(extras, line->elements[i].item);      strcat(extras, line->elements[i].item);
    # Line 1133  static struct grubConfig * readConfig(co Line 1332  static struct grubConfig * readConfig(co
    1332      continue;      continue;
    1333    
    1334   /* count ' or ", there should be two in menuentry line. */   /* count ' or ", there should be two in menuentry line. */
    1335   if (isquote(*line->elements[i].item))   if (isquote(*line->elements[i].item) && quote_char == '\0') {
    1336        /* ensure we properly pair off quotes */
    1337                quote_char = *line->elements[i].item;
    1338      count++;      count++;
    1339     }
    1340    
    1341   len = strlen(line->elements[i].item);   len = strlen(line->elements[i].item);
    1342    
    1343   if (isquote(line->elements[i].item[len -1]))   if (line->elements[i].item[len -1] == quote_char)
    1344      count++;      count++;
    1345    
    1346   /* ok, we get the final ' or ", others are extras. */   /* ok, we get the final ' or ", others are extras. */
    # Line 1169  static struct grubConfig * readConfig(co Line 1371  static struct grubConfig * readConfig(co
    1371      }      }
    1372   }   }
    1373    
    1374     if (line->type == LT_DEFAULT && line->numElements == 2) {
    1375        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1376        defaultLine = line;
    1377     }
    1378    
    1379   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
    1380     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
    1381     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
    # Line 1226  static struct grubConfig * readConfig(co Line 1433  static struct grubConfig * readConfig(co
    1433          if (defaultLine->numElements > 2 &&          if (defaultLine->numElements > 2 &&
    1434      cfi->defaultSupportSaved &&      cfi->defaultSupportSaved &&
    1435      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
    1436      cfg->defaultImage = DEFAULT_SAVED_GRUB2;   cfg->cfi->defaultIsSaved = 1;
    1437     cfg->defaultImage = DEFAULT_SAVED_GRUB2;
    1438     if (cfg->cfi->getEnv) {
    1439        char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1440        if (defTitle) {
    1441     int index = 0;
    1442     if (isnumber(defTitle)) {
    1443        index = atoi(defTitle);
    1444        entry = findEntryByIndex(cfg, index);
    1445     } else {
    1446        entry = findEntryByTitle(cfg, defTitle, &index);
    1447     }
    1448     if (entry)
    1449        cfg->defaultImage = index;
    1450        }
    1451     }
    1452   } else if (cfi->defaultIsVariable) {   } else if (cfi->defaultIsVariable) {
    1453      char *value = defaultLine->elements[2].item;      char *value = defaultLine->elements[2].item;
    1454      while (*value && (*value == '"' || *value == '\'' ||      while (*value && (*value == '"' || *value == '\'' ||
    # Line 1255  static struct grubConfig * readConfig(co Line 1477  static struct grubConfig * readConfig(co
    1477                                  line->elements[1].item)) break;                                  line->elements[1].item)) break;
    1478                  } else if (line) {                  } else if (line) {
    1479                      if (!strcmp(defaultLine->elements[1].item,                      if (!strcmp(defaultLine->elements[1].item,
    1480                                  extractTitle(line))) break;                                  extractTitle(cfg, line))) break;
    1481                  }                  }
    1482   i++;   i++;
    1483   entry = NULL;   entry = NULL;
    # Line 1267  static struct grubConfig * readConfig(co Line 1489  static struct grubConfig * readConfig(co
    1489          cfg->defaultImage = -1;          cfg->defaultImage = -1;
    1490      }      }
    1491   }   }
    1492        } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
    1493     char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1494     if (defTitle) {
    1495        int index = 0;
    1496        if (isnumber(defTitle)) {
    1497     index = atoi(defTitle);
    1498     entry = findEntryByIndex(cfg, index);
    1499        } else {
    1500     entry = findEntryByTitle(cfg, defTitle, &index);
    1501        }
    1502        if (entry)
    1503     cfg->defaultImage = index;
    1504     }
    1505      } else {      } else {
    1506          cfg->defaultImage = 0;          cfg->defaultImage = 0;
    1507      }      }
    # Line 1284  static void writeDefault(FILE * out, cha Line 1519  static void writeDefault(FILE * out, cha
    1519    
    1520      if (cfg->defaultImage == DEFAULT_SAVED)      if (cfg->defaultImage == DEFAULT_SAVED)
    1521   fprintf(out, "%sdefault%ssaved\n", indent, separator);   fprintf(out, "%sdefault%ssaved\n", indent, separator);
    1522      else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)      else if (cfg->cfi->defaultIsSaved) {
    1523   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
    1524      else if (cfg->defaultImage > -1) {   if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
    1525        char *title;
    1526        entry = findEntryByIndex(cfg, cfg->defaultImage);
    1527        line = getLineByType(LT_MENUENTRY, entry->lines);
    1528        if (!line)
    1529     line = getLineByType(LT_TITLE, entry->lines);
    1530        if (line) {
    1531     title = extractTitle(cfg, line);
    1532     if (title)
    1533        cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
    1534        }
    1535     }
    1536        } else if (cfg->defaultImage > -1) {
    1537   if (cfg->cfi->defaultIsIndex) {   if (cfg->cfi->defaultIsIndex) {
    1538      if (cfg->cfi->defaultIsVariable) {      if (cfg->cfi->defaultIsVariable) {
    1539          fprintf(out, "%sset default=\"%d\"\n", indent,          fprintf(out, "%sset default=\"%d\"\n", indent,
    # Line 1319  static void writeDefault(FILE * out, cha Line 1566  static void writeDefault(FILE * out, cha
    1566              else if (line && (line->numElements == 1) &&              else if (line && (line->numElements == 1) &&
    1567                       cfg->cfi->titleBracketed) {                       cfg->cfi->titleBracketed) {
    1568   fprintf(out, "%sdefault%s%s\n", indent, separator,   fprintf(out, "%sdefault%s%s\n", indent, separator,
    1569                          extractTitle(line));                          extractTitle(cfg, line));
    1570              }              }
    1571   }   }
    1572      }      }
    # Line 1389  static int writeConfig(struct grubConfig Line 1636  static int writeConfig(struct grubConfig
    1636      while (line) {      while (line) {
    1637          if (line->type == LT_SET_VARIABLE && defaultKw &&          if (line->type == LT_SET_VARIABLE && defaultKw &&
    1638   line->numElements == 3 &&   line->numElements == 3 &&
    1639   !strcmp(line->elements[1].item, defaultKw->key)) {   !strcmp(line->elements[1].item, defaultKw->key) &&
    1640     !is_special_grub2_variable(line->elements[2].item)) {
    1641      writeDefault(out, line->indent, line->elements[0].indent, cfg);      writeDefault(out, line->indent, line->elements[0].indent, cfg);
    1642      needs &= ~MAIN_DEFAULT;      needs &= ~MAIN_DEFAULT;
    1643   } else if (line->type == LT_DEFAULT) {   } else if (line->type == LT_DEFAULT) {
    # Line 1534  static char *findDiskForRoot() Line 1782  static char *findDiskForRoot()
    1782      return NULL;      return NULL;
    1783  }  }
    1784    
    1785  void printEntry(struct singleEntry * entry) {  void printEntry(struct singleEntry * entry, FILE *f) {
    1786      int i;      int i;
    1787      struct singleLine * line;      struct singleLine * line;
    1788    
    1789      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    1790   fprintf(stderr, "DBG: %s", line->indent);   log_message(f, "DBG: %s", line->indent);
    1791   for (i = 0; i < line->numElements; i++) {   for (i = 0; i < line->numElements; i++) {
    1792      /* Need to handle this, because we strip the quotes from      /* Need to handle this, because we strip the quotes from
    1793       * menuentry when read it. */       * menuentry when read it. */
    1794      if (line->type == LT_MENUENTRY && i == 1) {      if (line->type == LT_MENUENTRY && i == 1) {
    1795   if(!isquote(*line->elements[i].item))   if(!isquote(*line->elements[i].item))
    1796      fprintf(stderr, "\'%s\'", line->elements[i].item);      log_message(f, "\'%s\'", line->elements[i].item);
    1797   else   else
    1798      fprintf(stderr, "%s", line->elements[i].item);      log_message(f, "%s", line->elements[i].item);
    1799   fprintf(stderr, "%s", line->elements[i].indent);   log_message(f, "%s", line->elements[i].indent);
    1800    
    1801   continue;   continue;
    1802      }      }
    1803            
    1804      fprintf(stderr, "%s%s",      log_message(f, "%s%s",
    1805      line->elements[i].item, line->elements[i].indent);      line->elements[i].item, line->elements[i].indent);
    1806   }   }
    1807   fprintf(stderr, "\n");   log_message(f, "\n");
    1808      }      }
    1809  }  }
    1810    
    1811  void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)  void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
    1812  {  {
    1813      va_list argp;      static int once;
    1814        va_list argp, argq;
    1815    
    1816        va_start(argp, fmt);
    1817    
    1818        va_copy(argq, argp);
    1819        if (!once) {
    1820     log_time(NULL);
    1821     log_message(NULL, "command line: %s\n", saved_command_line);
    1822        }
    1823        log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
    1824        log_vmessage(NULL, fmt, argq);
    1825    
    1826        printEntry(entry, NULL);
    1827        va_end(argq);
    1828    
    1829      if (!debug)      if (!debug) {
    1830     once = 1;
    1831         va_end(argp);
    1832   return;   return;
    1833        }
    1834    
    1835      va_start(argp, fmt);      if (okay) {
    1836     va_end(argp);
    1837     return;
    1838        }
    1839    
    1840        if (!once)
    1841     log_message(stderr, "DBG: command line: %s\n", saved_command_line);
    1842        once = 1;
    1843      fprintf(stderr, "DBG: Image entry failed: ");      fprintf(stderr, "DBG: Image entry failed: ");
    1844      vfprintf(stderr, fmt, argp);      vfprintf(stderr, fmt, argp);
    1845      printEntry(entry);      printEntry(entry, stderr);
    1846      va_end(argp);      va_end(argp);
    1847  }  }
    1848    
    # Line 1597  int suitableImage(struct singleEntry * e Line 1869  int suitableImage(struct singleEntry * e
    1869      char * rootdev;      char * rootdev;
    1870    
    1871      if (skipRemoved && entry->skip) {      if (skipRemoved && entry->skip) {
    1872   notSuitablePrintf(entry, "marked to skip\n");   notSuitablePrintf(entry, 0, "marked to skip\n");
    1873   return 0;   return 0;
    1874      }      }
    1875    
    1876      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1877      if (!line) {      if (!line) {
    1878   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1879   return 0;   return 0;
    1880      }      }
    1881      if (line->numElements < 2) {      if (line->numElements < 2) {
    1882   notSuitablePrintf(entry, "line has only %d elements\n",   notSuitablePrintf(entry, 0, "line has only %d elements\n",
    1883      line->numElements);      line->numElements);
    1884   return 0;   return 0;
    1885      }      }
    1886    
    1887      if (flags & GRUBBY_BADIMAGE_OKAY) return 1;      if (flags & GRUBBY_BADIMAGE_OKAY) {
    1888        notSuitablePrintf(entry, 1, "\n");
    1889        return 1;
    1890        }
    1891    
    1892      fullName = alloca(strlen(bootPrefix) +      fullName = alloca(strlen(bootPrefix) +
    1893        strlen(line->elements[1].item) + 1);        strlen(line->elements[1].item) + 1);
    # Line 1623  int suitableImage(struct singleEntry * e Line 1898  int suitableImage(struct singleEntry * e
    1898      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
    1899              line->elements[1].item + rootspec_offset);              line->elements[1].item + rootspec_offset);
    1900      if (access(fullName, R_OK)) {      if (access(fullName, R_OK)) {
    1901   notSuitablePrintf(entry, "access to %s failed\n", fullName);   notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
    1902   return 0;   return 0;
    1903      }      }
    1904      for (i = 2; i < line->numElements; i++)      for (i = 2; i < line->numElements; i++)
    # Line 1644  int suitableImage(struct singleEntry * e Line 1919  int suitableImage(struct singleEntry * e
    1919    
    1920              /* failed to find one */              /* failed to find one */
    1921              if (!line) {              if (!line) {
    1922   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1923   return 0;   return 0;
    1924              }              }
    1925    
    # Line 1653  int suitableImage(struct singleEntry * e Line 1928  int suitableImage(struct singleEntry * e
    1928      if (i < line->numElements)      if (i < line->numElements)
    1929          dev = line->elements[i].item + 5;          dev = line->elements[i].item + 5;
    1930      else {      else {
    1931   notSuitablePrintf(entry, "no root= entry found\n");   notSuitablePrintf(entry, 0, "no root= entry found\n");
    1932   /* it failed too...  can't find root= */   /* it failed too...  can't find root= */
    1933          return 0;          return 0;
    1934              }              }
    # Line 1662  int suitableImage(struct singleEntry * e Line 1937  int suitableImage(struct singleEntry * e
    1937    
    1938      dev = getpathbyspec(dev);      dev = getpathbyspec(dev);
    1939      if (!getpathbyspec(dev)) {      if (!getpathbyspec(dev)) {
    1940          notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);          notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
    1941          return 0;          return 0;
    1942      } else      } else
    1943   dev = getpathbyspec(dev);   dev = getpathbyspec(dev);
    1944    
    1945      rootdev = findDiskForRoot();      rootdev = findDiskForRoot();
    1946      if (!rootdev) {      if (!rootdev) {
    1947          notSuitablePrintf(entry, "can't find root device\n");          notSuitablePrintf(entry, 0, "can't find root device\n");
    1948   return 0;   return 0;
    1949      }      }
    1950    
    1951      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
    1952          notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
    1953   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1954          free(rootdev);          free(rootdev);
    1955          return 0;          return 0;
    1956      }      }
    1957    
    1958      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
    1959          notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
    1960   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1961   free(rootdev);   free(rootdev);
    1962          return 0;          return 0;
    1963      }      }
    1964    
    1965      free(rootdev);      free(rootdev);
    1966        notSuitablePrintf(entry, 1, "\n");
    1967    
    1968      return 1;      return 1;
    1969  }  }
    # Line 1721  struct singleEntry * findEntryByPath(str Line 1997  struct singleEntry * findEntryByPath(str
    1997   }   }
    1998    
    1999   indexVars[i + 1] = -1;   indexVars[i + 1] = -1;
    2000    
    2001   i = 0;   i = 0;
    2002   if (index) {   if (index) {
    2003      while (i < *index) i++;      while (i < *index) {
    2004      if (indexVars[i] == -1) return NULL;   i++;
    2005     if (indexVars[i] == -1) return NULL;
    2006        }
    2007   }   }
    2008    
    2009   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    2010   if (!entry) return NULL;   if (!entry) return NULL;
    2011    
    2012   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    2013   if (!line) return NULL;   if (!line) return NULL;
    2014    
    2015   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1782  struct singleEntry * findEntryByPath(str Line 2060  struct singleEntry * findEntryByPath(str
    2060      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2061   enum lineType_e ct = checkType;   enum lineType_e ct = checkType;
    2062   if (entry->multiboot && checkType == LT_KERNEL)   if (entry->multiboot && checkType == LT_KERNEL)
    2063      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2064   else if (checkType & LT_KERNEL)   else if (checkType & LT_KERNEL)
    2065      ct = checkType | LT_KERNEL_EFI;      ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2066   line = getLineByType(ct, line);   line = getLineByType(ct, line);
    2067   if (!line)   if (!line)
    2068      break;  /* not found in this entry */      break;  /* not found in this entry */
    # Line 1806  struct singleEntry * findEntryByPath(str Line 2084  struct singleEntry * findEntryByPath(str
    2084       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2085       * unfortunate)       * unfortunate)
    2086       */       */
    2087      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
    2088   break; /* found 'im! */   break; /* found 'im! */
    2089   }   }
    2090    
    # Line 1816  struct singleEntry * findEntryByPath(str Line 2094  struct singleEntry * findEntryByPath(str
    2094      return entry;      return entry;
    2095  }  }
    2096    
    2097    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    2098          int * index) {
    2099        struct singleEntry * entry;
    2100        struct singleLine * line;
    2101        int i;
    2102        char * newtitle;
    2103    
    2104        for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
    2105     if (index && i < *index)
    2106        continue;
    2107     line = getLineByType(LT_TITLE, entry->lines);
    2108     if (!line)
    2109        line = getLineByType(LT_MENUENTRY, entry->lines);
    2110     if (!line)
    2111        continue;
    2112     newtitle = grub2ExtractTitle(line);
    2113     if (!newtitle)
    2114        continue;
    2115     if (!strcmp(title, newtitle))
    2116        break;
    2117        }
    2118    
    2119        if (!entry)
    2120     return NULL;
    2121    
    2122        if (index)
    2123     *index = i;
    2124        return entry;
    2125    }
    2126    
    2127  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
    2128      struct singleEntry * entry;      struct singleEntry * entry;
    2129    
    # Line 1838  struct singleEntry * findTemplate(struct Line 2146  struct singleEntry * findTemplate(struct
    2146      struct singleEntry * entry, * entry2;      struct singleEntry * entry, * entry2;
    2147      int index;      int index;
    2148    
    2149      if (cfg->defaultImage > -1) {      if (cfg->cfi->defaultIsSaved) {
    2150     if (cfg->cfi->getEnv) {
    2151        char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2152        if (defTitle) {
    2153     int index = 0;
    2154     if (isnumber(defTitle)) {
    2155        index = atoi(defTitle);
    2156        entry = findEntryByIndex(cfg, index);
    2157     } else {
    2158        entry = findEntryByTitle(cfg, defTitle, &index);
    2159     }
    2160     if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2161        cfg->defaultImage = index;
    2162        if (indexPtr)
    2163     *indexPtr = index;
    2164        return entry;
    2165     }
    2166        }
    2167     }
    2168        } else if (cfg->defaultImage > -1) {
    2169   entry = findEntryByIndex(cfg, cfg->defaultImage);   entry = findEntryByIndex(cfg, cfg->defaultImage);
    2170   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2171      if (indexPtr) *indexPtr = cfg->defaultImage;      if (indexPtr) *indexPtr = cfg->defaultImage;
    # Line 1992  void displayEntry(struct singleEntry * e Line 2319  void displayEntry(struct singleEntry * e
    2319      struct singleLine * line;      struct singleLine * line;
    2320      char * root = NULL;      char * root = NULL;
    2321      int i;      int i;
    2322        int j;
    2323    
    2324      printf("index=%d\n", index);      printf("index=%d\n", index);
    2325    
    2326      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    2327      if (!line) {      if (!line) {
    2328          printf("non linux entry\n");          printf("non linux entry\n");
    2329          return;          return;
    # Line 2060  void displayEntry(struct singleEntry * e Line 2388  void displayEntry(struct singleEntry * e
    2388   printf("root=%s\n", s);   printf("root=%s\n", s);
    2389      }      }
    2390    
    2391      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2392    
    2393      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2394   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2079  void displayEntry(struct singleEntry * e Line 2407  void displayEntry(struct singleEntry * e
    2407      } else {      } else {
    2408   char * title;   char * title;
    2409   line = getLineByType(LT_MENUENTRY, entry->lines);   line = getLineByType(LT_MENUENTRY, entry->lines);
    2410   title = grub2ExtractTitle(line);   if (line) {
    2411   if (title)      title = grub2ExtractTitle(line);
    2412      printf("title=%s\n", title);      if (title)
    2413     printf("title=%s\n", title);
    2414     }
    2415        }
    2416    
    2417        for (j = 0, line = entry->lines; line; line = line->next) {
    2418     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2419        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2420     printf("mbmodule%d=", j);
    2421        else
    2422     printf("mbmodule%d=%s", j, prefix);
    2423    
    2424        for (i = 1; i < line->numElements; i++)
    2425     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2426        printf("\n");
    2427        j++;
    2428     }
    2429      }      }
    2430  }  }
    2431    
    # Line 2477  struct singleLine * addLineTmpl(struct s Line 2821  struct singleLine * addLineTmpl(struct s
    2821   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2822    
    2823   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2824   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI)) {   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
    2825      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2826      if (rootspec != NULL) {      if (rootspec != NULL) {
    2827   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 2847  int updateActualImage(struct grubConfig Line 3191  int updateActualImage(struct grubConfig
    3191      firstElement = 2;      firstElement = 2;
    3192    
    3193   } else {   } else {
    3194      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3195      if (!line) {      if (!line) {
    3196   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3197   continue;   continue;
    # Line 3003  int updateImage(struct grubConfig * cfg, Line 3347  int updateImage(struct grubConfig * cfg,
    3347      return rc;      return rc;
    3348  }  }
    3349    
    3350    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3351     const char * image, const char * prefix, const char * initrd,
    3352     const char * title) {
    3353        struct singleEntry * entry;
    3354        struct singleLine * line, * kernelLine, *endLine = NULL;
    3355        int index = 0;
    3356    
    3357        if (!image) return 0;
    3358    
    3359        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3360            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3361            if (!kernelLine) continue;
    3362    
    3363     /* if title is supplied, the entry's title must match it. */
    3364     if (title) {
    3365        char *linetitle;
    3366    
    3367        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3368        if (!line)
    3369     continue;
    3370    
    3371        linetitle = extractTitle(cfg, line);
    3372        if (!linetitle)
    3373     continue;
    3374        if (strcmp(title, linetitle)) {
    3375     free(linetitle);
    3376     continue;
    3377        }
    3378        free(linetitle);
    3379     }
    3380    
    3381            if (prefix) {
    3382                int prefixLen = strlen(prefix);
    3383                if (!strncmp(initrd, prefix, prefixLen))
    3384                    initrd += prefixLen;
    3385            }
    3386     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3387     if (endLine)
    3388        removeLine(entry, endLine);
    3389            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3390     kernelLine->indent, initrd);
    3391            if (!line)
    3392        return 1;
    3393     if (endLine) {
    3394        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3395                if (!line)
    3396     return 1;
    3397     }
    3398    
    3399            break;
    3400        }
    3401    
    3402        return 0;
    3403    }
    3404    
    3405  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3406                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd, const char * title) {
    3407      struct singleEntry * entry;      struct singleEntry * entry;
    3408      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
    3409      int index = 0;      int index = 0;
    # Line 3012  int updateInitrd(struct grubConfig * cfg Line 3411  int updateInitrd(struct grubConfig * cfg
    3411      if (!image) return 0;      if (!image) return 0;
    3412    
    3413      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3414          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3415          if (!kernelLine) continue;          if (!kernelLine) continue;
    3416    
    3417          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);   /* if title is supplied, the entry's title must match it. */
    3418     if (title) {
    3419        char *linetitle;
    3420    
    3421        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3422        if (!line)
    3423     continue;
    3424    
    3425        linetitle = extractTitle(cfg, line);
    3426        if (!linetitle)
    3427     continue;
    3428        if (strcmp(title, linetitle)) {
    3429     free(linetitle);
    3430     continue;
    3431        }
    3432        free(linetitle);
    3433     }
    3434    
    3435            line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3436          if (line)          if (line)
    3437              removeLine(entry, line);              removeLine(entry, line);
    3438          if (prefix) {          if (prefix) {
    # Line 3026  int updateInitrd(struct grubConfig * cfg Line 3443  int updateInitrd(struct grubConfig * cfg
    3443   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3444   if (endLine)   if (endLine)
    3445      removeLine(entry, endLine);      removeLine(entry, endLine);
    3446          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3447   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3448        case LT_KERNEL:
    3449            lt = LT_INITRD;
    3450     break;
    3451        case LT_KERNEL_EFI:
    3452            lt = LT_INITRD_EFI;
    3453     break;
    3454        case LT_KERNEL_16:
    3455            lt = LT_INITRD_16;
    3456     break;
    3457        default:
    3458            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3459     }
    3460            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3461          if (!line)          if (!line)
    3462      return 1;      return 1;
    3463   if (endLine) {   if (endLine) {
    # Line 3386  int addNewKernel(struct grubConfig * con Line 3816  int addNewKernel(struct grubConfig * con
    3816   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3817   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3818   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3819                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3820     const char * newDevTreePath) {
    3821      struct singleEntry * new;      struct singleEntry * new;
    3822      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3823      int needs;      int needs;
    # Line 3427  int addNewKernel(struct grubConfig * con Line 3858  int addNewKernel(struct grubConfig * con
    3858          needs |= NEED_MB;          needs |= NEED_MB;
    3859          new->multiboot = 1;          new->multiboot = 1;
    3860      }      }
    3861        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3862     needs |= NEED_DEVTREE;
    3863    
    3864      if (template) {      if (template) {
    3865   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3612  int addNewKernel(struct grubConfig * con Line 4045  int addNewKernel(struct grubConfig * con
    4045   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    4046   config->cfi);   config->cfi);
    4047      }      }
    4048        } else if (tmplLine->type == LT_DEVTREE &&
    4049           tmplLine->numElements == 2 && newDevTreePath) {
    4050            newLine = addLineTmpl(new, tmplLine, newLine,
    4051          newDevTreePath + strlen(prefix),
    4052          config->cfi);
    4053     needs &= ~NEED_DEVTREE;
    4054        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    4055     const char *ndtp = newDevTreePath;
    4056     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    4057        ndtp += strlen(prefix);
    4058     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4059      config->secondaryIndent,
    4060      ndtp);
    4061     needs &= ~NEED_DEVTREE;
    4062     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    4063      } else {      } else {
    4064   /* pass through other lines from the template */   /* pass through other lines from the template */
    4065   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3625  int addNewKernel(struct grubConfig * con Line 4073  int addNewKernel(struct grubConfig * con
    4073   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    4074      case LT_KERNEL:      case LT_KERNEL:
    4075      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    4076        case LT_KERNEL_16:
    4077   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    4078      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    4079   } else {   } else {
    # Line 3686  int addNewKernel(struct grubConfig * con Line 4135  int addNewKernel(struct grubConfig * con
    4135   }   }
    4136      }      }
    4137    
    4138        struct singleLine *endLine = NULL;
    4139        endLine = getLineByType(LT_ENTRY_END, new->lines);
    4140        if (endLine) {
    4141        removeLine(new, endLine);
    4142        needs |= NEED_END;
    4143        }
    4144    
    4145      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
    4146       * 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,
    4147       * all the lines following the entryStart.       * all the lines following the entryStart.
    # Line 3731  int addNewKernel(struct grubConfig * con Line 4187  int addNewKernel(struct grubConfig * con
    4187   free(initrdVal);   free(initrdVal);
    4188   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4189      }      }
    4190        if (needs & NEED_DEVTREE) {
    4191     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4192      config->secondaryIndent,
    4193      newDevTreePath);
    4194     needs &= ~NEED_DEVTREE;
    4195        }
    4196    
    4197        /* NEEDS_END must be last on bootloaders that need it... */
    4198      if (needs & NEED_END) {      if (needs & NEED_END) {
    4199   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4200   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    # Line 3748  int addNewKernel(struct grubConfig * con Line 4212  int addNewKernel(struct grubConfig * con
    4212      return 0;      return 0;
    4213  }  }
    4214    
     static void traceback(int signum)  
     {  
         void *array[40];  
         size_t size;  
       
         signal(SIGSEGV, SIG_DFL);  
         memset(array, '\0', sizeof (array));  
         size = backtrace(array, 40);  
       
         fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",  
                 (unsigned long)size);  
         backtrace_symbols_fd(array, size, STDERR_FILENO);  
         exit(1);  
     }  
       
    4215  int main(int argc, const char ** argv) {  int main(int argc, const char ** argv) {
    4216      poptContext optCon;      poptContext optCon;
    4217      const char * grubConfig = NULL;      const char * grubConfig = NULL;
    # Line 3782  int main(int argc, const char ** argv) { Line 4231  int main(int argc, const char ** argv) {
    4231      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4232      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4233      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4234      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4235      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4236      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4237      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 3792  int main(int argc, const char ** argv) { Line 4241  int main(int argc, const char ** argv) {
    4241      char * removeArgs = NULL;      char * removeArgs = NULL;
    4242      char * kernelInfo = NULL;      char * kernelInfo = NULL;
    4243      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
    4244        char * envPath = NULL;
    4245      const char * chptr = NULL;      const char * chptr = NULL;
    4246      struct configFileInfo * cfi = NULL;      struct configFileInfo * cfi = NULL;
    4247      struct grubConfig * config;      struct grubConfig * config;
    # Line 3839  int main(int argc, const char ** argv) { Line 4289  int main(int argc, const char ** argv) {
    4289      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4290   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4291      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4292     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4293        _("device tree file for new stanza"), _("dtb-path") },
    4294     { "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4295        _("device tree directory for new stanza"), _("dtb-path") },
    4296   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4297      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4298   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    4299      _("force grub2 stanzas to use efi") },      _("force grub2 stanzas to use efi") },
    4300     { "env", 0, POPT_ARG_STRING, &envPath, 0,
    4301        _("path for environment data"),
    4302        _("path") },
    4303   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
    4304      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
    4305   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
    # Line 3897  int main(int argc, const char ** argv) { Line 4354  int main(int argc, const char ** argv) {
    4354    
    4355      useextlinuxmenu=0;      useextlinuxmenu=0;
    4356    
    4357      signal(SIGSEGV, traceback);      int i = 0;
    4358        for (int j = 1; j < argc; j++)
    4359     i += strlen(argv[j]) + 1;
    4360        saved_command_line = malloc(i);
    4361        if (!saved_command_line) {
    4362     fprintf(stderr, "grubby: %m\n");
    4363     exit(1);
    4364        }
    4365        saved_command_line[0] = '\0';
    4366        for (int j = 1; j < argc; j++) {
    4367     strcat(saved_command_line, argv[j]);
    4368     strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
    4369        }
    4370    
    4371      optCon = poptGetContext("grubby", argc, argv, options, 0);      optCon = poptGetContext("grubby", argc, argv, options, 0);
    4372      poptReadDefaultConfig(optCon, 1);      poptReadDefaultConfig(optCon, 1);
    # Line 3942  int main(int argc, const char ** argv) { Line 4411  int main(int argc, const char ** argv) {
    4411   return 1;   return 1;
    4412      } else if (configureGrub2) {      } else if (configureGrub2) {
    4413   cfi = &grub2ConfigType;   cfi = &grub2ConfigType;
    4414     if (envPath)
    4415        cfi->envFile = envPath;
    4416      } else if (configureLilo) {      } else if (configureLilo) {
    4417   cfi = &liloConfigType;   cfi = &liloConfigType;
    4418      } else if (configureGrub) {      } else if (configureGrub) {
    # Line 3960  int main(int argc, const char ** argv) { Line 4431  int main(int argc, const char ** argv) {
    4431      }      }
    4432    
    4433      if (!cfi) {      if (!cfi) {
    4434          if (grub2FindConfig(&grub2ConfigType))          if (grub2FindConfig(&grub2ConfigType)) {
    4435      cfi = &grub2ConfigType;      cfi = &grub2ConfigType;
    4436   else      if (envPath)
    4437     cfi->envFile = envPath;
    4438            } else
    4439        #ifdef __ia64__        #ifdef __ia64__
    4440      cfi = &eliloConfigType;      cfi = &eliloConfigType;
    4441        #elif __powerpc__        #elif __powerpc__
    # Line 3985  int main(int argc, const char ** argv) { Line 4458  int main(int argc, const char ** argv) {
    4458      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4459      }      }
    4460    
    4461      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4462      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4463      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4464      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 3994  int main(int argc, const char ** argv) { Line 4467  int main(int argc, const char ** argv) {
    4467   return 1;   return 1;
    4468      }      }
    4469    
    4470      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4471     removeKernelPath)) {     removeKernelPath)) {
    4472   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4473    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 4004  int main(int argc, const char ** argv) { Line 4477  int main(int argc, const char ** argv) {
    4477      if (newKernelPath && !newKernelTitle) {      if (newKernelPath && !newKernelTitle) {
    4478   fprintf(stderr, _("grubby: kernel title must be specified\n"));   fprintf(stderr, _("grubby: kernel title must be specified\n"));
    4479   return 1;   return 1;
    4480      } else if (!newKernelPath && (newKernelTitle  || copyDefault ||      } else if (!newKernelPath && (copyDefault ||
    4481    (newKernelInitrd && !updateKernelPath)||    (newKernelInitrd && !updateKernelPath)||
    4482    makeDefault || extraInitrdCount > 0)) {    makeDefault || extraInitrdCount > 0)) {
    4483   fprintf(stderr, _("grubby: kernel path expected\n"));   fprintf(stderr, _("grubby: kernel path expected\n"));
    # Line 4142  int main(int argc, const char ** argv) { Line 4615  int main(int argc, const char ** argv) {
    4615   return 0;   return 0;
    4616      }      }
    4617    
    4618        if (grubConfig == NULL) {
    4619     printf("Could not find bootloader configuration file.\n");
    4620     exit(1);
    4621        }
    4622    
    4623      config = readConfig(grubConfig, cfi);      config = readConfig(grubConfig, cfi);
    4624      if (!config) return 1;      if (!config) return 1;
    4625    
    # Line 4151  int main(int argc, const char ** argv) { Line 4629  int main(int argc, const char ** argv) {
    4629          char * rootspec;          char * rootspec;
    4630    
    4631   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4632     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4633     cfi->defaultIsSaved)
    4634        config->defaultImage = 0;
    4635   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4636   if (!entry) return 0;   if (!entry) return 0;
    4637   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4638    
    4639   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    4640   if (!line) return 0;   if (!line) return 0;
    4641    
    4642          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4169  int main(int argc, const char ** argv) { Line 4650  int main(int argc, const char ** argv) {
    4650   struct singleEntry * entry;   struct singleEntry * entry;
    4651    
    4652   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4653     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4654     cfi->defaultIsSaved)
    4655        config->defaultImage = 0;
    4656   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4657   if (!entry) return 0;   if (!entry) return 0;
    4658    
    # Line 4191  int main(int argc, const char ** argv) { Line 4675  int main(int argc, const char ** argv) {
    4675    
    4676      } else if (displayDefaultIndex) {      } else if (displayDefaultIndex) {
    4677          if (config->defaultImage == -1) return 0;          if (config->defaultImage == -1) return 0;
    4678     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4679     cfi->defaultIsSaved)
    4680        config->defaultImage = 0;
    4681          printf("%i\n", config->defaultImage);          printf("%i\n", config->defaultImage);
    4682            return 0;
    4683    
    4684      } else if (kernelInfo)      } else if (kernelInfo)
    4685   return displayInfo(config, kernelInfo, bootPrefix);   return displayInfo(config, kernelInfo, bootPrefix);
    # Line 4209  int main(int argc, const char ** argv) { Line 4697  int main(int argc, const char ** argv) {
    4697      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4698                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4699      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4700              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4701                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4702     bootPrefix, newKernelInitrd,
    4703     newKernelTitle))
    4704        return 1;
    4705        } else {
    4706        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4707     newKernelInitrd, newKernelTitle))
    4708     return 1;
    4709        }
    4710      }      }
    4711      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4712                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4713                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4714                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4715            
    4716    
    4717      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2058  
    changed lines
      Added in v.2991