Magellan Linux

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

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

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

    revision 1850 by niro, Mon Jul 2 13:09:12 2012 UTC revision 2708 by niro, Wed Jul 16 10:56:09 2014 UTC
    # Line 36  Line 36 
    36  #include <signal.h>  #include <signal.h>
    37  #include <blkid/blkid.h>  #include <blkid/blkid.h>
    38    
    39    #include "log.h"
    40    
    41  #ifndef DEBUG  #ifndef DEBUG
    42  #define DEBUG 0  #define DEBUG 0
    43  #endif  #endif
    # Line 56  int debug = 0; /* Currently just for tem Line 58  int debug = 0; /* Currently just for tem
    58  #define NOOP_OPCODE 0x90  #define NOOP_OPCODE 0x90
    59  #define JMP_SHORT_OPCODE 0xeb  #define JMP_SHORT_OPCODE 0xeb
    60    
    61    int isEfi = 0;
    62    
    63    #if defined(__aarch64__)
    64    #define isEfiOnly 1
    65    #else
    66    #define isEfiOnly 0
    67    #endif
    68    
    69    char *saved_command_line = NULL;
    70    
    71  /* comments get lumped in with indention */  /* comments get lumped in with indention */
    72  struct lineElement {  struct lineElement {
    73      char * item;      char * item;
    # Line 82  enum lineType_e { Line 94  enum lineType_e {
    94      LT_MENUENTRY    = 1 << 17,      LT_MENUENTRY    = 1 << 17,
    95      LT_ENTRY_END    = 1 << 18,      LT_ENTRY_END    = 1 << 18,
    96      LT_SET_VARIABLE = 1 << 19,      LT_SET_VARIABLE = 1 << 19,
    97      LT_UNKNOWN      = 1 << 20,      LT_KERNEL_EFI   = 1 << 20,
    98        LT_INITRD_EFI   = 1 << 21,
    99        LT_KERNEL_16    = 1 << 22,
    100        LT_INITRD_16    = 1 << 23,
    101        LT_DEVTREE      = 1 << 24,
    102        LT_UNKNOWN      = 1 << 25,
    103  };  };
    104    
    105  struct singleLine {  struct singleLine {
    # Line 111  struct singleEntry { Line 128  struct singleEntry {
    128  #define NEED_ARGS    (1 << 3)  #define NEED_ARGS    (1 << 3)
    129  #define NEED_MB      (1 << 4)  #define NEED_MB      (1 << 4)
    130  #define NEED_END     (1 << 5)  #define NEED_END     (1 << 5)
    131    #define NEED_DEVTREE (1 << 6)
    132    
    133  #define MAIN_DEFAULT    (1 << 0)  #define MAIN_DEFAULT    (1 << 0)
    134  #define DEFAULT_SAVED       -2  #define DEFAULT_SAVED       -2
    # Line 128  struct configFileInfo; Line 146  struct configFileInfo;
    146  typedef const char *(*findConfigFunc)(struct configFileInfo *);  typedef const char *(*findConfigFunc)(struct configFileInfo *);
    147  typedef const int (*writeLineFunc)(struct configFileInfo *,  typedef const int (*writeLineFunc)(struct configFileInfo *,
    148   struct singleLine *line);   struct singleLine *line);
    149    typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
    150    typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
    151    
    152  struct configFileInfo {  struct configFileInfo {
    153      char * defaultConfig;      char * defaultConfig;
    154      findConfigFunc findConfig;      findConfigFunc findConfig;
    155      writeLineFunc writeLine;      writeLineFunc writeLine;
    156        getEnvFunc getEnv;
    157        setEnvFunc setEnv;
    158      struct keywordTypes * keywords;      struct keywordTypes * keywords;
    159        int caseInsensitive;
    160      int defaultIsIndex;      int defaultIsIndex;
    161      int defaultIsVariable;      int defaultIsVariable;
    162      int defaultSupportSaved;      int defaultSupportSaved;
    163        int defaultIsSaved;
    164        int defaultIsUnquoted;
    165      enum lineType_e entryStart;      enum lineType_e entryStart;
    166      enum lineType_e entryEnd;      enum lineType_e entryEnd;
    167      int needsBootPrefix;      int needsBootPrefix;
    # Line 148  struct configFileInfo { Line 173  struct configFileInfo {
    173      int mbInitRdIsModule;      int mbInitRdIsModule;
    174      int mbConcatArgs;      int mbConcatArgs;
    175      int mbAllowExtraInitRds;      int mbAllowExtraInitRds;
    176        char *envFile;
    177  };  };
    178    
    179  struct keywordTypes grubKeywords[] = {  struct keywordTypes grubKeywords[] = {
    # Line 164  struct keywordTypes grubKeywords[] = { Line 190  struct keywordTypes grubKeywords[] = {
    190    
    191  const char *grubFindConfig(struct configFileInfo *cfi) {  const char *grubFindConfig(struct configFileInfo *cfi) {
    192      static const char *configFiles[] = {      static const char *configFiles[] = {
      "/etc/grub.conf",  
    193   "/boot/grub/grub.conf",   "/boot/grub/grub.conf",
    194   "/boot/grub/menu.lst",   "/boot/grub/menu.lst",
    195     "/etc/grub.conf",
    196     "/boot/grub2/grub.cfg",
    197     "/boot/grub2-efi/grub.cfg",
    198   NULL   NULL
    199      };      };
    200      static int i = -1;      static int i = -1;
    # Line 205  struct keywordTypes grub2Keywords[] = { Line 233  struct keywordTypes grub2Keywords[] = {
    233      { "default",    LT_DEFAULT,     ' ' },      { "default",    LT_DEFAULT,     ' ' },
    234      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    235      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    236        { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    237        { "linux16",    LT_KERNEL_16,   ' ' },
    238      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    239        { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
    240        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
    241      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
    242      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
    243        { "devicetree", LT_DEVTREE,  ' ' },
    244      { NULL, 0, 0 },      { NULL, 0, 0 },
    245  };  };
    246    
    # Line 219  const char *grub2FindConfig(struct confi Line 252  const char *grub2FindConfig(struct confi
    252      };      };
    253      static int i = -1;      static int i = -1;
    254      static const char *grub_cfg = "/boot/grub/grub.cfg";      static const char *grub_cfg = "/boot/grub/grub.cfg";
    255        int rc = -1;
    256    
    257      if (i == -1) {      if (i == -1) {
    258   for (i = 0; configFiles[i] != NULL; i++) {   for (i = 0; configFiles[i] != NULL; i++) {
    259      dbgPrintf("Checking \"%s\": ", configFiles[i]);      dbgPrintf("Checking \"%s\": ", configFiles[i]);
    260      if (!access(configFiles[i], R_OK)) {      if ((rc = access(configFiles[i], R_OK))) {
    261     if (errno == EACCES) {
    262        printf("Unable to access bootloader configuration file "
    263           "\"%s\": %m\n", configFiles[i]);
    264        exit(1);
    265     }
    266     continue;
    267        } else {
    268   dbgPrintf("found\n");   dbgPrintf("found\n");
    269   return configFiles[i];   return configFiles[i];
    270      }      }
    # Line 242  const char *grub2FindConfig(struct confi Line 283  const char *grub2FindConfig(struct confi
    283      return configFiles[i];      return configFiles[i];
    284  }  }
    285    
    286    /* kind of hacky.  It'll give the first 1024 bytes, ish. */
    287    static char *grub2GetEnv(struct configFileInfo *info, char *name)
    288    {
    289        static char buf[1025];
    290        char *s = NULL;
    291        char *ret = NULL;
    292        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    293        int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
    294    
    295        if (rc < 0)
    296     return NULL;
    297    
    298        FILE *f = popen(s, "r");
    299        if (!f)
    300     goto out;
    301    
    302        memset(buf, '\0', sizeof (buf));
    303        ret = fgets(buf, 1024, f);
    304        pclose(f);
    305    
    306        if (ret) {
    307     ret += strlen(name) + 1;
    308     ret[strlen(ret) - 1] = '\0';
    309        }
    310        dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
    311    out:
    312        free(s);
    313        return ret;
    314    }
    315    
    316    static int sPopCount(const char *s, const char *c)
    317    {
    318        int ret = 0;
    319        if (!s)
    320     return -1;
    321        for (int i = 0; s[i] != '\0'; i++)
    322     for (int j = 0; c[j] != '\0'; j++)
    323        if (s[i] == c[j])
    324     ret++;
    325        return ret;
    326    }
    327    
    328    static char *shellEscape(const char *s)
    329    {
    330        int l = strlen(s) + sPopCount(s, "'") * 2;
    331    
    332        char *ret = calloc(l+1, sizeof (*ret));
    333        if (!ret)
    334     return NULL;
    335        for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
    336     if (s[i] == '\'')
    337        ret[j++] = '\\';
    338     ret[j] = s[i];
    339        }
    340        return ret;
    341    }
    342    
    343    static void unquote(char *s)
    344    {
    345        int l = strlen(s);
    346    
    347        if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
    348     memmove(s, s+1, l-2);
    349     s[l-2] = '\0';
    350        }
    351    }
    352    
    353    static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
    354    {
    355        char *s = NULL;
    356        int rc = 0;
    357        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    358    
    359        unquote(value);
    360        value = shellEscape(value);
    361        if (!value)
    362        return -1;
    363    
    364        rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
    365        free(value);
    366        if (rc <0)
    367     return -1;
    368    
    369        dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
    370        rc = system(s);
    371        free(s);
    372        return rc;
    373    }
    374    
    375    /* this is a gigantic hack to avoid clobbering grub2 variables... */
    376    static int is_special_grub2_variable(const char *name)
    377    {
    378        if (!strcmp(name,"\"${next_entry}\""))
    379     return 1;
    380        if (!strcmp(name,"\"${prev_saved_entry}\""))
    381     return 1;
    382        return 0;
    383    }
    384    
    385  int sizeOfSingleLine(struct singleLine * line) {  int sizeOfSingleLine(struct singleLine * line) {
    386    int count = 0;    int count = 0;
    387    
    # Line 271  static int isquote(char q) Line 411  static int isquote(char q)
    411      return 0;      return 0;
    412  }  }
    413    
    414    static int iskernel(enum lineType_e type) {
    415        return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    416    }
    417    
    418    static int isinitrd(enum lineType_e type) {
    419        return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
    420    }
    421    
    422  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
    423      char * current;      char * current;
    424      char * current_indent;      char * current_indent;
    # Line 328  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 482  struct configFileInfo ziplConfigType = { Line 632  struct configFileInfo ziplConfigType = {
    632  struct configFileInfo extlinuxConfigType = {  struct configFileInfo extlinuxConfigType = {
    633      .defaultConfig = "/boot/extlinux/extlinux.conf",      .defaultConfig = "/boot/extlinux/extlinux.conf",
    634      .keywords = extlinuxKeywords,      .keywords = extlinuxKeywords,
    635        .caseInsensitive = 1,
    636      .entryStart = LT_TITLE,      .entryStart = LT_TITLE,
    637      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    638      .maxTitleLength = 255,      .maxTitleLength = 255,
    639      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    640        .defaultIsUnquoted = 1,
    641  };  };
    642    
    643  struct grubConfig {  struct grubConfig {
    # Line 506  struct singleEntry * findEntryByIndex(st Line 658  struct singleEntry * findEntryByIndex(st
    658  struct singleEntry * findEntryByPath(struct grubConfig * cfg,  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
    659       const char * path, const char * prefix,       const char * path, const char * prefix,
    660       int * index);       int * index);
    661    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    662          int * index);
    663  static int readFile(int fd, char ** bufPtr);  static int readFile(int fd, char ** bufPtr);
    664  static void lineInit(struct singleLine * line);  static void lineInit(struct singleLine * line);
    665  struct singleLine * lineDup(struct singleLine * line);  struct singleLine * lineDup(struct singleLine * line);
    # Line 570  static char * sdupprintf(const char *for Line 724  static char * sdupprintf(const char *for
    724      return buf;      return buf;
    725  }  }
    726    
    727    static enum lineType_e preferredLineType(enum lineType_e type,
    728     struct configFileInfo *cfi) {
    729        if (isEfi && cfi == &grub2ConfigType) {
    730     switch (type) {
    731     case LT_KERNEL:
    732        return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
    733     case LT_INITRD:
    734        return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
    735     default:
    736        return type;
    737     }
    738    #if defined(__i386__) || defined(__x86_64__)
    739        } else if (cfi == &grub2ConfigType) {
    740     switch (type) {
    741     case LT_KERNEL:
    742        return LT_KERNEL_16;
    743     case LT_INITRD:
    744        return LT_INITRD_16;
    745     default:
    746        return type;
    747     }
    748    #endif
    749        }
    750        return type;
    751    }
    752    
    753  static struct keywordTypes * getKeywordByType(enum lineType_e type,  static struct keywordTypes * getKeywordByType(enum lineType_e type,
    754        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    755      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
    # Line 603  static char * getuuidbydev(char *device) Line 783  static char * getuuidbydev(char *device)
    783  static enum lineType_e getTypeByKeyword(char * keyword,  static enum lineType_e getTypeByKeyword(char * keyword,
    784   struct configFileInfo * cfi) {   struct configFileInfo * cfi) {
    785      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
    786   if (!strcmp(keyword, kw->key))   if (cfi->caseInsensitive) {
    787      return kw->type;      if (!strcasecmp(keyword, kw->key))
    788                    return kw->type;
    789     } else {
    790        if (!strcmp(keyword, kw->key))
    791            return kw->type;
    792     }
    793      }      }
    794      return LT_UNKNOWN;      return LT_UNKNOWN;
    795  }  }
    # Line 643  static int isEntryStart(struct singleLin Line 828  static int isEntryStart(struct singleLin
    828  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
    829  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct singleLine * line) {
    830      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it (leaks a byte) */
    831      char * title;      char * title = NULL;
    832      title = strdup(line->elements[0].item);      if (line->type == LT_TITLE) {
    833      title++;   title = strdup(line->elements[0].item);
    834      *(title + strlen(title) - 1) = '\0';   title++;
    835     *(title + strlen(title) - 1) = '\0';
    836        } else if (line->type == LT_MENUENTRY)
    837     title = strdup(line->elements[1].item);
    838        else
    839     return NULL;
    840      return title;      return title;
    841  }  }
    842    
    # Line 904  static int getNextLine(char ** bufPtr, s Line 1094  static int getNextLine(char ** bufPtr, s
    1094      return 0;      return 0;
    1095  }  }
    1096    
    1097    static int isnumber(const char *s)
    1098    {
    1099        int i;
    1100        for (i = 0; s[i] != '\0'; i++)
    1101     if (s[i] < '0' || s[i] > '9')
    1102        return 0;
    1103        return i;
    1104    }
    1105    
    1106  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1107        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1108      int in;      int in;
    # Line 918  static struct grubConfig * readConfig(co Line 1117  static struct grubConfig * readConfig(co
    1117      int len;      int len;
    1118      char * buf;      char * buf;
    1119    
    1120      if (!strcmp(inName, "-")) {      if (inName == NULL) {
    1121            printf("Could not find bootloader configuration\n");
    1122            exit(1);
    1123        } else if (!strcmp(inName, "-")) {
    1124   in = 0;   in = 0;
    1125      } else {      } else {
    1126   if ((in = open(inName, O_RDONLY)) < 0) {   if ((in = open(inName, O_RDONLY)) < 0) {
    # Line 985  static struct grubConfig * readConfig(co Line 1187  static struct grubConfig * readConfig(co
    1187      dbgPrintf("\n");      dbgPrintf("\n");
    1188      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
    1189      if (kwType && line->numElements == 3 &&      if (kwType && line->numElements == 3 &&
    1190      !strcmp(line->elements[1].item, kwType->key)) {      !strcmp(line->elements[1].item, kwType->key) &&
    1191        !is_special_grub2_variable(line->elements[2].item)) {
    1192   dbgPrintf("Line sets default config\n");   dbgPrintf("Line sets default config\n");
    1193   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1194   defaultLine = line;   defaultLine = line;
    1195      }      }
      } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
         cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
         defaultLine = line;  
    1196    
    1197          } else if (line->type == LT_KERNEL) {          } else if (iskernel(line->type)) {
    1198      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
    1199       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
    1200       * instead of LT_KERNEL now       * instead of LT_KERNEL now
    1201       */       */
    1202      if (entry->multiboot)      if (entry && entry->multiboot)
    1203   line->type = LT_HYPER;   line->type = LT_HYPER;
    1204    
    1205          } else if (line->type == LT_MBMODULE) {          } else if (line->type == LT_MBMODULE) {
    # Line 1011  static struct grubConfig * readConfig(co Line 1211  static struct grubConfig * readConfig(co
    1211      for (struct singleLine *l = entry->lines; l; l = l->next) {      for (struct singleLine *l = entry->lines; l; l = l->next) {
    1212   if (l->type == LT_HYPER)   if (l->type == LT_HYPER)
    1213      break;      break;
    1214   else if (l->type == LT_KERNEL) {   else if (iskernel(l->type)) {
    1215      l->type = LT_HYPER;      l->type = LT_HYPER;
    1216      break;      break;
    1217   }   }
    # Line 1025  static struct grubConfig * readConfig(co Line 1225  static struct grubConfig * readConfig(co
    1225      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
    1226      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
    1227    
    1228   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
    1229      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
    1230        /* make the title/default a single argument (undoing our parsing) */
    1231      len = 0;      len = 0;
    1232      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1233   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1133  static struct grubConfig * readConfig(co Line 1334  static struct grubConfig * readConfig(co
    1334      }      }
    1335   }   }
    1336    
    1337     if (line->type == LT_DEFAULT && line->numElements == 2) {
    1338        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1339        defaultLine = line;
    1340     }
    1341    
    1342   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
    1343     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
    1344     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
    # Line 1190  static struct grubConfig * readConfig(co Line 1396  static struct grubConfig * readConfig(co
    1396          if (defaultLine->numElements > 2 &&          if (defaultLine->numElements > 2 &&
    1397      cfi->defaultSupportSaved &&      cfi->defaultSupportSaved &&
    1398      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
    1399      cfg->defaultImage = DEFAULT_SAVED_GRUB2;   cfg->cfi->defaultIsSaved = 1;
    1400     cfg->defaultImage = DEFAULT_SAVED_GRUB2;
    1401     if (cfg->cfi->getEnv) {
    1402        char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1403        if (defTitle) {
    1404     int index = 0;
    1405     if (isnumber(defTitle)) {
    1406        index = atoi(defTitle);
    1407        entry = findEntryByIndex(cfg, index);
    1408     } else {
    1409        entry = findEntryByTitle(cfg, defTitle, &index);
    1410     }
    1411     if (entry)
    1412        cfg->defaultImage = index;
    1413        }
    1414     }
    1415   } else if (cfi->defaultIsVariable) {   } else if (cfi->defaultIsVariable) {
    1416      char *value = defaultLine->elements[2].item;      char *value = defaultLine->elements[2].item;
    1417      while (*value && (*value == '"' || *value == '\'' ||      while (*value && (*value == '"' || *value == '\'' ||
    # Line 1231  static struct grubConfig * readConfig(co Line 1452  static struct grubConfig * readConfig(co
    1452          cfg->defaultImage = -1;          cfg->defaultImage = -1;
    1453      }      }
    1454   }   }
    1455        } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
    1456     char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1457     if (defTitle) {
    1458        int index = 0;
    1459        if (isnumber(defTitle)) {
    1460     index = atoi(defTitle);
    1461     entry = findEntryByIndex(cfg, index);
    1462        } else {
    1463     entry = findEntryByTitle(cfg, defTitle, &index);
    1464        }
    1465        if (entry)
    1466     cfg->defaultImage = index;
    1467     }
    1468      } else {      } else {
    1469          cfg->defaultImage = 0;          cfg->defaultImage = 0;
    1470      }      }
    # Line 1248  static void writeDefault(FILE * out, cha Line 1482  static void writeDefault(FILE * out, cha
    1482    
    1483      if (cfg->defaultImage == DEFAULT_SAVED)      if (cfg->defaultImage == DEFAULT_SAVED)
    1484   fprintf(out, "%sdefault%ssaved\n", indent, separator);   fprintf(out, "%sdefault%ssaved\n", indent, separator);
    1485      else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)      else if (cfg->cfi->defaultIsSaved) {
    1486   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
    1487      else if (cfg->defaultImage > -1) {   if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
    1488        char *title;
    1489        entry = findEntryByIndex(cfg, cfg->defaultImage);
    1490        line = getLineByType(LT_MENUENTRY, entry->lines);
    1491        if (!line)
    1492     line = getLineByType(LT_TITLE, entry->lines);
    1493        if (line) {
    1494     title = extractTitle(line);
    1495     if (title)
    1496        cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
    1497        }
    1498     }
    1499        } else if (cfg->defaultImage > -1) {
    1500   if (cfg->cfi->defaultIsIndex) {   if (cfg->cfi->defaultIsIndex) {
    1501      if (cfg->cfi->defaultIsVariable) {      if (cfg->cfi->defaultIsVariable) {
    1502          fprintf(out, "%sset default=\"%d\"\n", indent,          fprintf(out, "%sset default=\"%d\"\n", indent,
    # Line 1310  static int writeConfig(struct grubConfig Line 1556  static int writeConfig(struct grubConfig
    1556    
    1557      /* most likely the symlink is relative, so change our      /* most likely the symlink is relative, so change our
    1558         directory to the dir of the symlink */         directory to the dir of the symlink */
    1559              rc = chdir(dirname(outName));      char *dir = strdupa(outName);
    1560        rc = chdir(dirname(dir));
    1561      do {      do {
    1562   buf = alloca(len + 1);   buf = alloca(len + 1);
    1563   rc = readlink(basename(outName), buf, len);   rc = readlink(basename(outName), buf, len);
    # Line 1352  static int writeConfig(struct grubConfig Line 1599  static int writeConfig(struct grubConfig
    1599      while (line) {      while (line) {
    1600          if (line->type == LT_SET_VARIABLE && defaultKw &&          if (line->type == LT_SET_VARIABLE && defaultKw &&
    1601   line->numElements == 3 &&   line->numElements == 3 &&
    1602   !strcmp(line->elements[1].item, defaultKw->key)) {   !strcmp(line->elements[1].item, defaultKw->key) &&
    1603     !is_special_grub2_variable(line->elements[2].item)) {
    1604      writeDefault(out, line->indent, line->elements[0].indent, cfg);      writeDefault(out, line->indent, line->elements[0].indent, cfg);
    1605      needs &= ~MAIN_DEFAULT;      needs &= ~MAIN_DEFAULT;
    1606   } else if (line->type == LT_DEFAULT) {   } else if (line->type == LT_DEFAULT) {
    # Line 1497  static char *findDiskForRoot() Line 1745  static char *findDiskForRoot()
    1745      return NULL;      return NULL;
    1746  }  }
    1747    
    1748  void printEntry(struct singleEntry * entry) {  void printEntry(struct singleEntry * entry, FILE *f) {
    1749      int i;      int i;
    1750      struct singleLine * line;      struct singleLine * line;
    1751    
    1752      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    1753   fprintf(stderr, "DBG: %s", line->indent);   log_message(f, "DBG: %s", line->indent);
    1754   for (i = 0; i < line->numElements; i++) {   for (i = 0; i < line->numElements; i++) {
    1755      /* Need to handle this, because we strip the quotes from      /* Need to handle this, because we strip the quotes from
    1756       * menuentry when read it. */       * menuentry when read it. */
    1757      if (line->type == LT_MENUENTRY && i == 1) {      if (line->type == LT_MENUENTRY && i == 1) {
    1758   if(!isquote(*line->elements[i].item))   if(!isquote(*line->elements[i].item))
    1759      fprintf(stderr, "\'%s\'", line->elements[i].item);      log_message(f, "\'%s\'", line->elements[i].item);
    1760   else   else
    1761      fprintf(stderr, "%s", line->elements[i].item);      log_message(f, "%s", line->elements[i].item);
    1762   fprintf(stderr, "%s", line->elements[i].indent);   log_message(f, "%s", line->elements[i].indent);
    1763    
    1764   continue;   continue;
    1765      }      }
    1766            
    1767      fprintf(stderr, "%s%s",      log_message(f, "%s%s",
    1768      line->elements[i].item, line->elements[i].indent);      line->elements[i].item, line->elements[i].indent);
    1769   }   }
    1770   fprintf(stderr, "\n");   log_message(f, "\n");
    1771      }      }
    1772  }  }
    1773    
    1774  void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)  void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
    1775  {  {
    1776      va_list argp;      static int once;
    1777        va_list argp, argq;
    1778    
    1779        va_start(argp, fmt);
    1780    
    1781      if (!debug)      va_copy(argq, argp);
    1782        if (!once) {
    1783     log_time(NULL);
    1784     log_message(NULL, "command line: %s\n", saved_command_line);
    1785        }
    1786        log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
    1787        log_vmessage(NULL, fmt, argq);
    1788    
    1789        printEntry(entry, NULL);
    1790        va_end(argq);
    1791    
    1792        if (!debug) {
    1793     once = 1;
    1794         va_end(argp);
    1795   return;   return;
    1796        }
    1797    
    1798      va_start(argp, fmt);      if (okay) {
    1799     va_end(argp);
    1800     return;
    1801        }
    1802    
    1803        if (!once)
    1804     log_message(stderr, "DBG: command line: %s\n", saved_command_line);
    1805        once = 1;
    1806      fprintf(stderr, "DBG: Image entry failed: ");      fprintf(stderr, "DBG: Image entry failed: ");
    1807      vfprintf(stderr, fmt, argp);      vfprintf(stderr, fmt, argp);
    1808      printEntry(entry);      printEntry(entry, stderr);
    1809      va_end(argp);      va_end(argp);
    1810  }  }
    1811    
    # Line 1560  int suitableImage(struct singleEntry * e Line 1832  int suitableImage(struct singleEntry * e
    1832      char * rootdev;      char * rootdev;
    1833    
    1834      if (skipRemoved && entry->skip) {      if (skipRemoved && entry->skip) {
    1835   notSuitablePrintf(entry, "marked to skip\n");   notSuitablePrintf(entry, 0, "marked to skip\n");
    1836   return 0;   return 0;
    1837      }      }
    1838    
    1839      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1840      if (!line) {      if (!line) {
    1841   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1842   return 0;   return 0;
    1843      }      }
    1844      if (line->numElements < 2) {      if (line->numElements < 2) {
    1845   notSuitablePrintf(entry, "line has only %d elements\n",   notSuitablePrintf(entry, 0, "line has only %d elements\n",
    1846      line->numElements);      line->numElements);
    1847   return 0;   return 0;
    1848      }      }
    1849    
    1850      if (flags & GRUBBY_BADIMAGE_OKAY) return 1;      if (flags & GRUBBY_BADIMAGE_OKAY) {
    1851        notSuitablePrintf(entry, 1, "\n");
    1852        return 1;
    1853        }
    1854    
    1855      fullName = alloca(strlen(bootPrefix) +      fullName = alloca(strlen(bootPrefix) +
    1856        strlen(line->elements[1].item) + 1);        strlen(line->elements[1].item) + 1);
    # Line 1586  int suitableImage(struct singleEntry * e Line 1861  int suitableImage(struct singleEntry * e
    1861      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
    1862              line->elements[1].item + rootspec_offset);              line->elements[1].item + rootspec_offset);
    1863      if (access(fullName, R_OK)) {      if (access(fullName, R_OK)) {
    1864   notSuitablePrintf(entry, "access to %s failed\n", fullName);   notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
    1865   return 0;   return 0;
    1866      }      }
    1867      for (i = 2; i < line->numElements; i++)      for (i = 2; i < line->numElements; i++)
    # Line 1607  int suitableImage(struct singleEntry * e Line 1882  int suitableImage(struct singleEntry * e
    1882    
    1883              /* failed to find one */              /* failed to find one */
    1884              if (!line) {              if (!line) {
    1885   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1886   return 0;   return 0;
    1887              }              }
    1888    
    # Line 1616  int suitableImage(struct singleEntry * e Line 1891  int suitableImage(struct singleEntry * e
    1891      if (i < line->numElements)      if (i < line->numElements)
    1892          dev = line->elements[i].item + 5;          dev = line->elements[i].item + 5;
    1893      else {      else {
    1894   notSuitablePrintf(entry, "no root= entry found\n");   notSuitablePrintf(entry, 0, "no root= entry found\n");
    1895   /* it failed too...  can't find root= */   /* it failed too...  can't find root= */
    1896          return 0;          return 0;
    1897              }              }
    # Line 1625  int suitableImage(struct singleEntry * e Line 1900  int suitableImage(struct singleEntry * e
    1900    
    1901      dev = getpathbyspec(dev);      dev = getpathbyspec(dev);
    1902      if (!getpathbyspec(dev)) {      if (!getpathbyspec(dev)) {
    1903          notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);          notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
    1904          return 0;          return 0;
    1905      } else      } else
    1906   dev = getpathbyspec(dev);   dev = getpathbyspec(dev);
    1907    
    1908      rootdev = findDiskForRoot();      rootdev = findDiskForRoot();
    1909      if (!rootdev) {      if (!rootdev) {
    1910          notSuitablePrintf(entry, "can't find root device\n");          notSuitablePrintf(entry, 0, "can't find root device\n");
    1911   return 0;   return 0;
    1912      }      }
    1913    
    1914      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
    1915          notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
    1916   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1917          free(rootdev);          free(rootdev);
    1918          return 0;          return 0;
    1919      }      }
    1920    
    1921      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
    1922          notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
    1923   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1924   free(rootdev);   free(rootdev);
    1925          return 0;          return 0;
    1926      }      }
    1927    
    1928      free(rootdev);      free(rootdev);
    1929        notSuitablePrintf(entry, 1, "\n");
    1930    
    1931      return 1;      return 1;
    1932  }  }
    # Line 1694  struct singleEntry * findEntryByPath(str Line 1970  struct singleEntry * findEntryByPath(str
    1970   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1971   if (!entry) return NULL;   if (!entry) return NULL;
    1972    
    1973   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1974   if (!line) return NULL;   if (!line) return NULL;
    1975    
    1976   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1743  struct singleEntry * findEntryByPath(str Line 2019  struct singleEntry * findEntryByPath(str
    2019    
    2020      /* check all the lines matching checkType */      /* check all the lines matching checkType */
    2021      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2022   line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?   enum lineType_e ct = checkType;
    2023       LT_KERNEL|LT_MBMODULE|LT_HYPER :   if (entry->multiboot && checkType == LT_KERNEL)
    2024       checkType, line);      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2025   if (!line) break;  /* not found in this entry */   else if (checkType & LT_KERNEL)
    2026        ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2027     line = getLineByType(ct, line);
    2028     if (!line)
    2029        break;  /* not found in this entry */
    2030    
    2031   if (line && line->type != LT_MENUENTRY &&   if (line && line->type != LT_MENUENTRY &&
    2032   line->numElements >= 2) {   line->numElements >= 2) {
    # Line 1765  struct singleEntry * findEntryByPath(str Line 2045  struct singleEntry * findEntryByPath(str
    2045       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2046       * unfortunate)       * unfortunate)
    2047       */       */
    2048      if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
    2049   break; /* found 'im! */   break; /* found 'im! */
    2050   }   }
    2051    
    # Line 1775  struct singleEntry * findEntryByPath(str Line 2055  struct singleEntry * findEntryByPath(str
    2055      return entry;      return entry;
    2056  }  }
    2057    
    2058    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    2059          int * index) {
    2060        struct singleEntry * entry;
    2061        struct singleLine * line;
    2062        int i;
    2063        char * newtitle;
    2064    
    2065        for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
    2066     if (index && i < *index)
    2067        continue;
    2068     line = getLineByType(LT_TITLE, entry->lines);
    2069     if (!line)
    2070        line = getLineByType(LT_MENUENTRY, entry->lines);
    2071     if (!line)
    2072        continue;
    2073     newtitle = grub2ExtractTitle(line);
    2074     if (!newtitle)
    2075        continue;
    2076     if (!strcmp(title, newtitle))
    2077        break;
    2078        }
    2079    
    2080        if (!entry)
    2081     return NULL;
    2082    
    2083        if (index)
    2084     *index = i;
    2085        return entry;
    2086    }
    2087    
    2088  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
    2089      struct singleEntry * entry;      struct singleEntry * entry;
    2090    
    # Line 1797  struct singleEntry * findTemplate(struct Line 2107  struct singleEntry * findTemplate(struct
    2107      struct singleEntry * entry, * entry2;      struct singleEntry * entry, * entry2;
    2108      int index;      int index;
    2109    
    2110      if (cfg->defaultImage > -1) {      if (cfg->cfi->defaultIsSaved) {
    2111     if (cfg->cfi->getEnv) {
    2112        char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2113        if (defTitle) {
    2114     int index = 0;
    2115     if (isnumber(defTitle)) {
    2116        index = atoi(defTitle);
    2117        entry = findEntryByIndex(cfg, index);
    2118     } else {
    2119        entry = findEntryByTitle(cfg, defTitle, &index);
    2120     }
    2121     if (entry)
    2122        cfg->defaultImage = index;
    2123        }
    2124     }
    2125        } else if (cfg->defaultImage > -1) {
    2126   entry = findEntryByIndex(cfg, cfg->defaultImage);   entry = findEntryByIndex(cfg, cfg->defaultImage);
    2127   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2128      if (indexPtr) *indexPtr = cfg->defaultImage;      if (indexPtr) *indexPtr = cfg->defaultImage;
    # Line 1867  void markRemovedImage(struct grubConfig Line 2192  void markRemovedImage(struct grubConfig
    2192    
    2193  void setDefaultImage(struct grubConfig * config, int hasNew,  void setDefaultImage(struct grubConfig * config, int hasNew,
    2194       const char * defaultKernelPath, int newIsDefault,       const char * defaultKernelPath, int newIsDefault,
    2195       const char * prefix, int flags) {       const char * prefix, int flags, int index) {
    2196      struct singleEntry * entry, * entry2, * newDefault;      struct singleEntry * entry, * entry2, * newDefault;
    2197      int i, j;      int i, j;
    2198    
    2199      if (newIsDefault) {      if (newIsDefault) {
    2200   config->defaultImage = 0;   config->defaultImage = 0;
    2201   return;   return;
    2202        } else if ((index >= 0) && config->cfi->defaultIsIndex) {
    2203     if (findEntryByIndex(config, index))
    2204        config->defaultImage = index;
    2205     else
    2206        config->defaultImage = -1;
    2207     return;
    2208      } else if (defaultKernelPath) {      } else if (defaultKernelPath) {
    2209   i = 0;   i = 0;
    2210   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
    # Line 1945  void displayEntry(struct singleEntry * e Line 2276  void displayEntry(struct singleEntry * e
    2276      struct singleLine * line;      struct singleLine * line;
    2277      char * root = NULL;      char * root = NULL;
    2278      int i;      int i;
    2279        int j;
    2280    
    2281      printf("index=%d\n", index);      printf("index=%d\n", index);
    2282    
    2283      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    2284      if (!line) {      if (!line) {
    2285          printf("non linux entry\n");          printf("non linux entry\n");
    2286          return;          return;
    # Line 2013  void displayEntry(struct singleEntry * e Line 2345  void displayEntry(struct singleEntry * e
    2345   printf("root=%s\n", s);   printf("root=%s\n", s);
    2346      }      }
    2347    
    2348      line = getLineByType(LT_INITRD, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2349    
    2350      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2351   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2036  void displayEntry(struct singleEntry * e Line 2368  void displayEntry(struct singleEntry * e
    2368   if (title)   if (title)
    2369      printf("title=%s\n", title);      printf("title=%s\n", title);
    2370      }      }
    2371    
    2372        for (j = 0, line = entry->lines; line; line = line->next) {
    2373     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2374        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2375     printf("mbmodule%d=", j);
    2376        else
    2377     printf("mbmodule%d=%s", j, prefix);
    2378    
    2379        for (i = 1; i < line->numElements; i++)
    2380     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2381        printf("\n");
    2382        j++;
    2383     }
    2384        }
    2385  }  }
    2386    
    2387  int isSuseSystem(void) {  int isSuseSystem(void) {
    # Line 2350  void dumpSysconfigGrub(void) { Line 2696  void dumpSysconfigGrub(void) {
    2696      char * boot = NULL;      char * boot = NULL;
    2697      int lba;      int lba;
    2698    
    2699      if (!isSuseSystem()) {      if (isSuseSystem()) {
    2700          if (parseSysconfigGrub(&lba, &boot)) {          if (parseSuseGrubConf(&lba, &boot)) {
    2701      free(boot);      free(boot);
    2702      return;      return;
    2703   }   }
    2704      } else {      } else {
    2705          if (parseSuseGrubConf(&lba, &boot)) {          if (parseSysconfigGrub(&lba, &boot)) {
    2706      free(boot);      free(boot);
    2707      return;      return;
    2708   }   }
    # Line 2414  struct singleLine * addLineTmpl(struct s Line 2760  struct singleLine * addLineTmpl(struct s
    2760  {  {
    2761      struct singleLine * newLine = lineDup(tmplLine);      struct singleLine * newLine = lineDup(tmplLine);
    2762    
    2763        if (isEfi && cfi == &grub2ConfigType) {
    2764     enum lineType_e old = newLine->type;
    2765     newLine->type = preferredLineType(newLine->type, cfi);
    2766     if (old != newLine->type)
    2767        newLine->elements[0].item = getKeyByType(newLine->type, cfi);
    2768        }
    2769    
    2770      if (val) {      if (val) {
    2771   /* override the inherited value with our own.   /* override the inherited value with our own.
    2772   * This is a little weak because it only applies to elements[1]   * This is a little weak because it only applies to elements[1]
    # Line 2423  struct singleLine * addLineTmpl(struct s Line 2776  struct singleLine * addLineTmpl(struct s
    2776   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2777    
    2778   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2779   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
    2780      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2781      if (rootspec != NULL) {      if (rootspec != NULL) {
    2782   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 2460  struct singleLine *  addLine(struct sing Line 2813  struct singleLine *  addLine(struct sing
    2813      /* NB: This function shouldn't allocate items on the heap, rather on the      /* NB: This function shouldn't allocate items on the heap, rather on the
    2814       * stack since it calls addLineTmpl which will make copies.       * stack since it calls addLineTmpl which will make copies.
    2815       */       */
       
    2816      if (type == LT_TITLE && cfi->titleBracketed) {      if (type == LT_TITLE && cfi->titleBracketed) {
    2817   /* we're doing a bracketed title (zipl) */   /* we're doing a bracketed title (zipl) */
    2818   tmpl.type = type;   tmpl.type = type;
    # Line 2794  int updateActualImage(struct grubConfig Line 3146  int updateActualImage(struct grubConfig
    3146      firstElement = 2;      firstElement = 2;
    3147    
    3148   } else {   } else {
    3149      line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3150      if (!line) {      if (!line) {
    3151   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3152   continue;   continue;
    # Line 2950  int updateImage(struct grubConfig * cfg, Line 3302  int updateImage(struct grubConfig * cfg,
    3302      return rc;      return rc;
    3303  }  }
    3304    
    3305    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3306     const char * image, const char * prefix, const char * initrd) {
    3307        struct singleEntry * entry;
    3308        struct singleLine * line, * kernelLine, *endLine = NULL;
    3309        int index = 0;
    3310    
    3311        if (!image) return 0;
    3312    
    3313        for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {
    3314            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3315            if (!kernelLine) continue;
    3316    
    3317            if (prefix) {
    3318                int prefixLen = strlen(prefix);
    3319                if (!strncmp(initrd, prefix, prefixLen))
    3320                    initrd += prefixLen;
    3321            }
    3322     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3323     if (endLine)
    3324        removeLine(entry, endLine);
    3325            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3326     kernelLine->indent, initrd);
    3327            if (!line)
    3328        return 1;
    3329     if (endLine) {
    3330        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3331                if (!line)
    3332     return 1;
    3333     }
    3334    
    3335            break;
    3336        }
    3337    
    3338        return 0;
    3339    }
    3340    
    3341  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3342                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd) {
    3343      struct singleEntry * entry;      struct singleEntry * entry;
    # Line 2959  int updateInitrd(struct grubConfig * cfg Line 3347  int updateInitrd(struct grubConfig * cfg
    3347      if (!image) return 0;      if (!image) return 0;
    3348    
    3349      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3350          kernelLine = getLineByType(LT_KERNEL, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3351          if (!kernelLine) continue;          if (!kernelLine) continue;
    3352    
    3353          line = getLineByType(LT_INITRD, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3354          if (line)          if (line)
    3355              removeLine(entry, line);              removeLine(entry, line);
    3356          if (prefix) {          if (prefix) {
    # Line 2973  int updateInitrd(struct grubConfig * cfg Line 3361  int updateInitrd(struct grubConfig * cfg
    3361   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3362   if (endLine)   if (endLine)
    3363      removeLine(entry, endLine);      removeLine(entry, endLine);
    3364          line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);   enum lineType_e lt;
    3365     switch(kernelLine->type) {
    3366        case LT_KERNEL:
    3367            lt = LT_INITRD;
    3368     break;
    3369        case LT_KERNEL_EFI:
    3370            lt = LT_INITRD_EFI;
    3371     break;
    3372        case LT_KERNEL_16:
    3373            lt = LT_INITRD_16;
    3374     break;
    3375        default:
    3376            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3377     }
    3378            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3379          if (!line)          if (!line)
    3380      return 1;      return 1;
    3381   if (endLine) {   if (endLine) {
    # Line 3179  int checkForGrub(struct grubConfig * con Line 3581  int checkForGrub(struct grubConfig * con
    3581      int fd;      int fd;
    3582      unsigned char bootSect[512];      unsigned char bootSect[512];
    3583      char * boot;      char * boot;
    3584      int onSuse;      int onSuse = isSuseSystem();
    3585    
    3586      onSuse = isSuseSystem();  
    3587      if (!onSuse) {      if (onSuse) {
    3588   if (parseSysconfigGrub(NULL, &boot)) return 0;   if (parseSuseGrubConf(NULL, &boot))
    3589        return 0;
    3590      } else {      } else {
    3591   if (parseSuseGrubConf(NULL, &boot)) return 0;   if (parseSysconfigGrub(NULL, &boot))
    3592        return 0;
    3593      }      }
    3594    
    3595      /* assume grub is not installed -- not an error condition */      /* assume grub is not installed -- not an error condition */
    # Line 3205  int checkForGrub(struct grubConfig * con Line 3609  int checkForGrub(struct grubConfig * con
    3609      }      }
    3610      close(fd);      close(fd);
    3611    
    3612      if (!onSuse)      /* The more elaborate checks do not work on SuSE. The checks done
    3613   return checkDeviceBootloader(boot, bootSect);       * seem to be reasonble (at least for now), so just return success
    3614      else       */
    3615   /*      if (onSuse)
      * The more elaborate checks do not work on SuSE. The checks done  
      * seem to be reasonble (at least for now), so just return success  
      */  
    3616   return 2;   return 2;
    3617    
    3618        return checkDeviceBootloader(boot, bootSect);
    3619  }  }
    3620    
    3621  int checkForExtLinux(struct grubConfig * config) {  int checkForExtLinux(struct grubConfig * config) {
    # Line 3245  int checkForExtLinux(struct grubConfig * Line 3648  int checkForExtLinux(struct grubConfig *
    3648      return checkDeviceBootloader(boot, bootSect);      return checkDeviceBootloader(boot, bootSect);
    3649  }  }
    3650    
    3651    int checkForYaboot(struct grubConfig * config) {
    3652        /*
    3653         * This is a simplistic check that we consider good enough for own puporses
    3654         *
    3655         * If we were to properly check if yaboot is *installed* we'd need to:
    3656         * 1) get the system boot device (LT_BOOT)
    3657         * 2) considering it's a raw filesystem, check if the yaboot binary matches
    3658         *    the content on the boot device
    3659         * 3) if not, copy the binary to a temporary file and run "addnote" on it
    3660         * 4) check again if binary and boot device contents match
    3661         */
    3662        if (!access("/etc/yaboot.conf", R_OK))
    3663     return 2;
    3664    
    3665        return 1;
    3666    }
    3667    
    3668    int checkForElilo(struct grubConfig * config) {
    3669        if (!access("/etc/elilo.conf", R_OK))
    3670     return 2;
    3671    
    3672        return 1;
    3673    }
    3674    
    3675  static char * getRootSpecifier(char * str) {  static char * getRootSpecifier(char * str) {
    3676      char * idx, * rootspec = NULL;      char * idx, * rootspec = NULL;
    3677    
    # Line 3307  int addNewKernel(struct grubConfig * con Line 3734  int addNewKernel(struct grubConfig * con
    3734   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3735   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3736   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3737                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3738     const char * newDevTreePath) {
    3739      struct singleEntry * new;      struct singleEntry * new;
    3740      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3741      int needs;      int needs;
    # Line 3348  int addNewKernel(struct grubConfig * con Line 3776  int addNewKernel(struct grubConfig * con
    3776          needs |= NEED_MB;          needs |= NEED_MB;
    3777          new->multiboot = 1;          new->multiboot = 1;
    3778      }      }
    3779        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3780     needs |= NEED_DEVTREE;
    3781    
    3782      if (template) {      if (template) {
    3783   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3361  int addNewKernel(struct grubConfig * con Line 3791  int addNewKernel(struct grubConfig * con
    3791      while (*chptr && isspace(*chptr)) chptr++;      while (*chptr && isspace(*chptr)) chptr++;
    3792      if (*chptr == '#') continue;      if (*chptr == '#') continue;
    3793    
    3794      if (tmplLine->type == LT_KERNEL &&      if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
         tmplLine->numElements >= 2) {  
    3795   if (!template->multiboot && (needs & NEED_MB)) {   if (!template->multiboot && (needs & NEED_MB)) {
    3796      /* it's not a multiboot template and this is the kernel      /* it's not a multiboot template and this is the kernel
    3797       * line.  Try to be intelligent about inserting the       * line.  Try to be intelligent about inserting the
    # Line 3439  int addNewKernel(struct grubConfig * con Line 3868  int addNewKernel(struct grubConfig * con
    3868      /* template is multi but new is not,      /* template is multi but new is not,
    3869       * insert the kernel in the first module slot       * insert the kernel in the first module slot
    3870       */       */
    3871      tmplLine->type = LT_KERNEL;      tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
    3872      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
    3873      tmplLine->elements[0].item =      tmplLine->elements[0].item =
    3874   strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
    3875     config->cfi)->key);
    3876      newLine = addLineTmpl(new, tmplLine, newLine,      newLine = addLineTmpl(new, tmplLine, newLine,
    3877    newKernelPath + strlen(prefix), config->cfi);    newKernelPath + strlen(prefix),
    3878      config->cfi);
    3879      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
    3880   } else if (needs & NEED_INITRD) {   } else if (needs & NEED_INITRD) {
    3881      char *initrdVal;      char *initrdVal;
    3882      /* template is multi but new is not,      /* template is multi but new is not,
    3883       * insert the initrd in the second module slot       * insert the initrd in the second module slot
    3884       */       */
    3885      tmplLine->type = LT_INITRD;      tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
    3886      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
    3887      tmplLine->elements[0].item =      tmplLine->elements[0].item =
    3888   strdup(getKeywordByType(LT_INITRD, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
    3889     config->cfi)->key);
    3890      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
    3891      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
    3892      free(initrdVal);      free(initrdVal);
    3893      needs &= ~NEED_INITRD;      needs &= ~NEED_INITRD;
    3894   }   }
    3895    
    3896      } else if (tmplLine->type == LT_INITRD &&      } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
            tmplLine->numElements >= 2) {  
    3897   if (needs & NEED_INITRD &&   if (needs & NEED_INITRD &&
    3898      new->multiboot && !template->multiboot &&      new->multiboot && !template->multiboot &&
    3899      config->cfi->mbInitRdIsModule) {      config->cfi->mbInitRdIsModule) {
    # Line 3516  int addNewKernel(struct grubConfig * con Line 3947  int addNewKernel(struct grubConfig * con
    3947      static const char *prefix = "'Loading ";      static const char *prefix = "'Loading ";
    3948      if (tmplLine->numElements > 1 &&      if (tmplLine->numElements > 1 &&
    3949      strstr(tmplLine->elements[1].item, prefix) &&      strstr(tmplLine->elements[1].item, prefix) &&
    3950      masterLine->next && masterLine->next->type == LT_KERNEL) {      masterLine->next &&
    3951        iskernel(masterLine->next->type)) {
    3952   char *newTitle = malloc(strlen(prefix) +   char *newTitle = malloc(strlen(prefix) +
    3953   strlen(newKernelTitle) + 2);   strlen(newKernelTitle) + 2);
    3954    
    # Line 3531  int addNewKernel(struct grubConfig * con Line 3963  int addNewKernel(struct grubConfig * con
    3963   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3964   config->cfi);   config->cfi);
    3965      }      }
    3966        } else if (tmplLine->type == LT_DEVTREE &&
    3967           tmplLine->numElements == 2 && newDevTreePath) {
    3968            newLine = addLineTmpl(new, tmplLine, newLine,
    3969          newDevTreePath + strlen(prefix),
    3970          config->cfi);
    3971     needs &= ~NEED_DEVTREE;
    3972        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    3973     const char *ndtp = newDevTreePath;
    3974     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    3975        ndtp += strlen(prefix);
    3976     newLine = addLine(new, config->cfi, LT_DEVTREE,
    3977      config->secondaryIndent,
    3978      ndtp);
    3979     needs &= ~NEED_DEVTREE;
    3980     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    3981      } else {      } else {
    3982   /* pass through other lines from the template */   /* pass through other lines from the template */
    3983   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3543  int addNewKernel(struct grubConfig * con Line 3990  int addNewKernel(struct grubConfig * con
    3990   */   */
    3991   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3992      case LT_KERNEL:      case LT_KERNEL:
    3993        case LT_KERNEL_EFI:
    3994        case LT_KERNEL_16:
    3995   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    3996      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    3997   } else {   } else {
    3998      newLine = addLine(new, config->cfi, LT_KERNEL,      newLine = addLine(new, config->cfi,
    3999              preferredLineType(LT_KERNEL, config->cfi),
    4000        config->primaryIndent,        config->primaryIndent,
    4001        newKernelPath + strlen(prefix));        newKernelPath + strlen(prefix));
    4002      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
    # Line 3622  int addNewKernel(struct grubConfig * con Line 4072  int addNewKernel(struct grubConfig * con
    4072      if (needs & NEED_KERNEL) {      if (needs & NEED_KERNEL) {
    4073   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
    4074    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
    4075        config->cfi)) ?        config->cfi))
    4076    LT_MBMODULE : LT_KERNEL,     ? LT_MBMODULE
    4077     : preferredLineType(LT_KERNEL, config->cfi),
    4078    config->secondaryIndent,    config->secondaryIndent,
    4079    newKernelPath + strlen(prefix));    newKernelPath + strlen(prefix));
    4080   needs &= ~NEED_KERNEL;   needs &= ~NEED_KERNEL;
    # Line 3639  int addNewKernel(struct grubConfig * con Line 4090  int addNewKernel(struct grubConfig * con
    4090   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
    4091   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
    4092    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
    4093        config->cfi)) ?        config->cfi))
    4094    LT_MBMODULE : LT_INITRD,     ? LT_MBMODULE
    4095       : preferredLineType(LT_INITRD, config->cfi),
    4096    config->secondaryIndent,    config->secondaryIndent,
    4097    initrdVal);    initrdVal);
    4098   free(initrdVal);   free(initrdVal);
    4099   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4100      }      }
    4101        if (needs & NEED_DEVTREE) {
    4102     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4103      config->secondaryIndent,
    4104      newDevTreePath);
    4105     needs &= ~NEED_DEVTREE;
    4106        }
    4107    
    4108        /* NEEDS_END must be last on bootloaders that need it... */
    4109      if (needs & NEED_END) {      if (needs & NEED_END) {
    4110   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4111   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    4112   needs &= ~NEED_END;   needs &= ~NEED_END;
    4113      }      }
       
    4114      if (needs) {      if (needs) {
    4115   printf(_("grubby: needs=%d, aborting\n"), needs);   printf(_("grubby: needs=%d, aborting\n"), needs);
    4116   abort();   abort();
    # Line 3672  static void traceback(int signum) Line 4131  static void traceback(int signum)
    4131      memset(array, '\0', sizeof (array));      memset(array, '\0', sizeof (array));
    4132      size = backtrace(array, 40);      size = backtrace(array, 40);
    4133    
    4134      fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",      fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
    4135              (unsigned long)size);              (unsigned long)size);
    4136      backtrace_symbols_fd(array, size, STDERR_FILENO);      backtrace_symbols_fd(array, size, STDERR_FILENO);
    4137      exit(1);      exit(1);
    # Line 3697  int main(int argc, const char ** argv) { Line 4156  int main(int argc, const char ** argv) {
    4156      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4157      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4158      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4159      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4160      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4161      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4162      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 3707  int main(int argc, const char ** argv) { Line 4166  int main(int argc, const char ** argv) {
    4166      char * removeArgs = NULL;      char * removeArgs = NULL;
    4167      char * kernelInfo = NULL;      char * kernelInfo = NULL;
    4168      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
    4169        char * envPath = NULL;
    4170      const char * chptr = NULL;      const char * chptr = NULL;
    4171      struct configFileInfo * cfi = NULL;      struct configFileInfo * cfi = NULL;
    4172      struct grubConfig * config;      struct grubConfig * config;
    # Line 3715  int main(int argc, const char ** argv) { Line 4175  int main(int argc, const char ** argv) {
    4175      int displayDefault = 0;      int displayDefault = 0;
    4176      int displayDefaultIndex = 0;      int displayDefaultIndex = 0;
    4177      int displayDefaultTitle = 0;      int displayDefaultTitle = 0;
    4178        int defaultIndex = -1;
    4179      struct poptOption options[] = {      struct poptOption options[] = {
    4180   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
    4181      _("add an entry for the specified kernel"), _("kernel-path") },      _("add an entry for the specified kernel"), _("kernel-path") },
    # Line 3732  int main(int argc, const char ** argv) { Line 4193  int main(int argc, const char ** argv) {
    4193   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
    4194      _("filestystem which contains /boot directory (for testing only)"),      _("filestystem which contains /boot directory (for testing only)"),
    4195      _("bootfs") },      _("bootfs") },
    4196  #if defined(__i386__) || defined(__x86_64__)  #if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
    4197   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
    4198      _("check if lilo is installed on lilo.conf boot sector") },      _("check which bootloader is installed on boot sector") },
    4199  #endif  #endif
    4200   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
    4201      _("path to grub config file to update (\"-\" for stdin)"),      _("path to grub config file to update (\"-\" for stdin)"),
    # Line 3753  int main(int argc, const char ** argv) { Line 4214  int main(int argc, const char ** argv) {
    4214      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4215   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4216      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4217     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4218        _("device tree file for new stanza"), _("dtb-path") },
    4219   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4220      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4221     { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    4222        _("force grub2 stanzas to use efi") },
    4223     { "env", 0, POPT_ARG_STRING, &envPath, 0,
    4224        _("path for environment data"),
    4225        _("path") },
    4226   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
    4227      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
    4228   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
    # Line 3767  int main(int argc, const char ** argv) { Line 4235  int main(int argc, const char ** argv) {
    4235   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
    4236      _("initrd image for the new kernel"), _("initrd-path") },      _("initrd image for the new kernel"), _("initrd-path") },
    4237   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
    4238      _("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },      _("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
    4239   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
    4240      _("configure lilo bootloader") },      _("configure lilo bootloader") },
    4241   { "make-default", 0, 0, &makeDefault, 0,   { "make-default", 0, 0, &makeDefault, 0,
    # Line 3787  int main(int argc, const char ** argv) { Line 4255  int main(int argc, const char ** argv) {
    4255   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
    4256      _("make the first entry referencing the specified kernel "      _("make the first entry referencing the specified kernel "
    4257        "the default"), _("kernel-path") },        "the default"), _("kernel-path") },
    4258     { "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
    4259        _("make the given entry index the default entry"),
    4260        _("entry-index") },
    4261   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
    4262      _("configure silo bootloader") },      _("configure silo bootloader") },
    4263   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
    # Line 3808  int main(int argc, const char ** argv) { Line 4279  int main(int argc, const char ** argv) {
    4279    
    4280      signal(SIGSEGV, traceback);      signal(SIGSEGV, traceback);
    4281    
    4282        int i = 0;
    4283        for (int j = 1; j < argc; j++)
    4284     i += strlen(argv[j]) + 1;
    4285        saved_command_line = malloc(i);
    4286        if (!saved_command_line) {
    4287     fprintf(stderr, "grubby: %m\n");
    4288     exit(1);
    4289        }
    4290        saved_command_line[0] = '\0';
    4291        for (int j = 1; j < argc; j++) {
    4292     strcat(saved_command_line, argv[j]);
    4293     strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
    4294        }
    4295    
    4296      optCon = poptGetContext("grubby", argc, argv, options, 0);      optCon = poptGetContext("grubby", argc, argv, options, 0);
    4297      poptReadDefaultConfig(optCon, 1);      poptReadDefaultConfig(optCon, 1);
    4298    
    # Line 3851  int main(int argc, const char ** argv) { Line 4336  int main(int argc, const char ** argv) {
    4336   return 1;   return 1;
    4337      } else if (configureGrub2) {      } else if (configureGrub2) {
    4338   cfi = &grub2ConfigType;   cfi = &grub2ConfigType;
    4339     if (envPath)
    4340        cfi->envFile = envPath;
    4341      } else if (configureLilo) {      } else if (configureLilo) {
    4342   cfi = &liloConfigType;   cfi = &liloConfigType;
    4343      } else if (configureGrub) {      } else if (configureGrub) {
    # Line 3894  int main(int argc, const char ** argv) { Line 4381  int main(int argc, const char ** argv) {
    4381      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4382      }      }
    4383    
    4384      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4385    newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4386    defaultKernel || displayDefaultIndex || displayDefaultTitle)) {      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4387        (defaultIndex >= 0))) {
    4388   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
    4389    "specified option"));    "specified option"));
    4390   return 1;   return 1;
    4391      }      }
    4392    
    4393      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4394     removeKernelPath)) {     removeKernelPath)) {
    4395   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4396    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 3938  int main(int argc, const char ** argv) { Line 4426  int main(int argc, const char ** argv) {
    4426   makeDefault = 1;   makeDefault = 1;
    4427   defaultKernel = NULL;   defaultKernel = NULL;
    4428      }      }
    4429        else if (defaultKernel && (defaultIndex >= 0)) {
    4430     fprintf(stderr, _("grubby: --set-default and --set-default-index "
    4431      "may not be used together\n"));
    4432     return 1;
    4433        }
    4434    
    4435      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
    4436   fprintf(stderr, _("grubby: output file must be specified if stdin "   fprintf(stderr, _("grubby: output file must be specified if stdin "
    # Line 3946  int main(int argc, const char ** argv) { Line 4439  int main(int argc, const char ** argv) {
    4439      }      }
    4440    
    4441      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
    4442   && !kernelInfo && !bootloaderProbe && !updateKernelPath   && !kernelInfo && !bootloaderProbe && !updateKernelPath
    4443          && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {   && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
    4444     && (defaultIndex == -1)) {
    4445   fprintf(stderr, _("grubby: no action specified\n"));   fprintf(stderr, _("grubby: no action specified\n"));
    4446   return 1;   return 1;
    4447      }      }
    # Line 3974  int main(int argc, const char ** argv) { Line 4468  int main(int argc, const char ** argv) {
    4468      }      }
    4469    
    4470      if (bootloaderProbe) {      if (bootloaderProbe) {
    4471   int lrc = 0, grc = 0, gr2c = 0, erc = 0;   int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
    4472   struct grubConfig * lconfig, * gconfig;   struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
    4473    
    4474   const char *grub2config = grub2FindConfig(&grub2ConfigType);   const char *grub2config = grub2FindConfig(&grub2ConfigType);
    4475   if (grub2config) {   if (grub2config) {
    # Line 4003  int main(int argc, const char ** argv) { Line 4497  int main(int argc, const char ** argv) {
    4497   lrc = checkForLilo(lconfig);   lrc = checkForLilo(lconfig);
    4498   }   }
    4499    
    4500     if (!access(eliloConfigType.defaultConfig, F_OK)) {
    4501        econfig = readConfig(eliloConfigType.defaultConfig,
    4502     &eliloConfigType);
    4503        if (!econfig)
    4504     erc = 1;
    4505        else
    4506     erc = checkForElilo(econfig);
    4507     }
    4508    
    4509   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
    4510      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
    4511      if (!lconfig)      if (!lconfig)
    4512   erc = 1;   extrc = 1;
    4513      else      else
    4514   erc = checkForExtLinux(lconfig);   extrc = checkForExtLinux(lconfig);
    4515   }   }
    4516    
    4517   if (lrc == 1 || grc == 1 || gr2c == 1) return 1;  
    4518     if (!access(yabootConfigType.defaultConfig, F_OK)) {
    4519        yconfig = readConfig(yabootConfigType.defaultConfig,
    4520     &yabootConfigType);
    4521        if (!yconfig)
    4522     yrc = 1;
    4523        else
    4524     yrc = checkForYaboot(yconfig);
    4525     }
    4526    
    4527     if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
    4528     erc == 1)
    4529        return 1;
    4530    
    4531   if (lrc == 2) printf("lilo\n");   if (lrc == 2) printf("lilo\n");
    4532   if (gr2c == 2) printf("grub2\n");   if (gr2c == 2) printf("grub2\n");
    4533   if (grc == 2) printf("grub\n");   if (grc == 2) printf("grub\n");
    4534   if (erc == 2) printf("extlinux\n");   if (extrc == 2) printf("extlinux\n");
    4535     if (yrc == 2) printf("yaboot\n");
    4536     if (erc == 2) printf("elilo\n");
    4537    
    4538   return 0;   return 0;
    4539      }      }
    4540    
    4541        if (grubConfig == NULL) {
    4542     printf("Could not find bootloader configuration file.\n");
    4543     exit(1);
    4544        }
    4545    
    4546      config = readConfig(grubConfig, cfi);      config = readConfig(grubConfig, cfi);
    4547      if (!config) return 1;      if (!config) return 1;
    4548    
    # Line 4030  int main(int argc, const char ** argv) { Line 4552  int main(int argc, const char ** argv) {
    4552          char * rootspec;          char * rootspec;
    4553    
    4554   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4555     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4556     cfi->defaultIsSaved)
    4557        config->defaultImage = 0;
    4558   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4559   if (!entry) return 0;   if (!entry) return 0;
    4560   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4561    
    4562   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    4563   if (!line) return 0;   if (!line) return 0;
    4564    
    4565          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4048  int main(int argc, const char ** argv) { Line 4573  int main(int argc, const char ** argv) {
    4573   struct singleEntry * entry;   struct singleEntry * entry;
    4574    
    4575   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4576     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4577     cfi->defaultIsSaved)
    4578        config->defaultImage = 0;
    4579   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4580   if (!entry) return 0;   if (!entry) return 0;
    4581    
    # Line 4070  int main(int argc, const char ** argv) { Line 4598  int main(int argc, const char ** argv) {
    4598    
    4599      } else if (displayDefaultIndex) {      } else if (displayDefaultIndex) {
    4600          if (config->defaultImage == -1) return 0;          if (config->defaultImage == -1) return 0;
    4601     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4602     cfi->defaultIsSaved)
    4603        config->defaultImage = 0;
    4604          printf("%i\n", config->defaultImage);          printf("%i\n", config->defaultImage);
    4605            return 0;
    4606    
    4607      } else if (kernelInfo)      } else if (kernelInfo)
    4608   return displayInfo(config, kernelInfo, bootPrefix);   return displayInfo(config, kernelInfo, bootPrefix);
    # Line 4083  int main(int argc, const char ** argv) { Line 4615  int main(int argc, const char ** argv) {
    4615      markRemovedImage(config, removeKernelPath, bootPrefix);      markRemovedImage(config, removeKernelPath, bootPrefix);
    4616      markRemovedImage(config, removeMBKernel, bootPrefix);      markRemovedImage(config, removeMBKernel, bootPrefix);
    4617      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
    4618      bootPrefix, flags);      bootPrefix, flags, defaultIndex);
    4619      setFallbackImage(config, newKernelPath != NULL);      setFallbackImage(config, newKernelPath != NULL);
    4620      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4621                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4622      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4623              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4624                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4625     bootPrefix, newKernelInitrd))
    4626        return 1;
    4627        } else {
    4628        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4629     newKernelInitrd))
    4630     return 1;
    4631        }
    4632      }      }
    4633      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4634                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4635                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4636                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4637            
    4638    
    4639      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.1850  
    changed lines
      Added in v.2708