Magellan Linux

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

    Diff of /trunk/grubby/grubby.c

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

    revision 2257 by niro, Mon Oct 21 14:01:48 2013 UTC revision 2992 by niro, Thu Jun 30 10:35:14 2016 UTC
    # Line 60  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;  char *saved_command_line = NULL;
    70    
    71  /* comments get lumped in with indention */  /* comments get lumped in with indention */
    # Line 90  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 119  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 151  struct configFileInfo { Line 161  struct configFileInfo {
    161      int defaultIsVariable;      int defaultIsVariable;
    162      int defaultSupportSaved;      int defaultSupportSaved;
    163      int defaultIsSaved;      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 182  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 209  struct configFileInfo grubConfigType = { Line 222  struct configFileInfo grubConfigType = {
    222      .mbHyperFirst = 1,      .mbHyperFirst = 1,
    223      .mbInitRdIsModule = 1,      .mbInitRdIsModule = 1,
    224      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    225        .titlePosition = 1,
    226  };  };
    227    
    228  struct keywordTypes grub2Keywords[] = {  struct keywordTypes grub2Keywords[] = {
    # Line 221  struct keywordTypes grub2Keywords[] = { Line 235  struct keywordTypes grub2Keywords[] = {
    235      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    236      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    237      { "linuxefi",   LT_KERNEL_EFI,  ' ' },      { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    238        { "linux16",    LT_KERNEL_16,   ' ' },
    239      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    240      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
    241        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
    242      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
    243      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
    244        { "devicetree", LT_DEVTREE,  ' ' },
    245      { NULL, 0, 0 },      { NULL, 0, 0 },
    246  };  };
    247    
    # Line 273  static char *grub2GetEnv(struct configFi Line 290  static char *grub2GetEnv(struct configFi
    290      static char buf[1025];      static char buf[1025];
    291      char *s = NULL;      char *s = NULL;
    292      char *ret = NULL;      char *ret = NULL;
    293      char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";      char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    294      int rc = asprintf(&s, "grub2-editenv %s list | grep '^%s='", envFile, name);      int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
    295    
    296      if (rc < 0)      if (rc < 0)
    297   return NULL;   return NULL;
    # Line 338  static int grub2SetEnv(struct configFile Line 355  static int grub2SetEnv(struct configFile
    355  {  {
    356      char *s = NULL;      char *s = NULL;
    357      int rc = 0;      int rc = 0;
    358      char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";      char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    359    
    360      unquote(value);      unquote(value);
    361      value = shellEscape(value);      value = shellEscape(value);
    362      if (!value)      if (!value)
    363      return -1;      return -1;
    364    
    365      rc = asprintf(&s, "grub2-editenv %s set '%s=%s'", envFile, name, value);      rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
    366      free(value);      free(value);
    367      if (rc <0)      if (rc <0)
    368   return -1;   return -1;
    # Line 396  static int isquote(char q) Line 413  static int isquote(char q)
    413  }  }
    414    
    415  static int iskernel(enum lineType_e type) {  static int iskernel(enum lineType_e type) {
    416      return (type == LT_KERNEL || type == LT_KERNEL_EFI);      return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    417  }  }
    418    
    419  static int isinitrd(enum lineType_e type) {  static int isinitrd(enum lineType_e type) {
    420      return (type == LT_INITRD || type == LT_INITRD_EFI);      return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
    421  }  }
    422    
    423  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
    # Line 412  char *grub2ExtractTitle(struct singleLin Line 429  char *grub2ExtractTitle(struct singleLin
    429    
    430      /* bail out if line does not start with menuentry */      /* bail out if line does not start with menuentry */
    431      if (strcmp(line->elements[0].item, "menuentry"))      if (strcmp(line->elements[0].item, "menuentry"))
    432        return NULL;   return NULL;
    433    
    434      i = 1;      i = 1;
    435      current = line->elements[i].item;      current = line->elements[i].item;
    # Line 421  char *grub2ExtractTitle(struct singleLin Line 438  char *grub2ExtractTitle(struct singleLin
    438      /* if second word is quoted, strip the quotes and return single word */      /* if second word is quoted, strip the quotes and return single word */
    439      if (isquote(*current) && isquote(current[current_len - 1])) {      if (isquote(*current) && isquote(current[current_len - 1])) {
    440   char *tmp;   char *tmp;
    441    
    442   tmp = strdup(current);   tmp = strdup(current+1);
    443   *(tmp + current_len - 1) = '\0';   if (!tmp)
    444   return ++tmp;      return NULL;
    445     tmp[strlen(tmp)-1] = '\0';
    446     return tmp;
    447      }      }
    448    
    449      /* if no quotes, return second word verbatim */      /* if no quotes, return second word verbatim */
    # Line 435  char *grub2ExtractTitle(struct singleLin Line 454  char *grub2ExtractTitle(struct singleLin
    454       * whose last character is also quote (assuming it's the closing one) */       * whose last character is also quote (assuming it's the closing one) */
    455      int resultMaxSize;      int resultMaxSize;
    456      char * result;      char * result;
    457            /* need to ensure that ' does not match " as we search */
    458        char quote_char = *current;
    459    
    460      resultMaxSize = sizeOfSingleLine(line);      resultMaxSize = sizeOfSingleLine(line);
    461      result = malloc(resultMaxSize);      result = malloc(resultMaxSize);
    462      snprintf(result, resultMaxSize, "%s", ++current);      snprintf(result, resultMaxSize, "%s", ++current);
    463        
    464      i++;      i++;
    465      for (; i < line->numElements; ++i) {      for (; i < line->numElements; ++i) {
    466   current = line->elements[i].item;   current = line->elements[i].item;
    # Line 448  char *grub2ExtractTitle(struct singleLin Line 469  char *grub2ExtractTitle(struct singleLin
    469   current_indent_len = strlen(current_indent);   current_indent_len = strlen(current_indent);
    470    
    471   strncat(result, current_indent, current_indent_len);   strncat(result, current_indent, current_indent_len);
    472   if (!isquote(current[current_len-1])) {   if (current[current_len-1] != quote_char) {
    473      strncat(result, current, current_len);      strncat(result, current, current_len);
    474   } else {   } else {
    475      strncat(result, current, current_len - 1);      strncat(result, current, current_len - 1);
    # Line 566  struct keywordTypes extlinuxKeywords[] = Line 587  struct keywordTypes extlinuxKeywords[] =
    587      { "initrd",    LT_INITRD,      ' ', ',' },      { "initrd",    LT_INITRD,      ' ', ',' },
    588      { "append",    LT_KERNELARGS,  ' ' },      { "append",    LT_KERNELARGS,  ' ' },
    589      { "prompt",     LT_UNKNOWN,     ' ' },      { "prompt",     LT_UNKNOWN,     ' ' },
    590        { "fdt",        LT_DEVTREE,     ' ' },
    591        { "fdtdir",     LT_DEVTREE,     ' ' },
    592      { NULL,    0, 0 },      { NULL,    0, 0 },
    593  };  };
    594  int useextlinuxmenu;  int useextlinuxmenu;
    # Line 576  struct configFileInfo eliloConfigType = Line 599  struct configFileInfo eliloConfigType =
    599      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    600      .argsInQuotes = 1,      .argsInQuotes = 1,
    601      .mbConcatArgs = 1,      .mbConcatArgs = 1,
    602        .titlePosition = 1,
    603  };  };
    604    
    605  struct configFileInfo liloConfigType = {  struct configFileInfo liloConfigType = {
    # Line 584  struct configFileInfo liloConfigType = { Line 608  struct configFileInfo liloConfigType = {
    608      .entryStart = LT_KERNEL,      .entryStart = LT_KERNEL,
    609      .argsInQuotes = 1,      .argsInQuotes = 1,
    610      .maxTitleLength = 15,      .maxTitleLength = 15,
    611        .titlePosition = 1,
    612  };  };
    613    
    614  struct configFileInfo yabootConfigType = {  struct configFileInfo yabootConfigType = {
    # Line 594  struct configFileInfo yabootConfigType = Line 619  struct configFileInfo yabootConfigType =
    619      .argsInQuotes = 1,      .argsInQuotes = 1,
    620      .maxTitleLength = 15,      .maxTitleLength = 15,
    621      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    622        .titlePosition = 1,
    623  };  };
    624    
    625  struct configFileInfo siloConfigType = {  struct configFileInfo siloConfigType = {
    # Line 603  struct configFileInfo siloConfigType = { Line 629  struct configFileInfo siloConfigType = {
    629      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    630      .argsInQuotes = 1,      .argsInQuotes = 1,
    631      .maxTitleLength = 15,      .maxTitleLength = 15,
    632        .titlePosition = 1,
    633  };  };
    634    
    635  struct configFileInfo ziplConfigType = {  struct configFileInfo ziplConfigType = {
    # Line 621  struct configFileInfo extlinuxConfigType Line 648  struct configFileInfo extlinuxConfigType
    648      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    649      .maxTitleLength = 255,      .maxTitleLength = 255,
    650      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    651        .defaultIsUnquoted = 1,
    652        .titlePosition = 1,
    653  };  };
    654    
    655  struct grubConfig {  struct grubConfig {
    # Line 712  static enum lineType_e preferredLineType Line 741  static enum lineType_e preferredLineType
    741      if (isEfi && cfi == &grub2ConfigType) {      if (isEfi && cfi == &grub2ConfigType) {
    742   switch (type) {   switch (type) {
    743   case LT_KERNEL:   case LT_KERNEL:
    744      return LT_KERNEL_EFI;      return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
    745   case LT_INITRD:   case LT_INITRD:
    746      return LT_INITRD_EFI;      return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
    747   default:   default:
    748      return type;      return type;
    749   }   }
    750    #if defined(__i386__) || defined(__x86_64__)
    751        } else if (cfi == &grub2ConfigType) {
    752     switch (type) {
    753     case LT_KERNEL:
    754        return LT_KERNEL_16;
    755     case LT_INITRD:
    756        return LT_INITRD_16;
    757     default:
    758        return type;
    759     }
    760    #endif
    761      }      }
    762      return type;      return type;
    763  }  }
    # Line 798  static int isEntryStart(struct singleLin Line 838  static int isEntryStart(struct singleLin
    838  }  }
    839    
    840  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
    841  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
    842      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it */
    843      char * title = NULL;      char * title = NULL;
    844      if (line->type == LT_TITLE) {      if (line->type == LT_TITLE) {
    845   title = strdup(line->elements[0].item);   char *tmp = line->elements[cfg->cfi->titlePosition].item;
    846   title++;   if (cfg->cfi->titleBracketed) {
    847   *(title + strlen(title) - 1) = '\0';      tmp++;
    848        title = strdup(tmp);
    849        *(title + strlen(title) - 1) = '\0';
    850     } else {
    851        title = strdup(tmp);
    852     }
    853      } else if (line->type == LT_MENUENTRY)      } else if (line->type == LT_MENUENTRY)
    854   title = strdup(line->elements[1].item);   title = strdup(line->elements[1].item);
    855      else      else
    # Line 888  static int lineWrite(FILE * out, struct Line 933  static int lineWrite(FILE * out, struct
    933   /* Need to handle this, because we strip the quotes from   /* Need to handle this, because we strip the quotes from
    934   * menuentry when read it. */   * menuentry when read it. */
    935   if (line->type == LT_MENUENTRY && i == 1) {   if (line->type == LT_MENUENTRY && i == 1) {
    936      if(!isquote(*line->elements[i].item))      if(!isquote(*line->elements[i].item)) {
    937   fprintf(out, "\'%s\'", line->elements[i].item);   int substring = 0;
    938      else   /* If the line contains nested quotes, we did not strip
    939     * the "interna" quotes and we must use the right quotes
    940     * again when writing the updated file. */
    941     for (int j = i; j < line->numElements; j++) {
    942        if (strchr(line->elements[i].item, '\'') != NULL) {
    943           substring = 1;
    944           fprintf(out, "\"%s\"", line->elements[i].item);
    945           break;
    946        }
    947     }
    948     if (!substring)
    949        fprintf(out, "\'%s\'", line->elements[i].item);
    950        } else {
    951   fprintf(out, "%s", line->elements[i].item);   fprintf(out, "%s", line->elements[i].item);
    952        }
    953      fprintf(out, "%s", line->elements[i].indent);      fprintf(out, "%s", line->elements[i].indent);
    954    
    955      continue;      continue;
    # Line 1066  static int getNextLine(char ** bufPtr, s Line 1124  static int getNextLine(char ** bufPtr, s
    1124      return 0;      return 0;
    1125  }  }
    1126    
    1127    static int isnumber(const char *s)
    1128    {
    1129        int i;
    1130        for (i = 0; s[i] != '\0'; i++)
    1131     if (s[i] < '0' || s[i] > '9')
    1132        return 0;
    1133        return i;
    1134    }
    1135    
    1136  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1137        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1138      int in;      int in;
    # Line 1156  static struct grubConfig * readConfig(co Line 1223  static struct grubConfig * readConfig(co
    1223   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1224   defaultLine = line;   defaultLine = line;
    1225      }      }
      } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
         cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
         defaultLine = line;  
    1226    
    1227          } else if (iskernel(line->type)) {          } else if (iskernel(line->type)) {
    1228      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
    1229       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
    1230       * instead of LT_KERNEL now       * instead of LT_KERNEL now
    1231       */       */
    1232      if (entry->multiboot)      if (entry && entry->multiboot)
    1233   line->type = LT_HYPER;   line->type = LT_HYPER;
    1234    
    1235          } else if (line->type == LT_MBMODULE) {          } else if (line->type == LT_MBMODULE) {
    # Line 1191  static struct grubConfig * readConfig(co Line 1255  static struct grubConfig * readConfig(co
    1255      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
    1256      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
    1257    
    1258   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
    1259      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
    1260        /* make the title/default a single argument (undoing our parsing) */
    1261      len = 0;      len = 0;
    1262      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1263   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1220  static struct grubConfig * readConfig(co Line 1285  static struct grubConfig * readConfig(co
    1285      len = 0;      len = 0;
    1286      char *extras;      char *extras;
    1287      char *title;      char *title;
    1288        /* initially unseen value */
    1289        char quote_char = '\0';
    1290    
    1291      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1292   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1236  static struct grubConfig * readConfig(co Line 1303  static struct grubConfig * readConfig(co
    1303      for (int i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    1304   if (!strcmp(line->elements[i].item, "menuentry"))   if (!strcmp(line->elements[i].item, "menuentry"))
    1305      continue;      continue;
    1306   if (isquote(*line->elements[i].item))   if (isquote(*line->elements[i].item) && quote_char == '\0') {
    1307        /* ensure we properly pair off quotes */
    1308        quote_char = *line->elements[i].item;
    1309      title = line->elements[i].item + 1;      title = line->elements[i].item + 1;
    1310   else   } else {
    1311      title = line->elements[i].item;      title = line->elements[i].item;
    1312     }
    1313    
    1314   len = strlen(title);   len = strlen(title);
    1315          if (isquote(title[len-1])) {          if (title[len-1] == quote_char) {
    1316      strncat(buf, title,len-1);      strncat(buf, title,len-1);
    1317      break;      break;
    1318   } else {   } else {
    # Line 1253  static struct grubConfig * readConfig(co Line 1323  static struct grubConfig * readConfig(co
    1323    
    1324      /* get extras */      /* get extras */
    1325      int count = 0;      int count = 0;
    1326        quote_char = '\0';
    1327      for (int i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    1328   if (count >= 2) {   if (count >= 2) {
    1329      strcat(extras, line->elements[i].item);      strcat(extras, line->elements[i].item);
    # Line 1263  static struct grubConfig * readConfig(co Line 1334  static struct grubConfig * readConfig(co
    1334      continue;      continue;
    1335    
    1336   /* count ' or ", there should be two in menuentry line. */   /* count ' or ", there should be two in menuentry line. */
    1337   if (isquote(*line->elements[i].item))   if (isquote(*line->elements[i].item) && quote_char == '\0') {
    1338        /* ensure we properly pair off quotes */
    1339                quote_char = *line->elements[i].item;
    1340      count++;      count++;
    1341     }
    1342    
    1343   len = strlen(line->elements[i].item);   len = strlen(line->elements[i].item);
    1344    
    1345   if (isquote(line->elements[i].item[len -1]))   if (line->elements[i].item[len -1] == quote_char)
    1346      count++;      count++;
    1347    
    1348   /* ok, we get the final ' or ", others are extras. */   /* ok, we get the final ' or ", others are extras. */
    # Line 1299  static struct grubConfig * readConfig(co Line 1373  static struct grubConfig * readConfig(co
    1373      }      }
    1374   }   }
    1375    
    1376     if (line->type == LT_DEFAULT && line->numElements == 2) {
    1377        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1378        defaultLine = line;
    1379     }
    1380    
    1381   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
    1382     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
    1383     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
    # Line 1362  static struct grubConfig * readConfig(co Line 1441  static struct grubConfig * readConfig(co
    1441      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1442      if (defTitle) {      if (defTitle) {
    1443   int index = 0;   int index = 0;
    1444   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    1445        index = atoi(defTitle);
    1446        entry = findEntryByIndex(cfg, index);
    1447     } else {
    1448        entry = findEntryByTitle(cfg, defTitle, &index);
    1449     }
    1450   if (entry)   if (entry)
    1451      cfg->defaultImage = index;      cfg->defaultImage = index;
    1452      }      }
    # Line 1395  static struct grubConfig * readConfig(co Line 1479  static struct grubConfig * readConfig(co
    1479                                  line->elements[1].item)) break;                                  line->elements[1].item)) break;
    1480                  } else if (line) {                  } else if (line) {
    1481                      if (!strcmp(defaultLine->elements[1].item,                      if (!strcmp(defaultLine->elements[1].item,
    1482                                  extractTitle(line))) break;                                  extractTitle(cfg, line))) break;
    1483                  }                  }
    1484   i++;   i++;
    1485   entry = NULL;   entry = NULL;
    # Line 1411  static struct grubConfig * readConfig(co Line 1495  static struct grubConfig * readConfig(co
    1495   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1496   if (defTitle) {   if (defTitle) {
    1497      int index = 0;      int index = 0;
    1498      entry = findEntryByTitle(cfg, defTitle, &index);      if (isnumber(defTitle)) {
    1499     index = atoi(defTitle);
    1500     entry = findEntryByIndex(cfg, index);
    1501        } else {
    1502     entry = findEntryByTitle(cfg, defTitle, &index);
    1503        }
    1504      if (entry)      if (entry)
    1505   cfg->defaultImage = index;   cfg->defaultImage = index;
    1506   }   }
    # Line 1441  static void writeDefault(FILE * out, cha Line 1530  static void writeDefault(FILE * out, cha
    1530      if (!line)      if (!line)
    1531   line = getLineByType(LT_TITLE, entry->lines);   line = getLineByType(LT_TITLE, entry->lines);
    1532      if (line) {      if (line) {
    1533   title = extractTitle(line);   title = extractTitle(cfg, line);
    1534   if (title)   if (title)
    1535      cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);      cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
    1536      }      }
    # Line 1479  static void writeDefault(FILE * out, cha Line 1568  static void writeDefault(FILE * out, cha
    1568              else if (line && (line->numElements == 1) &&              else if (line && (line->numElements == 1) &&
    1569                       cfg->cfi->titleBracketed) {                       cfg->cfi->titleBracketed) {
    1570   fprintf(out, "%sdefault%s%s\n", indent, separator,   fprintf(out, "%sdefault%s%s\n", indent, separator,
    1571                          extractTitle(line));                          extractTitle(cfg, line));
    1572              }              }
    1573   }   }
    1574      }      }
    # Line 1786  int suitableImage(struct singleEntry * e Line 1875  int suitableImage(struct singleEntry * e
    1875   return 0;   return 0;
    1876      }      }
    1877    
    1878      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);
    1879      if (!line) {      if (!line) {
    1880   notSuitablePrintf(entry, 0, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1881   return 0;   return 0;
    # Line 1910  struct singleEntry * findEntryByPath(str Line 1999  struct singleEntry * findEntryByPath(str
    1999   }   }
    2000    
    2001   indexVars[i + 1] = -1;   indexVars[i + 1] = -1;
    2002    
    2003   i = 0;   i = 0;
    2004   if (index) {   if (index) {
    2005      while (i < *index) i++;      while (i < *index) {
    2006      if (indexVars[i] == -1) return NULL;   i++;
    2007     if (indexVars[i] == -1) return NULL;
    2008        }
    2009   }   }
    2010    
    2011   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    2012   if (!entry) return NULL;   if (!entry) return NULL;
    2013    
    2014   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    2015   if (!line) return NULL;   if (!line) return NULL;
    2016    
    2017   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1971  struct singleEntry * findEntryByPath(str Line 2062  struct singleEntry * findEntryByPath(str
    2062      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2063   enum lineType_e ct = checkType;   enum lineType_e ct = checkType;
    2064   if (entry->multiboot && checkType == LT_KERNEL)   if (entry->multiboot && checkType == LT_KERNEL)
    2065      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2066   else if (checkType & LT_KERNEL)   else if (checkType & LT_KERNEL)
    2067      ct = checkType | LT_KERNEL_EFI;      ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2068   line = getLineByType(ct, line);   line = getLineByType(ct, line);
    2069   if (!line)   if (!line)
    2070      break;  /* not found in this entry */      break;  /* not found in this entry */
    # Line 1995  struct singleEntry * findEntryByPath(str Line 2086  struct singleEntry * findEntryByPath(str
    2086       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2087       * unfortunate)       * unfortunate)
    2088       */       */
    2089      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
    2090   break; /* found 'im! */   break; /* found 'im! */
    2091   }   }
    2092    
    # Line 2062  struct singleEntry * findTemplate(struct Line 2153  struct singleEntry * findTemplate(struct
    2153      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2154      if (defTitle) {      if (defTitle) {
    2155   int index = 0;   int index = 0;
    2156   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    2157        index = atoi(defTitle);
    2158        entry = findEntryByIndex(cfg, index);
    2159     } else {
    2160        entry = findEntryByTitle(cfg, defTitle, &index);
    2161     }
    2162     if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2163        cfg->defaultImage = index;
    2164        if (indexPtr)
    2165     *indexPtr = index;
    2166        return entry;
    2167     }
    2168      }      }
    2169   }   }
    2170      } else if (cfg->defaultImage > -1) {      } else if (cfg->defaultImage > -1) {
    # Line 2219  void displayEntry(struct singleEntry * e Line 2321  void displayEntry(struct singleEntry * e
    2321      struct singleLine * line;      struct singleLine * line;
    2322      char * root = NULL;      char * root = NULL;
    2323      int i;      int i;
    2324        int j;
    2325    
    2326      printf("index=%d\n", index);      printf("index=%d\n", index);
    2327    
    2328      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    2329      if (!line) {      if (!line) {
    2330          printf("non linux entry\n");          printf("non linux entry\n");
    2331          return;          return;
    # Line 2287  void displayEntry(struct singleEntry * e Line 2390  void displayEntry(struct singleEntry * e
    2390   printf("root=%s\n", s);   printf("root=%s\n", s);
    2391      }      }
    2392    
    2393      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2394    
    2395      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2396   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2306  void displayEntry(struct singleEntry * e Line 2409  void displayEntry(struct singleEntry * e
    2409      } else {      } else {
    2410   char * title;   char * title;
    2411   line = getLineByType(LT_MENUENTRY, entry->lines);   line = getLineByType(LT_MENUENTRY, entry->lines);
    2412   title = grub2ExtractTitle(line);   if (line) {
    2413   if (title)      title = grub2ExtractTitle(line);
    2414      printf("title=%s\n", title);      if (title)
    2415     printf("title=%s\n", title);
    2416     }
    2417        }
    2418    
    2419        for (j = 0, line = entry->lines; line; line = line->next) {
    2420     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2421        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2422     printf("mbmodule%d=", j);
    2423        else
    2424     printf("mbmodule%d=%s", j, prefix);
    2425    
    2426        for (i = 1; i < line->numElements; i++)
    2427     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2428        printf("\n");
    2429        j++;
    2430     }
    2431      }      }
    2432  }  }
    2433    
    # Line 2704  struct singleLine * addLineTmpl(struct s Line 2823  struct singleLine * addLineTmpl(struct s
    2823   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2824    
    2825   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2826   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|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)) {
    2827      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2828      if (rootspec != NULL) {      if (rootspec != NULL) {
    2829   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 3074  int updateActualImage(struct grubConfig Line 3193  int updateActualImage(struct grubConfig
    3193      firstElement = 2;      firstElement = 2;
    3194    
    3195   } else {   } else {
    3196      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3197      if (!line) {      if (!line) {
    3198   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3199   continue;   continue;
    # Line 3230  int updateImage(struct grubConfig * cfg, Line 3349  int updateImage(struct grubConfig * cfg,
    3349      return rc;      return rc;
    3350  }  }
    3351    
    3352    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3353     const char * image, const char * prefix, const char * initrd,
    3354     const char * title) {
    3355        struct singleEntry * entry;
    3356        struct singleLine * line, * kernelLine, *endLine = NULL;
    3357        int index = 0;
    3358    
    3359        if (!image) return 0;
    3360    
    3361        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3362            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3363            if (!kernelLine) continue;
    3364    
    3365     /* if title is supplied, the entry's title must match it. */
    3366     if (title) {
    3367        char *linetitle;
    3368    
    3369        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3370        if (!line)
    3371     continue;
    3372    
    3373        linetitle = extractTitle(cfg, line);
    3374        if (!linetitle)
    3375     continue;
    3376        if (strcmp(title, linetitle)) {
    3377     free(linetitle);
    3378     continue;
    3379        }
    3380        free(linetitle);
    3381     }
    3382    
    3383            if (prefix) {
    3384                int prefixLen = strlen(prefix);
    3385                if (!strncmp(initrd, prefix, prefixLen))
    3386                    initrd += prefixLen;
    3387            }
    3388     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3389     if (endLine)
    3390        removeLine(entry, endLine);
    3391            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3392     kernelLine->indent, initrd);
    3393            if (!line)
    3394        return 1;
    3395     if (endLine) {
    3396        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3397                if (!line)
    3398     return 1;
    3399     }
    3400    
    3401            break;
    3402        }
    3403    
    3404        return 0;
    3405    }
    3406    
    3407  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3408                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd, const char * title) {
    3409      struct singleEntry * entry;      struct singleEntry * entry;
    3410      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
    3411      int index = 0;      int index = 0;
    # Line 3239  int updateInitrd(struct grubConfig * cfg Line 3413  int updateInitrd(struct grubConfig * cfg
    3413      if (!image) return 0;      if (!image) return 0;
    3414    
    3415      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3416          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3417          if (!kernelLine) continue;          if (!kernelLine) continue;
    3418    
    3419          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);   /* if title is supplied, the entry's title must match it. */
    3420     if (title) {
    3421        char *linetitle;
    3422    
    3423        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3424        if (!line)
    3425     continue;
    3426    
    3427        linetitle = extractTitle(cfg, line);
    3428        if (!linetitle)
    3429     continue;
    3430        if (strcmp(title, linetitle)) {
    3431     free(linetitle);
    3432     continue;
    3433        }
    3434        free(linetitle);
    3435     }
    3436    
    3437            line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3438          if (line)          if (line)
    3439              removeLine(entry, line);              removeLine(entry, line);
    3440          if (prefix) {          if (prefix) {
    # Line 3253  int updateInitrd(struct grubConfig * cfg Line 3445  int updateInitrd(struct grubConfig * cfg
    3445   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3446   if (endLine)   if (endLine)
    3447      removeLine(entry, endLine);      removeLine(entry, endLine);
    3448          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3449   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3450        case LT_KERNEL:
    3451            lt = LT_INITRD;
    3452     break;
    3453        case LT_KERNEL_EFI:
    3454            lt = LT_INITRD_EFI;
    3455     break;
    3456        case LT_KERNEL_16:
    3457            lt = LT_INITRD_16;
    3458     break;
    3459        default:
    3460            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3461     }
    3462            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3463          if (!line)          if (!line)
    3464      return 1;      return 1;
    3465   if (endLine) {   if (endLine) {
    # Line 3613  int addNewKernel(struct grubConfig * con Line 3818  int addNewKernel(struct grubConfig * con
    3818   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3819   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3820   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3821                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3822     const char * newDevTreePath) {
    3823      struct singleEntry * new;      struct singleEntry * new;
    3824      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3825      int needs;      int needs;
    # Line 3654  int addNewKernel(struct grubConfig * con Line 3860  int addNewKernel(struct grubConfig * con
    3860          needs |= NEED_MB;          needs |= NEED_MB;
    3861          new->multiboot = 1;          new->multiboot = 1;
    3862      }      }
    3863        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3864     needs |= NEED_DEVTREE;
    3865    
    3866      if (template) {      if (template) {
    3867   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3839  int addNewKernel(struct grubConfig * con Line 4047  int addNewKernel(struct grubConfig * con
    4047   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    4048   config->cfi);   config->cfi);
    4049      }      }
    4050        } else if (tmplLine->type == LT_DEVTREE &&
    4051           tmplLine->numElements == 2 && newDevTreePath) {
    4052            newLine = addLineTmpl(new, tmplLine, newLine,
    4053          newDevTreePath + strlen(prefix),
    4054          config->cfi);
    4055     needs &= ~NEED_DEVTREE;
    4056        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    4057     const char *ndtp = newDevTreePath;
    4058     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    4059        ndtp += strlen(prefix);
    4060     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4061      config->secondaryIndent,
    4062      ndtp);
    4063     needs &= ~NEED_DEVTREE;
    4064     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    4065      } else {      } else {
    4066   /* pass through other lines from the template */   /* pass through other lines from the template */
    4067   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3852  int addNewKernel(struct grubConfig * con Line 4075  int addNewKernel(struct grubConfig * con
    4075   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    4076      case LT_KERNEL:      case LT_KERNEL:
    4077      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    4078        case LT_KERNEL_16:
    4079   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    4080      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    4081   } else {   } else {
    # Line 3913  int addNewKernel(struct grubConfig * con Line 4137  int addNewKernel(struct grubConfig * con
    4137   }   }
    4138      }      }
    4139    
    4140        struct singleLine *endLine = NULL;
    4141        endLine = getLineByType(LT_ENTRY_END, new->lines);
    4142        if (endLine) {
    4143        removeLine(new, endLine);
    4144        needs |= NEED_END;
    4145        }
    4146    
    4147      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
    4148       * weren't present in the template, or in the case of no template,       * weren't present in the template, or in the case of no template,
    4149       * all the lines following the entryStart.       * all the lines following the entryStart.
    # Line 3958  int addNewKernel(struct grubConfig * con Line 4189  int addNewKernel(struct grubConfig * con
    4189   free(initrdVal);   free(initrdVal);
    4190   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4191      }      }
    4192        if (needs & NEED_DEVTREE) {
    4193     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4194      config->secondaryIndent,
    4195      newDevTreePath);
    4196     needs &= ~NEED_DEVTREE;
    4197        }
    4198    
    4199        /* NEEDS_END must be last on bootloaders that need it... */
    4200      if (needs & NEED_END) {      if (needs & NEED_END) {
    4201   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4202   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    # Line 3975  int addNewKernel(struct grubConfig * con Line 4214  int addNewKernel(struct grubConfig * con
    4214      return 0;      return 0;
    4215  }  }
    4216    
     static void traceback(int signum)  
     {  
         void *array[40];  
         size_t size;  
       
         signal(SIGSEGV, SIG_DFL);  
         memset(array, '\0', sizeof (array));  
         size = backtrace(array, 40);  
       
         fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",  
                 (unsigned long)size);  
         backtrace_symbols_fd(array, size, STDERR_FILENO);  
         exit(1);  
     }  
       
    4217  int main(int argc, const char ** argv) {  int main(int argc, const char ** argv) {
    4218      poptContext optCon;      poptContext optCon;
    4219      const char * grubConfig = NULL;      const char * grubConfig = NULL;
    # Line 4009  int main(int argc, const char ** argv) { Line 4233  int main(int argc, const char ** argv) {
    4233      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4234      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4235      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4236      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4237      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4238      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4239      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 4067  int main(int argc, const char ** argv) { Line 4291  int main(int argc, const char ** argv) {
    4291      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4292   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4293      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4294     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4295        _("device tree file for new stanza"), _("dtb-path") },
    4296     { "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4297        _("device tree directory for new stanza"), _("dtb-path") },
    4298   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4299      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4300   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    # Line 4128  int main(int argc, const char ** argv) { Line 4356  int main(int argc, const char ** argv) {
    4356    
    4357      useextlinuxmenu=0;      useextlinuxmenu=0;
    4358    
         signal(SIGSEGV, traceback);  
       
    4359      int i = 0;      int i = 0;
    4360      for (int j = 1; j < argc; j++)      for (int j = 1; j < argc; j++)
    4361   i += strlen(argv[j]) + 1;   i += strlen(argv[j]) + 1;
    # Line 4207  int main(int argc, const char ** argv) { Line 4433  int main(int argc, const char ** argv) {
    4433      }      }
    4434    
    4435      if (!cfi) {      if (!cfi) {
    4436          if (grub2FindConfig(&grub2ConfigType))          if (grub2FindConfig(&grub2ConfigType)) {
    4437      cfi = &grub2ConfigType;      cfi = &grub2ConfigType;
    4438   else      if (envPath)
    4439     cfi->envFile = envPath;
    4440            } else
    4441        #ifdef __ia64__        #ifdef __ia64__
    4442      cfi = &eliloConfigType;      cfi = &eliloConfigType;
    4443        #elif __powerpc__        #elif __powerpc__
    # Line 4232  int main(int argc, const char ** argv) { Line 4460  int main(int argc, const char ** argv) {
    4460      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4461      }      }
    4462    
    4463      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4464      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4465      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4466      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4241  int main(int argc, const char ** argv) { Line 4469  int main(int argc, const char ** argv) {
    4469   return 1;   return 1;
    4470      }      }
    4471    
    4472      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4473     removeKernelPath)) {     removeKernelPath)) {
    4474   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4475    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 4251  int main(int argc, const char ** argv) { Line 4479  int main(int argc, const char ** argv) {
    4479      if (newKernelPath && !newKernelTitle) {      if (newKernelPath && !newKernelTitle) {
    4480   fprintf(stderr, _("grubby: kernel title must be specified\n"));   fprintf(stderr, _("grubby: kernel title must be specified\n"));
    4481   return 1;   return 1;
    4482      } else if (!newKernelPath && (newKernelTitle  || copyDefault ||      } else if (!newKernelPath && (copyDefault ||
    4483    (newKernelInitrd && !updateKernelPath)||    (newKernelInitrd && !updateKernelPath)||
    4484    makeDefault || extraInitrdCount > 0)) {    makeDefault || extraInitrdCount > 0)) {
    4485   fprintf(stderr, _("grubby: kernel path expected\n"));   fprintf(stderr, _("grubby: kernel path expected\n"));
    # Line 4410  int main(int argc, const char ** argv) { Line 4638  int main(int argc, const char ** argv) {
    4638   if (!entry) return 0;   if (!entry) return 0;
    4639   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4640    
    4641   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    4642   if (!line) return 0;   if (!line) return 0;
    4643    
    4644          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4423  int main(int argc, const char ** argv) { Line 4651  int main(int argc, const char ** argv) {
    4651   struct singleLine * line;   struct singleLine * line;
    4652   struct singleEntry * entry;   struct singleEntry * entry;
    4653    
    4654   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1)
    4655        return 0;
    4656   if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&   if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4657   cfi->defaultIsSaved)   cfi->defaultIsSaved)
    4658      config->defaultImage = 0;      config->defaultImage = 0;
    4659   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4660   if (!entry) return 0;   if (!entry)
    4661     return 0;
    4662    
    4663   if (!configureGrub2) {   if (!configureGrub2) {
    4664    line = getLineByType(LT_TITLE, entry->lines);      char *title;
    4665    if (!line) return 0;      line = getLineByType(LT_TITLE, entry->lines);
    4666    printf("%s\n", line->elements[1].item);      if (!line)
    4667     return 0;
    4668        title = extractTitle(config, line);
    4669        if (!title)
    4670     return 0;
    4671        printf("%s\n", title);
    4672        free(title);
    4673   } else {   } else {
    4674    char * title;      char * title;
    4675    
    4676    dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");      dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
    4677    line = getLineByType(LT_MENUENTRY, entry->lines);      line = getLineByType(LT_MENUENTRY, entry->lines);
    4678    if (!line) return 0;      if (!line)
    4679    title = grub2ExtractTitle(line);   return 0;
    4680    if (title)      title = grub2ExtractTitle(line);
    4681      printf("%s\n", title);      if (title)
    4682     printf("%s\n", title);
    4683   }   }
    4684   return 0;   return 0;
    4685    
    # Line 4471  int main(int argc, const char ** argv) { Line 4707  int main(int argc, const char ** argv) {
    4707      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4708                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4709      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4710              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4711                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4712     bootPrefix, newKernelInitrd,
    4713     newKernelTitle))
    4714        return 1;
    4715        } else {
    4716        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4717     newKernelInitrd, newKernelTitle))
    4718     return 1;
    4719        }
    4720      }      }
    4721      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4722                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4723                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4724                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4725            
    4726    
    4727      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2257  
    changed lines
      Added in v.2992