Magellan Linux

  • Back to homepage
    • /[magellan-source]/tags/grubby-8_40_20170627/grubby.c

    Diff of /tags/grubby-8_40_20170627/grubby.c

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

    revision 2052 by niro, Wed Feb 20 14:00:54 2013 UTC revision 2977 by niro, Thu Jun 30 10:24:27 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;
    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 152  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 171  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 210  struct keywordTypes grub2Keywords[] = { Line 234  struct keywordTypes grub2Keywords[] = {
    234      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    235      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    236      { "linuxefi",   LT_KERNEL_EFI,  ' ' },      { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    237        { "linux16",    LT_KERNEL_16,   ' ' },
    238      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    239      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },      { "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 225  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 248  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) {
    386    int count = 0;    int count = 0;
    387    
    # Line 278  static int isquote(char q) Line 412  static int isquote(char q)
    412  }  }
    413    
    414  static int iskernel(enum lineType_e type) {  static int iskernel(enum lineType_e type) {
    415      return (type == LT_KERNEL || type == LT_KERNEL_EFI);      return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    416  }  }
    417    
    418  static int isinitrd(enum lineType_e type) {  static int isinitrd(enum lineType_e type) {
    419      return (type == LT_INITRD || type == LT_INITRD_EFI);      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) {
    # Line 342  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 446  struct keywordTypes extlinuxKeywords[] = Line 582  struct keywordTypes extlinuxKeywords[] =
    582      { "initrd",    LT_INITRD,      ' ', ',' },      { "initrd",    LT_INITRD,      ' ', ',' },
    583      { "append",    LT_KERNELARGS,  ' ' },      { "append",    LT_KERNELARGS,  ' ' },
    584      { "prompt",     LT_UNKNOWN,     ' ' },      { "prompt",     LT_UNKNOWN,     ' ' },
    585        { "fdt",        LT_DEVTREE,     ' ' },
    586        { "fdtdir",     LT_DEVTREE,     ' ' },
    587      { NULL,    0, 0 },      { NULL,    0, 0 },
    588  };  };
    589  int useextlinuxmenu;  int useextlinuxmenu;
    # Line 496  struct configFileInfo ziplConfigType = { Line 634  struct configFileInfo ziplConfigType = {
    634  struct configFileInfo extlinuxConfigType = {  struct configFileInfo extlinuxConfigType = {
    635      .defaultConfig = "/boot/extlinux/extlinux.conf",      .defaultConfig = "/boot/extlinux/extlinux.conf",
    636      .keywords = extlinuxKeywords,      .keywords = extlinuxKeywords,
    637        .caseInsensitive = 1,
    638      .entryStart = LT_TITLE,      .entryStart = LT_TITLE,
    639      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    640      .maxTitleLength = 255,      .maxTitleLength = 255,
    641      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    642        .defaultIsUnquoted = 1,
    643  };  };
    644    
    645  struct grubConfig {  struct grubConfig {
    # Line 520  struct singleEntry * findEntryByIndex(st Line 660  struct singleEntry * findEntryByIndex(st
    660  struct singleEntry * findEntryByPath(struct grubConfig * cfg,  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
    661       const char * path, const char * prefix,       const char * path, const char * prefix,
    662       int * index);       int * index);
    663    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    664          int * index);
    665  static int readFile(int fd, char ** bufPtr);  static int readFile(int fd, char ** bufPtr);
    666  static void lineInit(struct singleLine * line);  static void lineInit(struct singleLine * line);
    667  struct singleLine * lineDup(struct singleLine * line);  struct singleLine * lineDup(struct singleLine * line);
    # Line 589  static enum lineType_e preferredLineType Line 731  static enum lineType_e preferredLineType
    731      if (isEfi && cfi == &grub2ConfigType) {      if (isEfi && cfi == &grub2ConfigType) {
    732   switch (type) {   switch (type) {
    733   case LT_KERNEL:   case LT_KERNEL:
    734      return LT_KERNEL_EFI;      return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
    735     case LT_INITRD:
    736        return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
    737     default:
    738        return type;
    739     }
    740    #if defined(__i386__) || defined(__x86_64__)
    741        } else if (cfi == &grub2ConfigType) {
    742     switch (type) {
    743     case LT_KERNEL:
    744        return LT_KERNEL_16;
    745   case LT_INITRD:   case LT_INITRD:
    746      return LT_INITRD_EFI;      return LT_INITRD_16;
    747   default:   default:
    748      return type;      return type;
    749   }   }
    750    #endif
    751      }      }
    752      return type;      return type;
    753  }  }
    # Line 632  static char * getuuidbydev(char *device) Line 785  static char * getuuidbydev(char *device)
    785  static enum lineType_e getTypeByKeyword(char * keyword,  static enum lineType_e getTypeByKeyword(char * keyword,
    786   struct configFileInfo * cfi) {   struct configFileInfo * cfi) {
    787      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
    788   if (!strcmp(keyword, kw->key))   if (cfi->caseInsensitive) {
    789      return kw->type;      if (!strcasecmp(keyword, kw->key))
    790                    return kw->type;
    791     } else {
    792        if (!strcmp(keyword, kw->key))
    793            return kw->type;
    794     }
    795      }      }
    796      return LT_UNKNOWN;      return LT_UNKNOWN;
    797  }  }
    # Line 671  static int isEntryStart(struct singleLin Line 829  static int isEntryStart(struct singleLin
    829    
    830  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
    831  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct singleLine * line) {
    832      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it */
    833      char * title;      char * title = NULL;
    834      title = strdup(line->elements[0].item);      if (line->type == LT_TITLE) {
    835      title++;   title = strdup(line->elements[0].item + 1);
    836      *(title + strlen(title) - 1) = '\0';   *(title + strlen(title) - 1) = '\0';
    837        } else if (line->type == LT_MENUENTRY)
    838     title = strdup(line->elements[1].item);
    839        else
    840     return NULL;
    841      return title;      return title;
    842  }  }
    843    
    # Line 933  static int getNextLine(char ** bufPtr, s Line 1095  static int getNextLine(char ** bufPtr, s
    1095      return 0;      return 0;
    1096  }  }
    1097    
    1098    static int isnumber(const char *s)
    1099    {
    1100        int i;
    1101        for (i = 0; s[i] != '\0'; i++)
    1102     if (s[i] < '0' || s[i] > '9')
    1103        return 0;
    1104        return i;
    1105    }
    1106    
    1107  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1108        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1109      int in;      int in;
    # Line 947  static struct grubConfig * readConfig(co Line 1118  static struct grubConfig * readConfig(co
    1118      int len;      int len;
    1119      char * buf;      char * buf;
    1120    
    1121      if (!strcmp(inName, "-")) {      if (inName == NULL) {
    1122            printf("Could not find bootloader configuration\n");
    1123            exit(1);
    1124        } else if (!strcmp(inName, "-")) {
    1125   in = 0;   in = 0;
    1126      } else {      } else {
    1127   if ((in = open(inName, O_RDONLY)) < 0) {   if ((in = open(inName, O_RDONLY)) < 0) {
    # Line 1014  static struct grubConfig * readConfig(co Line 1188  static struct grubConfig * readConfig(co
    1188      dbgPrintf("\n");      dbgPrintf("\n");
    1189      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
    1190      if (kwType && line->numElements == 3 &&      if (kwType && line->numElements == 3 &&
    1191      !strcmp(line->elements[1].item, kwType->key)) {      !strcmp(line->elements[1].item, kwType->key) &&
    1192        !is_special_grub2_variable(line->elements[2].item)) {
    1193   dbgPrintf("Line sets default config\n");   dbgPrintf("Line sets default config\n");
    1194   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1195   defaultLine = line;   defaultLine = line;
    1196      }      }
      } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
         cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
         defaultLine = line;  
    1197    
    1198          } else if (iskernel(line->type)) {          } else if (iskernel(line->type)) {
    1199      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
    1200       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
    1201       * instead of LT_KERNEL now       * instead of LT_KERNEL now
    1202       */       */
    1203      if (entry->multiboot)      if (entry && entry->multiboot)
    1204   line->type = LT_HYPER;   line->type = LT_HYPER;
    1205    
    1206          } else if (line->type == LT_MBMODULE) {          } else if (line->type == LT_MBMODULE) {
    # Line 1054  static struct grubConfig * readConfig(co Line 1226  static struct grubConfig * readConfig(co
    1226      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
    1227      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
    1228    
    1229   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
    1230      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
    1231        /* make the title/default a single argument (undoing our parsing) */
    1232      len = 0;      len = 0;
    1233      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1234   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1162  static struct grubConfig * readConfig(co Line 1335  static struct grubConfig * readConfig(co
    1335      }      }
    1336   }   }
    1337    
    1338     if (line->type == LT_DEFAULT && line->numElements == 2) {
    1339        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1340        defaultLine = line;
    1341     }
    1342    
    1343   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
    1344     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
    1345     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
    # Line 1219  static struct grubConfig * readConfig(co Line 1397  static struct grubConfig * readConfig(co
    1397          if (defaultLine->numElements > 2 &&          if (defaultLine->numElements > 2 &&
    1398      cfi->defaultSupportSaved &&      cfi->defaultSupportSaved &&
    1399      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
    1400      cfg->defaultImage = DEFAULT_SAVED_GRUB2;   cfg->cfi->defaultIsSaved = 1;
    1401     cfg->defaultImage = DEFAULT_SAVED_GRUB2;
    1402     if (cfg->cfi->getEnv) {
    1403        char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1404        if (defTitle) {
    1405     int index = 0;
    1406     if (isnumber(defTitle)) {
    1407        index = atoi(defTitle);
    1408        entry = findEntryByIndex(cfg, index);
    1409     } else {
    1410        entry = findEntryByTitle(cfg, defTitle, &index);
    1411     }
    1412     if (entry)
    1413        cfg->defaultImage = index;
    1414        }
    1415     }
    1416   } else if (cfi->defaultIsVariable) {   } else if (cfi->defaultIsVariable) {
    1417      char *value = defaultLine->elements[2].item;      char *value = defaultLine->elements[2].item;
    1418      while (*value && (*value == '"' || *value == '\'' ||      while (*value && (*value == '"' || *value == '\'' ||
    # Line 1260  static struct grubConfig * readConfig(co Line 1453  static struct grubConfig * readConfig(co
    1453          cfg->defaultImage = -1;          cfg->defaultImage = -1;
    1454      }      }
    1455   }   }
    1456        } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
    1457     char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1458     if (defTitle) {
    1459        int index = 0;
    1460        if (isnumber(defTitle)) {
    1461     index = atoi(defTitle);
    1462     entry = findEntryByIndex(cfg, index);
    1463        } else {
    1464     entry = findEntryByTitle(cfg, defTitle, &index);
    1465        }
    1466        if (entry)
    1467     cfg->defaultImage = index;
    1468     }
    1469      } else {      } else {
    1470          cfg->defaultImage = 0;          cfg->defaultImage = 0;
    1471      }      }
    # Line 1277  static void writeDefault(FILE * out, cha Line 1483  static void writeDefault(FILE * out, cha
    1483    
    1484      if (cfg->defaultImage == DEFAULT_SAVED)      if (cfg->defaultImage == DEFAULT_SAVED)
    1485   fprintf(out, "%sdefault%ssaved\n", indent, separator);   fprintf(out, "%sdefault%ssaved\n", indent, separator);
    1486      else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)      else if (cfg->cfi->defaultIsSaved) {
    1487   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
    1488      else if (cfg->defaultImage > -1) {   if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
    1489        char *title;
    1490        entry = findEntryByIndex(cfg, cfg->defaultImage);
    1491        line = getLineByType(LT_MENUENTRY, entry->lines);
    1492        if (!line)
    1493     line = getLineByType(LT_TITLE, entry->lines);
    1494        if (line) {
    1495     title = extractTitle(line);
    1496     if (title)
    1497        cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
    1498        }
    1499     }
    1500        } else if (cfg->defaultImage > -1) {
    1501   if (cfg->cfi->defaultIsIndex) {   if (cfg->cfi->defaultIsIndex) {
    1502      if (cfg->cfi->defaultIsVariable) {      if (cfg->cfi->defaultIsVariable) {
    1503          fprintf(out, "%sset default=\"%d\"\n", indent,          fprintf(out, "%sset default=\"%d\"\n", indent,
    # Line 1382  static int writeConfig(struct grubConfig Line 1600  static int writeConfig(struct grubConfig
    1600      while (line) {      while (line) {
    1601          if (line->type == LT_SET_VARIABLE && defaultKw &&          if (line->type == LT_SET_VARIABLE && defaultKw &&
    1602   line->numElements == 3 &&   line->numElements == 3 &&
    1603   !strcmp(line->elements[1].item, defaultKw->key)) {   !strcmp(line->elements[1].item, defaultKw->key) &&
    1604     !is_special_grub2_variable(line->elements[2].item)) {
    1605      writeDefault(out, line->indent, line->elements[0].indent, cfg);      writeDefault(out, line->indent, line->elements[0].indent, cfg);
    1606      needs &= ~MAIN_DEFAULT;      needs &= ~MAIN_DEFAULT;
    1607   } else if (line->type == LT_DEFAULT) {   } else if (line->type == LT_DEFAULT) {
    # Line 1527  static char *findDiskForRoot() Line 1746  static char *findDiskForRoot()
    1746      return NULL;      return NULL;
    1747  }  }
    1748    
    1749  void printEntry(struct singleEntry * entry) {  void printEntry(struct singleEntry * entry, FILE *f) {
    1750      int i;      int i;
    1751      struct singleLine * line;      struct singleLine * line;
    1752    
    1753      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    1754   fprintf(stderr, "DBG: %s", line->indent);   log_message(f, "DBG: %s", line->indent);
    1755   for (i = 0; i < line->numElements; i++) {   for (i = 0; i < line->numElements; i++) {
    1756      /* Need to handle this, because we strip the quotes from      /* Need to handle this, because we strip the quotes from
    1757       * menuentry when read it. */       * menuentry when read it. */
    1758      if (line->type == LT_MENUENTRY && i == 1) {      if (line->type == LT_MENUENTRY && i == 1) {
    1759   if(!isquote(*line->elements[i].item))   if(!isquote(*line->elements[i].item))
    1760      fprintf(stderr, "\'%s\'", line->elements[i].item);      log_message(f, "\'%s\'", line->elements[i].item);
    1761   else   else
    1762      fprintf(stderr, "%s", line->elements[i].item);      log_message(f, "%s", line->elements[i].item);
    1763   fprintf(stderr, "%s", line->elements[i].indent);   log_message(f, "%s", line->elements[i].indent);
    1764    
    1765   continue;   continue;
    1766      }      }
    1767            
    1768      fprintf(stderr, "%s%s",      log_message(f, "%s%s",
    1769      line->elements[i].item, line->elements[i].indent);      line->elements[i].item, line->elements[i].indent);
    1770   }   }
    1771   fprintf(stderr, "\n");   log_message(f, "\n");
    1772      }      }
    1773  }  }
    1774    
    1775  void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)  void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
    1776  {  {
    1777      va_list argp;      static int once;
    1778        va_list argp, argq;
    1779    
    1780        va_start(argp, fmt);
    1781    
    1782      if (!debug)      va_copy(argq, argp);
    1783        if (!once) {
    1784     log_time(NULL);
    1785     log_message(NULL, "command line: %s\n", saved_command_line);
    1786        }
    1787        log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
    1788        log_vmessage(NULL, fmt, argq);
    1789    
    1790        printEntry(entry, NULL);
    1791        va_end(argq);
    1792    
    1793        if (!debug) {
    1794     once = 1;
    1795         va_end(argp);
    1796   return;   return;
    1797        }
    1798    
    1799      va_start(argp, fmt);      if (okay) {
    1800     va_end(argp);
    1801     return;
    1802        }
    1803    
    1804        if (!once)
    1805     log_message(stderr, "DBG: command line: %s\n", saved_command_line);
    1806        once = 1;
    1807      fprintf(stderr, "DBG: Image entry failed: ");      fprintf(stderr, "DBG: Image entry failed: ");
    1808      vfprintf(stderr, fmt, argp);      vfprintf(stderr, fmt, argp);
    1809      printEntry(entry);      printEntry(entry, stderr);
    1810      va_end(argp);      va_end(argp);
    1811  }  }
    1812    
    # Line 1590  int suitableImage(struct singleEntry * e Line 1833  int suitableImage(struct singleEntry * e
    1833      char * rootdev;      char * rootdev;
    1834    
    1835      if (skipRemoved && entry->skip) {      if (skipRemoved && entry->skip) {
    1836   notSuitablePrintf(entry, "marked to skip\n");   notSuitablePrintf(entry, 0, "marked to skip\n");
    1837   return 0;   return 0;
    1838      }      }
    1839    
    1840      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);
    1841      if (!line) {      if (!line) {
    1842   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1843   return 0;   return 0;
    1844      }      }
    1845      if (line->numElements < 2) {      if (line->numElements < 2) {
    1846   notSuitablePrintf(entry, "line has only %d elements\n",   notSuitablePrintf(entry, 0, "line has only %d elements\n",
    1847      line->numElements);      line->numElements);
    1848   return 0;   return 0;
    1849      }      }
    1850    
    1851      if (flags & GRUBBY_BADIMAGE_OKAY) return 1;      if (flags & GRUBBY_BADIMAGE_OKAY) {
    1852        notSuitablePrintf(entry, 1, "\n");
    1853        return 1;
    1854        }
    1855    
    1856      fullName = alloca(strlen(bootPrefix) +      fullName = alloca(strlen(bootPrefix) +
    1857        strlen(line->elements[1].item) + 1);        strlen(line->elements[1].item) + 1);
    # Line 1616  int suitableImage(struct singleEntry * e Line 1862  int suitableImage(struct singleEntry * e
    1862      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
    1863              line->elements[1].item + rootspec_offset);              line->elements[1].item + rootspec_offset);
    1864      if (access(fullName, R_OK)) {      if (access(fullName, R_OK)) {
    1865   notSuitablePrintf(entry, "access to %s failed\n", fullName);   notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
    1866   return 0;   return 0;
    1867      }      }
    1868      for (i = 2; i < line->numElements; i++)      for (i = 2; i < line->numElements; i++)
    # Line 1637  int suitableImage(struct singleEntry * e Line 1883  int suitableImage(struct singleEntry * e
    1883    
    1884              /* failed to find one */              /* failed to find one */
    1885              if (!line) {              if (!line) {
    1886   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1887   return 0;   return 0;
    1888              }              }
    1889    
    # Line 1646  int suitableImage(struct singleEntry * e Line 1892  int suitableImage(struct singleEntry * e
    1892      if (i < line->numElements)      if (i < line->numElements)
    1893          dev = line->elements[i].item + 5;          dev = line->elements[i].item + 5;
    1894      else {      else {
    1895   notSuitablePrintf(entry, "no root= entry found\n");   notSuitablePrintf(entry, 0, "no root= entry found\n");
    1896   /* it failed too...  can't find root= */   /* it failed too...  can't find root= */
    1897          return 0;          return 0;
    1898              }              }
    # Line 1655  int suitableImage(struct singleEntry * e Line 1901  int suitableImage(struct singleEntry * e
    1901    
    1902      dev = getpathbyspec(dev);      dev = getpathbyspec(dev);
    1903      if (!getpathbyspec(dev)) {      if (!getpathbyspec(dev)) {
    1904          notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);          notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
    1905          return 0;          return 0;
    1906      } else      } else
    1907   dev = getpathbyspec(dev);   dev = getpathbyspec(dev);
    1908    
    1909      rootdev = findDiskForRoot();      rootdev = findDiskForRoot();
    1910      if (!rootdev) {      if (!rootdev) {
    1911          notSuitablePrintf(entry, "can't find root device\n");          notSuitablePrintf(entry, 0, "can't find root device\n");
    1912   return 0;   return 0;
    1913      }      }
    1914    
    1915      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
    1916          notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
    1917   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1918          free(rootdev);          free(rootdev);
    1919          return 0;          return 0;
    1920      }      }
    1921    
    1922      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
    1923          notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
    1924   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1925   free(rootdev);   free(rootdev);
    1926          return 0;          return 0;
    1927      }      }
    1928    
    1929      free(rootdev);      free(rootdev);
    1930        notSuitablePrintf(entry, 1, "\n");
    1931    
    1932      return 1;      return 1;
    1933  }  }
    # Line 1714  struct singleEntry * findEntryByPath(str Line 1961  struct singleEntry * findEntryByPath(str
    1961   }   }
    1962    
    1963   indexVars[i + 1] = -1;   indexVars[i + 1] = -1;
    1964    
    1965   i = 0;   i = 0;
    1966   if (index) {   if (index) {
    1967      while (i < *index) i++;      while (i < *index) {
    1968      if (indexVars[i] == -1) return NULL;   i++;
    1969     if (indexVars[i] == -1) return NULL;
    1970        }
    1971   }   }
    1972    
    1973   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1974   if (!entry) return NULL;   if (!entry) return NULL;
    1975    
    1976   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);
    1977   if (!line) return NULL;   if (!line) return NULL;
    1978    
    1979   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1775  struct singleEntry * findEntryByPath(str Line 2024  struct singleEntry * findEntryByPath(str
    2024      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2025   enum lineType_e ct = checkType;   enum lineType_e ct = checkType;
    2026   if (entry->multiboot && checkType == LT_KERNEL)   if (entry->multiboot && checkType == LT_KERNEL)
    2027      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2028   else if (checkType & LT_KERNEL)   else if (checkType & LT_KERNEL)
    2029      ct = checkType | LT_KERNEL_EFI;      ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2030   line = getLineByType(ct, line);   line = getLineByType(ct, line);
    2031   if (!line)   if (!line)
    2032      break;  /* not found in this entry */      break;  /* not found in this entry */
    # Line 1799  struct singleEntry * findEntryByPath(str Line 2048  struct singleEntry * findEntryByPath(str
    2048       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2049       * unfortunate)       * unfortunate)
    2050       */       */
    2051      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))
    2052   break; /* found 'im! */   break; /* found 'im! */
    2053   }   }
    2054    
    # Line 1809  struct singleEntry * findEntryByPath(str Line 2058  struct singleEntry * findEntryByPath(str
    2058      return entry;      return entry;
    2059  }  }
    2060    
    2061    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    2062          int * index) {
    2063        struct singleEntry * entry;
    2064        struct singleLine * line;
    2065        int i;
    2066        char * newtitle;
    2067    
    2068        for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
    2069     if (index && i < *index)
    2070        continue;
    2071     line = getLineByType(LT_TITLE, entry->lines);
    2072     if (!line)
    2073        line = getLineByType(LT_MENUENTRY, entry->lines);
    2074     if (!line)
    2075        continue;
    2076     newtitle = grub2ExtractTitle(line);
    2077     if (!newtitle)
    2078        continue;
    2079     if (!strcmp(title, newtitle))
    2080        break;
    2081        }
    2082    
    2083        if (!entry)
    2084     return NULL;
    2085    
    2086        if (index)
    2087     *index = i;
    2088        return entry;
    2089    }
    2090    
    2091  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
    2092      struct singleEntry * entry;      struct singleEntry * entry;
    2093    
    # Line 1831  struct singleEntry * findTemplate(struct Line 2110  struct singleEntry * findTemplate(struct
    2110      struct singleEntry * entry, * entry2;      struct singleEntry * entry, * entry2;
    2111      int index;      int index;
    2112    
    2113      if (cfg->defaultImage > -1) {      if (cfg->cfi->defaultIsSaved) {
    2114     if (cfg->cfi->getEnv) {
    2115        char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2116        if (defTitle) {
    2117     int index = 0;
    2118     if (isnumber(defTitle)) {
    2119        index = atoi(defTitle);
    2120        entry = findEntryByIndex(cfg, index);
    2121     } else {
    2122        entry = findEntryByTitle(cfg, defTitle, &index);
    2123     }
    2124     if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2125        cfg->defaultImage = index;
    2126        if (indexPtr)
    2127     *indexPtr = index;
    2128        return entry;
    2129     }
    2130        }
    2131     }
    2132        } else if (cfg->defaultImage > -1) {
    2133   entry = findEntryByIndex(cfg, cfg->defaultImage);   entry = findEntryByIndex(cfg, cfg->defaultImage);
    2134   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2135      if (indexPtr) *indexPtr = cfg->defaultImage;      if (indexPtr) *indexPtr = cfg->defaultImage;
    # Line 1985  void displayEntry(struct singleEntry * e Line 2283  void displayEntry(struct singleEntry * e
    2283      struct singleLine * line;      struct singleLine * line;
    2284      char * root = NULL;      char * root = NULL;
    2285      int i;      int i;
    2286        int j;
    2287    
    2288      printf("index=%d\n", index);      printf("index=%d\n", index);
    2289    
    2290      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);
    2291      if (!line) {      if (!line) {
    2292          printf("non linux entry\n");          printf("non linux entry\n");
    2293          return;          return;
    # Line 2053  void displayEntry(struct singleEntry * e Line 2352  void displayEntry(struct singleEntry * e
    2352   printf("root=%s\n", s);   printf("root=%s\n", s);
    2353      }      }
    2354    
    2355      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2356    
    2357      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2358   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2072  void displayEntry(struct singleEntry * e Line 2371  void displayEntry(struct singleEntry * e
    2371      } else {      } else {
    2372   char * title;   char * title;
    2373   line = getLineByType(LT_MENUENTRY, entry->lines);   line = getLineByType(LT_MENUENTRY, entry->lines);
    2374   title = grub2ExtractTitle(line);   if (line) {
    2375   if (title)      title = grub2ExtractTitle(line);
    2376      printf("title=%s\n", title);      if (title)
    2377     printf("title=%s\n", title);
    2378     }
    2379        }
    2380    
    2381        for (j = 0, line = entry->lines; line; line = line->next) {
    2382     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2383        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2384     printf("mbmodule%d=", j);
    2385        else
    2386     printf("mbmodule%d=%s", j, prefix);
    2387    
    2388        for (i = 1; i < line->numElements; i++)
    2389     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2390        printf("\n");
    2391        j++;
    2392     }
    2393      }      }
    2394  }  }
    2395    
    # Line 2470  struct singleLine * addLineTmpl(struct s Line 2785  struct singleLine * addLineTmpl(struct s
    2785   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2786    
    2787   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2788   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)) {
    2789      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2790      if (rootspec != NULL) {      if (rootspec != NULL) {
    2791   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 2840  int updateActualImage(struct grubConfig Line 3155  int updateActualImage(struct grubConfig
    3155      firstElement = 2;      firstElement = 2;
    3156    
    3157   } else {   } else {
    3158      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);
    3159      if (!line) {      if (!line) {
    3160   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3161   continue;   continue;
    # Line 2996  int updateImage(struct grubConfig * cfg, Line 3311  int updateImage(struct grubConfig * cfg,
    3311      return rc;      return rc;
    3312  }  }
    3313    
    3314    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3315     const char * image, const char * prefix, const char * initrd,
    3316     const char * title) {
    3317        struct singleEntry * entry;
    3318        struct singleLine * line, * kernelLine, *endLine = NULL;
    3319        int index = 0;
    3320    
    3321        if (!image) return 0;
    3322    
    3323        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3324            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3325            if (!kernelLine) continue;
    3326    
    3327     /* if title is supplied, the entry's title must match it. */
    3328     if (title) {
    3329        char *linetitle;
    3330    
    3331        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3332        if (!line)
    3333     continue;
    3334    
    3335        linetitle = extractTitle(line);
    3336        if (!linetitle)
    3337     continue;
    3338        if (strcmp(title, linetitle)) {
    3339     free(linetitle);
    3340     continue;
    3341        }
    3342        free(linetitle);
    3343     }
    3344    
    3345            if (prefix) {
    3346                int prefixLen = strlen(prefix);
    3347                if (!strncmp(initrd, prefix, prefixLen))
    3348                    initrd += prefixLen;
    3349            }
    3350     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3351     if (endLine)
    3352        removeLine(entry, endLine);
    3353            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3354     kernelLine->indent, initrd);
    3355            if (!line)
    3356        return 1;
    3357     if (endLine) {
    3358        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3359                if (!line)
    3360     return 1;
    3361     }
    3362    
    3363            break;
    3364        }
    3365    
    3366        return 0;
    3367    }
    3368    
    3369  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3370                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd, const char * title) {
    3371      struct singleEntry * entry;      struct singleEntry * entry;
    3372      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
    3373      int index = 0;      int index = 0;
    # Line 3005  int updateInitrd(struct grubConfig * cfg Line 3375  int updateInitrd(struct grubConfig * cfg
    3375      if (!image) return 0;      if (!image) return 0;
    3376    
    3377      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3378          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3379          if (!kernelLine) continue;          if (!kernelLine) continue;
    3380    
    3381          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);   /* if title is supplied, the entry's title must match it. */
    3382     if (title) {
    3383        char *linetitle;
    3384    
    3385        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3386        if (!line)
    3387     continue;
    3388    
    3389        linetitle = extractTitle(line);
    3390        if (!linetitle)
    3391     continue;
    3392        if (strcmp(title, linetitle)) {
    3393     free(linetitle);
    3394     continue;
    3395        }
    3396        free(linetitle);
    3397     }
    3398    
    3399            line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3400          if (line)          if (line)
    3401              removeLine(entry, line);              removeLine(entry, line);
    3402          if (prefix) {          if (prefix) {
    # Line 3019  int updateInitrd(struct grubConfig * cfg Line 3407  int updateInitrd(struct grubConfig * cfg
    3407   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3408   if (endLine)   if (endLine)
    3409      removeLine(entry, endLine);      removeLine(entry, endLine);
    3410          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3411   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3412        case LT_KERNEL:
    3413            lt = LT_INITRD;
    3414     break;
    3415        case LT_KERNEL_EFI:
    3416            lt = LT_INITRD_EFI;
    3417     break;
    3418        case LT_KERNEL_16:
    3419            lt = LT_INITRD_16;
    3420     break;
    3421        default:
    3422            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3423     }
    3424            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3425          if (!line)          if (!line)
    3426      return 1;      return 1;
    3427   if (endLine) {   if (endLine) {
    # Line 3379  int addNewKernel(struct grubConfig * con Line 3780  int addNewKernel(struct grubConfig * con
    3780   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3781   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3782   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3783                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3784     const char * newDevTreePath) {
    3785      struct singleEntry * new;      struct singleEntry * new;
    3786      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3787      int needs;      int needs;
    # Line 3420  int addNewKernel(struct grubConfig * con Line 3822  int addNewKernel(struct grubConfig * con
    3822          needs |= NEED_MB;          needs |= NEED_MB;
    3823          new->multiboot = 1;          new->multiboot = 1;
    3824      }      }
    3825        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3826     needs |= NEED_DEVTREE;
    3827    
    3828      if (template) {      if (template) {
    3829   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3605  int addNewKernel(struct grubConfig * con Line 4009  int addNewKernel(struct grubConfig * con
    4009   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    4010   config->cfi);   config->cfi);
    4011      }      }
    4012        } else if (tmplLine->type == LT_DEVTREE &&
    4013           tmplLine->numElements == 2 && newDevTreePath) {
    4014            newLine = addLineTmpl(new, tmplLine, newLine,
    4015          newDevTreePath + strlen(prefix),
    4016          config->cfi);
    4017     needs &= ~NEED_DEVTREE;
    4018        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    4019     const char *ndtp = newDevTreePath;
    4020     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    4021        ndtp += strlen(prefix);
    4022     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4023      config->secondaryIndent,
    4024      ndtp);
    4025     needs &= ~NEED_DEVTREE;
    4026     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    4027      } else {      } else {
    4028   /* pass through other lines from the template */   /* pass through other lines from the template */
    4029   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3618  int addNewKernel(struct grubConfig * con Line 4037  int addNewKernel(struct grubConfig * con
    4037   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    4038      case LT_KERNEL:      case LT_KERNEL:
    4039      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    4040        case LT_KERNEL_16:
    4041   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    4042      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    4043   } else {   } else {
    # Line 3679  int addNewKernel(struct grubConfig * con Line 4099  int addNewKernel(struct grubConfig * con
    4099   }   }
    4100      }      }
    4101    
    4102        struct singleLine *endLine = NULL;
    4103        endLine = getLineByType(LT_ENTRY_END, new->lines);
    4104        if (endLine) {
    4105        removeLine(new, endLine);
    4106        needs |= NEED_END;
    4107        }
    4108    
    4109      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
    4110       * 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,
    4111       * all the lines following the entryStart.       * all the lines following the entryStart.
    # Line 3724  int addNewKernel(struct grubConfig * con Line 4151  int addNewKernel(struct grubConfig * con
    4151   free(initrdVal);   free(initrdVal);
    4152   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4153      }      }
    4154        if (needs & NEED_DEVTREE) {
    4155     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4156      config->secondaryIndent,
    4157      newDevTreePath);
    4158     needs &= ~NEED_DEVTREE;
    4159        }
    4160    
    4161        /* NEEDS_END must be last on bootloaders that need it... */
    4162      if (needs & NEED_END) {      if (needs & NEED_END) {
    4163   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4164   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    # Line 3750  static void traceback(int signum) Line 4185  static void traceback(int signum)
    4185      memset(array, '\0', sizeof (array));      memset(array, '\0', sizeof (array));
    4186      size = backtrace(array, 40);      size = backtrace(array, 40);
    4187    
    4188      fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",      fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
    4189              (unsigned long)size);              (unsigned long)size);
    4190      backtrace_symbols_fd(array, size, STDERR_FILENO);      backtrace_symbols_fd(array, size, STDERR_FILENO);
    4191      exit(1);      exit(1);
    # Line 3775  int main(int argc, const char ** argv) { Line 4210  int main(int argc, const char ** argv) {
    4210      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4211      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4212      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4213      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4214      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4215      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4216      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 3785  int main(int argc, const char ** argv) { Line 4220  int main(int argc, const char ** argv) {
    4220      char * removeArgs = NULL;      char * removeArgs = NULL;
    4221      char * kernelInfo = NULL;      char * kernelInfo = NULL;
    4222      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
    4223        char * envPath = NULL;
    4224      const char * chptr = NULL;      const char * chptr = NULL;
    4225      struct configFileInfo * cfi = NULL;      struct configFileInfo * cfi = NULL;
    4226      struct grubConfig * config;      struct grubConfig * config;
    # Line 3832  int main(int argc, const char ** argv) { Line 4268  int main(int argc, const char ** argv) {
    4268      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4269   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4270      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4271     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4272        _("device tree file for new stanza"), _("dtb-path") },
    4273     { "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4274        _("device tree directory for new stanza"), _("dtb-path") },
    4275   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4276      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4277   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    4278      _("force grub2 stanzas to use efi") },      _("force grub2 stanzas to use efi") },
    4279     { "env", 0, POPT_ARG_STRING, &envPath, 0,
    4280        _("path for environment data"),
    4281        _("path") },
    4282   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
    4283      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
    4284   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
    # Line 3848  int main(int argc, const char ** argv) { Line 4291  int main(int argc, const char ** argv) {
    4291   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
    4292      _("initrd image for the new kernel"), _("initrd-path") },      _("initrd image for the new kernel"), _("initrd-path") },
    4293   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
    4294      _("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },      _("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
    4295   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
    4296      _("configure lilo bootloader") },      _("configure lilo bootloader") },
    4297   { "make-default", 0, 0, &makeDefault, 0,   { "make-default", 0, 0, &makeDefault, 0,
    # Line 3892  int main(int argc, const char ** argv) { Line 4335  int main(int argc, const char ** argv) {
    4335    
    4336      signal(SIGSEGV, traceback);      signal(SIGSEGV, traceback);
    4337    
    4338        int i = 0;
    4339        for (int j = 1; j < argc; j++)
    4340     i += strlen(argv[j]) + 1;
    4341        saved_command_line = malloc(i);
    4342        if (!saved_command_line) {
    4343     fprintf(stderr, "grubby: %m\n");
    4344     exit(1);
    4345        }
    4346        saved_command_line[0] = '\0';
    4347        for (int j = 1; j < argc; j++) {
    4348     strcat(saved_command_line, argv[j]);
    4349     strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
    4350        }
    4351    
    4352      optCon = poptGetContext("grubby", argc, argv, options, 0);      optCon = poptGetContext("grubby", argc, argv, options, 0);
    4353      poptReadDefaultConfig(optCon, 1);      poptReadDefaultConfig(optCon, 1);
    4354    
    # Line 3935  int main(int argc, const char ** argv) { Line 4392  int main(int argc, const char ** argv) {
    4392   return 1;   return 1;
    4393      } else if (configureGrub2) {      } else if (configureGrub2) {
    4394   cfi = &grub2ConfigType;   cfi = &grub2ConfigType;
    4395     if (envPath)
    4396        cfi->envFile = envPath;
    4397      } else if (configureLilo) {      } else if (configureLilo) {
    4398   cfi = &liloConfigType;   cfi = &liloConfigType;
    4399      } else if (configureGrub) {      } else if (configureGrub) {
    # Line 3978  int main(int argc, const char ** argv) { Line 4437  int main(int argc, const char ** argv) {
    4437      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4438      }      }
    4439    
    4440      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4441      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4442      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4443      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 3987  int main(int argc, const char ** argv) { Line 4446  int main(int argc, const char ** argv) {
    4446   return 1;   return 1;
    4447      }      }
    4448    
    4449      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4450     removeKernelPath)) {     removeKernelPath)) {
    4451   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4452    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 3997  int main(int argc, const char ** argv) { Line 4456  int main(int argc, const char ** argv) {
    4456      if (newKernelPath && !newKernelTitle) {      if (newKernelPath && !newKernelTitle) {
    4457   fprintf(stderr, _("grubby: kernel title must be specified\n"));   fprintf(stderr, _("grubby: kernel title must be specified\n"));
    4458   return 1;   return 1;
    4459      } else if (!newKernelPath && (newKernelTitle  || copyDefault ||      } else if (!newKernelPath && (copyDefault ||
    4460    (newKernelInitrd && !updateKernelPath)||    (newKernelInitrd && !updateKernelPath)||
    4461    makeDefault || extraInitrdCount > 0)) {    makeDefault || extraInitrdCount > 0)) {
    4462   fprintf(stderr, _("grubby: kernel path expected\n"));   fprintf(stderr, _("grubby: kernel path expected\n"));
    # Line 4135  int main(int argc, const char ** argv) { Line 4594  int main(int argc, const char ** argv) {
    4594   return 0;   return 0;
    4595      }      }
    4596    
    4597        if (grubConfig == NULL) {
    4598     printf("Could not find bootloader configuration file.\n");
    4599     exit(1);
    4600        }
    4601    
    4602      config = readConfig(grubConfig, cfi);      config = readConfig(grubConfig, cfi);
    4603      if (!config) return 1;      if (!config) return 1;
    4604    
    # Line 4144  int main(int argc, const char ** argv) { Line 4608  int main(int argc, const char ** argv) {
    4608          char * rootspec;          char * rootspec;
    4609    
    4610   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4611     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4612     cfi->defaultIsSaved)
    4613        config->defaultImage = 0;
    4614   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4615   if (!entry) return 0;   if (!entry) return 0;
    4616   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4617    
    4618   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);
    4619   if (!line) return 0;   if (!line) return 0;
    4620    
    4621          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4162  int main(int argc, const char ** argv) { Line 4629  int main(int argc, const char ** argv) {
    4629   struct singleEntry * entry;   struct singleEntry * entry;
    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    
    # Line 4184  int main(int argc, const char ** argv) { Line 4654  int main(int argc, const char ** argv) {
    4654    
    4655      } else if (displayDefaultIndex) {      } else if (displayDefaultIndex) {
    4656          if (config->defaultImage == -1) return 0;          if (config->defaultImage == -1) return 0;
    4657     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4658     cfi->defaultIsSaved)
    4659        config->defaultImage = 0;
    4660          printf("%i\n", config->defaultImage);          printf("%i\n", config->defaultImage);
    4661            return 0;
    4662    
    4663      } else if (kernelInfo)      } else if (kernelInfo)
    4664   return displayInfo(config, kernelInfo, bootPrefix);   return displayInfo(config, kernelInfo, bootPrefix);
    # Line 4202  int main(int argc, const char ** argv) { Line 4676  int main(int argc, const char ** argv) {
    4676      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4677                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4678      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4679              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4680                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4681     bootPrefix, newKernelInitrd,
    4682     newKernelTitle))
    4683        return 1;
    4684        } else {
    4685        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4686     newKernelInitrd, newKernelTitle))
    4687     return 1;
    4688        }
    4689      }      }
    4690      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4691                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4692                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4693                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4694            
    4695    
    4696      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2052  
    changed lines
      Added in v.2977