Magellan Linux

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

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

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

    revision 1844 by niro, Mon Jul 2 12:59:07 2012 UTC revision 1940 by niro, Mon Oct 1 12:39:50 2012 UTC
    # Line 56  int debug = 0; /* Currently just for tem Line 56  int debug = 0; /* Currently just for tem
    56  #define NOOP_OPCODE 0x90  #define NOOP_OPCODE 0x90
    57  #define JMP_SHORT_OPCODE 0xeb  #define JMP_SHORT_OPCODE 0xeb
    58    
    59    int isEfi = 0;
    60    
    61  /* comments get lumped in with indention */  /* comments get lumped in with indention */
    62  struct lineElement {  struct lineElement {
    63      char * item;      char * item;
    # Line 82  enum lineType_e { Line 84  enum lineType_e {
    84      LT_MENUENTRY    = 1 << 17,      LT_MENUENTRY    = 1 << 17,
    85      LT_ENTRY_END    = 1 << 18,      LT_ENTRY_END    = 1 << 18,
    86      LT_SET_VARIABLE = 1 << 19,      LT_SET_VARIABLE = 1 << 19,
    87      LT_UNKNOWN      = 1 << 20,      LT_KERNEL_EFI   = 1 << 20,
    88        LT_INITRD_EFI   = 1 << 21,
    89        LT_UNKNOWN      = 1 << 22,
    90  };  };
    91    
    92  struct singleLine {  struct singleLine {
    # Line 164  struct keywordTypes grubKeywords[] = { Line 168  struct keywordTypes grubKeywords[] = {
    168    
    169  const char *grubFindConfig(struct configFileInfo *cfi) {  const char *grubFindConfig(struct configFileInfo *cfi) {
    170      static const char *configFiles[] = {      static const char *configFiles[] = {
      "/etc/grub.conf",  
    171   "/boot/grub/grub.conf",   "/boot/grub/grub.conf",
    172   "/boot/grub/menu.lst",   "/boot/grub/menu.lst",
    173     "/etc/grub.conf",
    174   NULL   NULL
    175      };      };
    176      static int i = -1;      static int i = -1;
    # Line 205  struct keywordTypes grub2Keywords[] = { Line 209  struct keywordTypes grub2Keywords[] = {
    209      { "default",    LT_DEFAULT,     ' ' },      { "default",    LT_DEFAULT,     ' ' },
    210      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    211      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    212        { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    213      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    214        { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
    215      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
    216      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
    217      { NULL, 0, 0 },      { NULL, 0, 0 },
    # Line 243  const char *grub2FindConfig(struct confi Line 249  const char *grub2FindConfig(struct confi
    249  }  }
    250    
    251  int sizeOfSingleLine(struct singleLine * line) {  int sizeOfSingleLine(struct singleLine * line) {
       int i;  
    252    int count = 0;    int count = 0;
    253    
    254    for (i = 0; i < line->numElements; i++) {    for (int i = 0; i < line->numElements; i++) {
    255      int indentSize = 0;      int indentSize = 0;
    256    
    257      count = count + strlen(line->elements[i].item);      count = count + strlen(line->elements[i].item);
    # Line 272  static int isquote(char q) Line 277  static int isquote(char q)
    277      return 0;      return 0;
    278  }  }
    279    
    280    static int iskernel(enum lineType_e type) {
    281        return (type == LT_KERNEL || type == LT_KERNEL_EFI);
    282    }
    283    
    284    static int isinitrd(enum lineType_e type) {
    285        return (type == LT_INITRD || type == LT_INITRD_EFI);
    286    }
    287    
    288  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
    289      char * current;      char * current;
    290      char * current_indent;      char * current_indent;
    # Line 571  static char * sdupprintf(const char *for Line 584  static char * sdupprintf(const char *for
    584      return buf;      return buf;
    585  }  }
    586    
    587    static enum lineType_e preferredLineType(enum lineType_e type,
    588     struct configFileInfo *cfi) {
    589        if (isEfi && cfi == &grub2ConfigType) {
    590     switch (type) {
    591     case LT_KERNEL:
    592        return LT_KERNEL_EFI;
    593     case LT_INITRD:
    594        return LT_INITRD_EFI;
    595     default:
    596        return type;
    597     }
    598        }
    599        return type;
    600    }
    601    
    602  static struct keywordTypes * getKeywordByType(enum lineType_e type,  static struct keywordTypes * getKeywordByType(enum lineType_e type,
    603        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    604      struct keywordTypes * kw;      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
         for (kw = cfi->keywords; kw->key; kw++) {  
    605   if (kw->type == type)   if (kw->type == type)
    606      return kw;      return kw;
    607      }      }
    # Line 604  static char * getuuidbydev(char *device) Line 631  static char * getuuidbydev(char *device)
    631    
    632  static enum lineType_e getTypeByKeyword(char * keyword,  static enum lineType_e getTypeByKeyword(char * keyword,
    633   struct configFileInfo * cfi) {   struct configFileInfo * cfi) {
    634      struct keywordTypes * kw;      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
         for (kw = cfi->keywords; kw->key; kw++) {  
    635   if (!strcmp(keyword, kw->key))   if (!strcmp(keyword, kw->key))
    636      return kw->type;      return kw->type;
    637      }      }
    # Line 692  static void lineInit(struct singleLine * Line 718  static void lineInit(struct singleLine *
    718  }  }
    719    
    720  struct singleLine * lineDup(struct singleLine * line) {  struct singleLine * lineDup(struct singleLine * line) {
         int i;  
    721      struct singleLine * newLine = malloc(sizeof(*newLine));      struct singleLine * newLine = malloc(sizeof(*newLine));
    722    
    723      newLine->indent = strdup(line->indent);      newLine->indent = strdup(line->indent);
    # Line 702  struct singleLine * lineDup(struct singl Line 727  struct singleLine * lineDup(struct singl
    727      newLine->elements = malloc(sizeof(*newLine->elements) *      newLine->elements = malloc(sizeof(*newLine->elements) *
    728         newLine->numElements);         newLine->numElements);
    729    
    730      for (i = 0; i < newLine->numElements; i++) {      for (int i = 0; i < newLine->numElements; i++) {
    731   newLine->elements[i].indent = strdup(line->elements[i].indent);   newLine->elements[i].indent = strdup(line->elements[i].indent);
    732   newLine->elements[i].item = strdup(line->elements[i].item);   newLine->elements[i].item = strdup(line->elements[i].item);
    733      }      }
    # Line 711  struct singleLine * lineDup(struct singl Line 736  struct singleLine * lineDup(struct singl
    736  }  }
    737    
    738  static void lineFree(struct singleLine * line) {  static void lineFree(struct singleLine * line) {
         int i;  
       
    739      if (line->indent) free(line->indent);      if (line->indent) free(line->indent);
    740    
    741      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    742   free(line->elements[i].item);   free(line->elements[i].item);
    743   free(line->elements[i].indent);   free(line->elements[i].indent);
    744      }      }
    # Line 726  static void lineFree(struct singleLine * Line 749  static void lineFree(struct singleLine *
    749    
    750  static int lineWrite(FILE * out, struct singleLine * line,  static int lineWrite(FILE * out, struct singleLine * line,
    751       struct configFileInfo * cfi) {       struct configFileInfo * cfi) {
         int i;  
       
    752      if (fprintf(out, "%s", line->indent) == -1) return -1;      if (fprintf(out, "%s", line->indent) == -1) return -1;
    753    
    754      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    755   /* Need to handle this, because we strip the quotes from   /* Need to handle this, because we strip the quotes from
    756   * menuentry when read it. */   * menuentry when read it. */
    757   if (line->type == LT_MENUENTRY && i == 1) {   if (line->type == LT_MENUENTRY && i == 1) {
    # Line 836  static int getNextLine(char ** bufPtr, s Line 857  static int getNextLine(char ** bufPtr, s
    857      if (*line->elements[0].item == '#') {      if (*line->elements[0].item == '#') {
    858   char * fullLine;   char * fullLine;
    859   int len;   int len;
      int i;  
    860    
    861   len = strlen(line->indent);   len = strlen(line->indent);
    862   for (i = 0; i < line->numElements; i++)   for (int i = 0; i < line->numElements; i++)
    863      len += strlen(line->elements[i].item) +      len += strlen(line->elements[i].item) +
    864     strlen(line->elements[i].indent);     strlen(line->elements[i].indent);
    865    
    # Line 848  static int getNextLine(char ** bufPtr, s Line 868  static int getNextLine(char ** bufPtr, s
    868   free(line->indent);   free(line->indent);
    869   line->indent = fullLine;   line->indent = fullLine;
    870    
    871   for (i = 0; i < line->numElements; i++) {   for (int i = 0; i < line->numElements; i++) {
    872      strcat(fullLine, line->elements[i].item);      strcat(fullLine, line->elements[i].item);
    873      strcat(fullLine, line->elements[i].indent);      strcat(fullLine, line->elements[i].indent);
    874      free(line->elements[i].item);      free(line->elements[i].item);
    # Line 867  static int getNextLine(char ** bufPtr, s Line 887  static int getNextLine(char ** bufPtr, s
    887   * elements up more   * elements up more
    888   */   */
    889   if (!isspace(kw->separatorChar)) {   if (!isspace(kw->separatorChar)) {
         int i;  
    890      char indent[2] = "";      char indent[2] = "";
    891      indent[0] = kw->separatorChar;      indent[0] = kw->separatorChar;
    892      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    893   char *p;   char *p;
      int j;  
    894   int numNewElements;   int numNewElements;
    895    
    896   numNewElements = 0;   numNewElements = 0;
    # Line 888  static int getNextLine(char ** bufPtr, s Line 906  static int getNextLine(char ** bufPtr, s
    906      sizeof(*line->elements) * elementsAlloced);      sizeof(*line->elements) * elementsAlloced);
    907   }   }
    908    
    909   for (j = line->numElements; j > i; j--) {   for (int j = line->numElements; j > i; j--) {
    910   line->elements[j + numNewElements] = line->elements[j];   line->elements[j + numNewElements] = line->elements[j];
    911   }   }
    912   line->numElements += numNewElements;   line->numElements += numNewElements;
    # Line 926  static struct grubConfig * readConfig(co Line 944  static struct grubConfig * readConfig(co
    944      struct singleLine * last = NULL, * line, * defaultLine = NULL;      struct singleLine * last = NULL, * line, * defaultLine = NULL;
    945      char * end;      char * end;
    946      struct singleEntry * entry = NULL;      struct singleEntry * entry = NULL;
    947      int i, len;      int len;
    948      char * buf;      char * buf;
    949    
    950      if (!strcmp(inName, "-")) {      if (!strcmp(inName, "-")) {
    # Line 989  static struct grubConfig * readConfig(co Line 1007  static struct grubConfig * readConfig(co
    1007   }   }
    1008    
    1009   if (line->type == LT_SET_VARIABLE) {   if (line->type == LT_SET_VARIABLE) {
         int i;  
    1010      dbgPrintf("found 'set' command (%d elements): ", line->numElements);      dbgPrintf("found 'set' command (%d elements): ", line->numElements);
    1011      dbgPrintf("%s", line->indent);      dbgPrintf("%s", line->indent);
    1012      for (i = 0; i < line->numElements; i++)      for (int i = 0; i < line->numElements; i++)
    1013   dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);   dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
    1014      dbgPrintf("\n");      dbgPrintf("\n");
    1015      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
    # Line 1006  static struct grubConfig * readConfig(co Line 1023  static struct grubConfig * readConfig(co
    1023      cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;      cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1024      defaultLine = line;      defaultLine = line;
    1025    
    1026          } else if (line->type == LT_KERNEL) {          } else if (iskernel(line->type)) {
    1027      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
    1028       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
    1029       * instead of LT_KERNEL now       * instead of LT_KERNEL now
    # Line 1020  static struct grubConfig * readConfig(co Line 1037  static struct grubConfig * readConfig(co
    1037       * This only applies to grub, but that's the only place we       * This only applies to grub, but that's the only place we
    1038       * should find LT_MBMODULE lines anyway.       * should find LT_MBMODULE lines anyway.
    1039       */       */
    1040      struct singleLine * l;      for (struct singleLine *l = entry->lines; l; l = l->next) {
         for (l = entry->lines; l; l = l->next) {  
    1041   if (l->type == LT_HYPER)   if (l->type == LT_HYPER)
    1042      break;      break;
    1043   else if (l->type == LT_KERNEL) {   else if (iskernel(l->type)) {
    1044      l->type = LT_HYPER;      l->type = LT_HYPER;
    1045      break;      break;
    1046   }   }
    # Line 1041  static struct grubConfig * readConfig(co Line 1057  static struct grubConfig * readConfig(co
    1057   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if (line->type == LT_TITLE && line->numElements > 1) {
    1058      /* make the title a single argument (undoing our parsing) */      /* make the title a single argument (undoing our parsing) */
    1059      len = 0;      len = 0;
    1060      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1061   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    1062   len += strlen(line->elements[i].indent);   len += strlen(line->elements[i].indent);
    1063      }      }
    1064      buf = malloc(len + 1);      buf = malloc(len + 1);
    1065      *buf = '\0';      *buf = '\0';
    1066    
    1067      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1068   strcat(buf, line->elements[i].item);   strcat(buf, line->elements[i].item);
    1069   free(line->elements[i].item);   free(line->elements[i].item);
    1070    
    # Line 1068  static struct grubConfig * readConfig(co Line 1084  static struct grubConfig * readConfig(co
    1084      char *extras;      char *extras;
    1085      char *title;      char *title;
    1086    
    1087      for (i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1088   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    1089   len += strlen(line->elements[i].indent);   len += strlen(line->elements[i].indent);
    1090      }      }
    # Line 1080  static struct grubConfig * readConfig(co Line 1096  static struct grubConfig * readConfig(co
    1096      *extras = '\0';      *extras = '\0';
    1097    
    1098      /* get title. */      /* get title. */
    1099      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    1100   if (!strcmp(line->elements[i].item, "menuentry"))   if (!strcmp(line->elements[i].item, "menuentry"))
    1101      continue;      continue;
    1102   if (isquote(*line->elements[i].item))   if (isquote(*line->elements[i].item))
    # Line 1100  static struct grubConfig * readConfig(co Line 1116  static struct grubConfig * readConfig(co
    1116    
    1117      /* get extras */      /* get extras */
    1118      int count = 0;      int count = 0;
    1119      for (i = 0; i < line->numElements; i++) {      for (int i = 0; i < line->numElements; i++) {
    1120   if (count >= 2) {   if (count >= 2) {
    1121      strcat(extras, line->elements[i].item);      strcat(extras, line->elements[i].item);
    1122      strcat(extras, line->elements[i].indent);      strcat(extras, line->elements[i].indent);
    # Line 1221  static struct grubConfig * readConfig(co Line 1237  static struct grubConfig * readConfig(co
    1237      cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);      cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
    1238      if (*end) cfg->defaultImage = -1;      if (*end) cfg->defaultImage = -1;
    1239   } else if (defaultLine->numElements >= 2) {   } else if (defaultLine->numElements >= 2) {
    1240      i = 0;      int i = 0;
    1241      while ((entry = findEntryByIndex(cfg, i))) {      while ((entry = findEntryByIndex(cfg, i))) {
    1242   for (line = entry->lines; line; line = line->next)   for (line = entry->lines; line; line = line->next)
    1243      if (line->type == LT_TITLE) break;      if (line->type == LT_TITLE) break;
    # Line 1323  static int writeConfig(struct grubConfig Line 1339  static int writeConfig(struct grubConfig
    1339    
    1340      /* most likely the symlink is relative, so change our      /* most likely the symlink is relative, so change our
    1341         directory to the dir of the symlink */         directory to the dir of the symlink */
    1342              rc = chdir(dirname(strdupa(outName)));      char *dir = strdupa(outName);
    1343        rc = chdir(dirname(dir));
    1344      do {      do {
    1345   buf = alloca(len + 1);   buf = alloca(len + 1);
    1346   rc = readlink(basename(outName), buf, len);   rc = readlink(basename(outName), buf, len);
    # Line 1577  int suitableImage(struct singleEntry * e Line 1594  int suitableImage(struct singleEntry * e
    1594   return 0;   return 0;
    1595      }      }
    1596    
    1597      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
    1598      if (!line) {      if (!line) {
    1599   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, "no line found\n");
    1600   return 0;   return 0;
    # Line 1707  struct singleEntry * findEntryByPath(str Line 1724  struct singleEntry * findEntryByPath(str
    1724   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1725   if (!entry) return NULL;   if (!entry) return NULL;
    1726    
    1727   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
    1728   if (!line) return NULL;   if (!line) return NULL;
    1729    
    1730   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1756  struct singleEntry * findEntryByPath(str Line 1773  struct singleEntry * findEntryByPath(str
    1773    
    1774      /* check all the lines matching checkType */      /* check all the lines matching checkType */
    1775      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    1776   line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?   line = getLineByType(entry->multiboot && checkType == LT_KERNEL
    1777       LT_KERNEL|LT_MBMODULE|LT_HYPER :   ? LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER
    1778       checkType, line);   : checkType, line);
    1779   if (!line) break;  /* not found in this entry */   if (!line) break;  /* not found in this entry */
    1780    
    1781   if (line && line->type != LT_MENUENTRY &&   if (line && line->type != LT_MENUENTRY &&
    # Line 1778  struct singleEntry * findEntryByPath(str Line 1795  struct singleEntry * findEntryByPath(str
    1795       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    1796       * unfortunate)       * unfortunate)
    1797       */       */
    1798      if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))
    1799   break; /* found 'im! */   break; /* found 'im! */
    1800   }   }
    1801    
    # Line 1880  void markRemovedImage(struct grubConfig Line 1897  void markRemovedImage(struct grubConfig
    1897    
    1898  void setDefaultImage(struct grubConfig * config, int hasNew,  void setDefaultImage(struct grubConfig * config, int hasNew,
    1899       const char * defaultKernelPath, int newIsDefault,       const char * defaultKernelPath, int newIsDefault,
    1900       const char * prefix, int flags) {       const char * prefix, int flags, int index) {
    1901      struct singleEntry * entry, * entry2, * newDefault;      struct singleEntry * entry, * entry2, * newDefault;
    1902      int i, j;      int i, j;
    1903    
    1904      if (newIsDefault) {      if (newIsDefault) {
    1905   config->defaultImage = 0;   config->defaultImage = 0;
    1906   return;   return;
    1907        } else if ((index >= 0) && config->cfi->defaultIsIndex) {
    1908     if (findEntryByIndex(config, index))
    1909        config->defaultImage = index;
    1910     else
    1911        config->defaultImage = -1;
    1912     return;
    1913      } else if (defaultKernelPath) {      } else if (defaultKernelPath) {
    1914   i = 0;   i = 0;
    1915   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {   if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
    # Line 1961  void displayEntry(struct singleEntry * e Line 1984  void displayEntry(struct singleEntry * e
    1984    
    1985      printf("index=%d\n", index);      printf("index=%d\n", index);
    1986    
    1987      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
    1988      if (!line) {      if (!line) {
    1989          printf("non linux entry\n");          printf("non linux entry\n");
    1990          return;          return;
    1991      }      }
    1992    
    1993      printf("kernel=%s%s\n", prefix, line->elements[1].item);      if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    1994     printf("kernel=%s\n", line->elements[1].item);
    1995        else
    1996     printf("kernel=%s%s\n", prefix, line->elements[1].item);
    1997    
    1998      if (line->numElements >= 3) {      if (line->numElements >= 3) {
    1999   printf("args=\"");   printf("args=\"");
    # Line 2023  void displayEntry(struct singleEntry * e Line 2049  void displayEntry(struct singleEntry * e
    2049   printf("root=%s\n", s);   printf("root=%s\n", s);
    2050      }      }
    2051    
    2052      line = getLineByType(LT_INITRD, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
    2053    
    2054      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2055   printf("initrd=%s", prefix);   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2056        printf("initrd=");
    2057     else
    2058        printf("initrd=%s", prefix);
    2059    
    2060   for (i = 1; i < line->numElements; i++)   for (i = 1; i < line->numElements; i++)
    2061      printf("%s%s", line->elements[i].item, line->elements[i].indent);      printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2062   printf("\n");   printf("\n");
    # Line 2044  void displayEntry(struct singleEntry * e Line 2074  void displayEntry(struct singleEntry * e
    2074      }      }
    2075  }  }
    2076    
    2077    int isSuseSystem(void) {
    2078        const char * path;
    2079        const static char default_path[] = "/etc/SuSE-release";
    2080    
    2081        if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
    2082     path = default_path;
    2083    
    2084        if (!access(path, R_OK))
    2085     return 1;
    2086        return 0;
    2087    }
    2088    
    2089    int isSuseGrubConf(const char * path) {
    2090        FILE * grubConf;
    2091        char * line = NULL;
    2092        size_t len = 0, res = 0;
    2093    
    2094        grubConf = fopen(path, "r");
    2095        if (!grubConf) {
    2096            dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
    2097     return 0;
    2098        }
    2099    
    2100        while ((res = getline(&line, &len, grubConf)) != -1) {
    2101     if (!strncmp(line, "setup", 5)) {
    2102        fclose(grubConf);
    2103        free(line);
    2104        return 1;
    2105     }
    2106        }
    2107    
    2108        dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
    2109          path);
    2110    
    2111        fclose(grubConf);
    2112        free(line);
    2113        return 0;
    2114    }
    2115    
    2116    int suseGrubConfGetLba(const char * path, int * lbaPtr) {
    2117        FILE * grubConf;
    2118        char * line = NULL;
    2119        size_t res = 0, len = 0;
    2120    
    2121        if (!path) return 1;
    2122        if (!lbaPtr) return 1;
    2123    
    2124        grubConf = fopen(path, "r");
    2125        if (!grubConf) return 1;
    2126    
    2127        while ((res = getline(&line, &len, grubConf)) != -1) {
    2128     if (line[res - 1] == '\n')
    2129        line[res - 1] = '\0';
    2130     else if (len > res)
    2131        line[res] = '\0';
    2132     else {
    2133        line = realloc(line, res + 1);
    2134        line[res] = '\0';
    2135     }
    2136    
    2137     if (!strncmp(line, "setup", 5)) {
    2138        if (strstr(line, "--force-lba")) {
    2139            *lbaPtr = 1;
    2140        } else {
    2141            *lbaPtr = 0;
    2142        }
    2143        dbgPrintf("lba: %i\n", *lbaPtr);
    2144        break;
    2145     }
    2146        }
    2147    
    2148        free(line);
    2149        fclose(grubConf);
    2150        return 0;
    2151    }
    2152    
    2153    int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
    2154        FILE * grubConf;
    2155        char * line = NULL;
    2156        size_t res = 0, len = 0;
    2157        char * lastParamPtr = NULL;
    2158        char * secLastParamPtr = NULL;
    2159        char installDeviceNumber = '\0';
    2160        char * bounds = NULL;
    2161    
    2162        if (!path) return 1;
    2163        if (!devicePtr) return 1;
    2164    
    2165        grubConf = fopen(path, "r");
    2166        if (!grubConf) return 1;
    2167    
    2168        while ((res = getline(&line, &len, grubConf)) != -1) {
    2169     if (strncmp(line, "setup", 5))
    2170        continue;
    2171    
    2172     if (line[res - 1] == '\n')
    2173        line[res - 1] = '\0';
    2174     else if (len > res)
    2175        line[res] = '\0';
    2176     else {
    2177        line = realloc(line, res + 1);
    2178        line[res] = '\0';
    2179     }
    2180    
    2181     lastParamPtr = bounds = line + res;
    2182    
    2183     /* Last parameter in grub may be an optional IMAGE_DEVICE */
    2184     while (!isspace(*lastParamPtr))
    2185        lastParamPtr--;
    2186     lastParamPtr++;
    2187    
    2188     secLastParamPtr = lastParamPtr - 2;
    2189     dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
    2190    
    2191     if (lastParamPtr + 3 > bounds) {
    2192        dbgPrintf("lastParamPtr going over boundary");
    2193        fclose(grubConf);
    2194        free(line);
    2195        return 1;
    2196     }
    2197     if (!strncmp(lastParamPtr, "(hd", 3))
    2198        lastParamPtr += 3;
    2199     dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
    2200    
    2201     /*
    2202     * Second last parameter will decide wether last parameter is
    2203     * an IMAGE_DEVICE or INSTALL_DEVICE
    2204     */
    2205     while (!isspace(*secLastParamPtr))
    2206        secLastParamPtr--;
    2207     secLastParamPtr++;
    2208    
    2209     if (secLastParamPtr + 3 > bounds) {
    2210        dbgPrintf("secLastParamPtr going over boundary");
    2211        fclose(grubConf);
    2212        free(line);
    2213        return 1;
    2214     }
    2215     dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
    2216     if (!strncmp(secLastParamPtr, "(hd", 3)) {
    2217        secLastParamPtr += 3;
    2218        dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
    2219        installDeviceNumber = *secLastParamPtr;
    2220     } else {
    2221        installDeviceNumber = *lastParamPtr;
    2222     }
    2223    
    2224     *devicePtr = malloc(6);
    2225     snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
    2226     dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
    2227     fclose(grubConf);
    2228     free(line);
    2229     return 0;
    2230        }
    2231    
    2232        free(line);
    2233        fclose(grubConf);
    2234        return 1;
    2235    }
    2236    
    2237    int grubGetBootFromDeviceMap(const char * device,
    2238         char ** bootPtr) {
    2239        FILE * deviceMap;
    2240        char * line = NULL;
    2241        size_t res = 0, len = 0;
    2242        char * devicePtr;
    2243        char * bounds = NULL;
    2244        const char * path;
    2245        const static char default_path[] = "/boot/grub/device.map";
    2246    
    2247        if (!device) return 1;
    2248        if (!bootPtr) return 1;
    2249    
    2250        if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
    2251     path = default_path;
    2252    
    2253        dbgPrintf("opening grub device.map file from: %s\n", path);
    2254        deviceMap = fopen(path, "r");
    2255        if (!deviceMap)
    2256     return 1;
    2257    
    2258        while ((res = getline(&line, &len, deviceMap)) != -1) {
    2259            if (!strncmp(line, "#", 1))
    2260        continue;
    2261    
    2262     if (line[res - 1] == '\n')
    2263        line[res - 1] = '\0';
    2264     else if (len > res)
    2265        line[res] = '\0';
    2266     else {
    2267        line = realloc(line, res + 1);
    2268        line[res] = '\0';
    2269     }
    2270    
    2271     devicePtr = line;
    2272     bounds = line + res;
    2273    
    2274     while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
    2275        devicePtr++;
    2276     dbgPrintf("device: %s\n", devicePtr);
    2277    
    2278     if (!strncmp(devicePtr, device, strlen(device))) {
    2279        devicePtr += strlen(device);
    2280        while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
    2281            devicePtr++;
    2282    
    2283        *bootPtr = strdup(devicePtr);
    2284        break;
    2285     }
    2286        }
    2287    
    2288        free(line);
    2289        fclose(deviceMap);
    2290        return 0;
    2291    }
    2292    
    2293    int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
    2294        char * grubDevice;
    2295    
    2296        if (suseGrubConfGetInstallDevice(path, &grubDevice))
    2297     dbgPrintf("error looking for grub installation device\n");
    2298        else
    2299     dbgPrintf("grubby installation device: %s\n", grubDevice);
    2300    
    2301        if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
    2302     dbgPrintf("error looking for grub boot device\n");
    2303        else
    2304     dbgPrintf("grubby boot device: %s\n", *bootPtr);
    2305    
    2306        free(grubDevice);
    2307        return 0;
    2308    }
    2309    
    2310    int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
    2311        /*
    2312         * This SuSE grub configuration file at this location is not your average
    2313         * grub configuration file, but instead the grub commands used to setup
    2314         * grub on that system.
    2315         */
    2316        const char * path;
    2317        const static char default_path[] = "/etc/grub.conf";
    2318    
    2319        if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
    2320     path = default_path;
    2321    
    2322        if (!isSuseGrubConf(path)) return 1;
    2323    
    2324        if (lbaPtr) {
    2325            *lbaPtr = 0;
    2326            if (suseGrubConfGetLba(path, lbaPtr))
    2327                return 1;
    2328        }
    2329    
    2330        if (bootPtr) {
    2331            *bootPtr = NULL;
    2332            suseGrubConfGetBoot(path, bootPtr);
    2333        }
    2334    
    2335        return 0;
    2336    }
    2337    
    2338  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
    2339      FILE * in;      FILE * in;
    2340      char buf[1024];      char buf[1024];
    # Line 2092  int parseSysconfigGrub(int * lbaPtr, cha Line 2383  int parseSysconfigGrub(int * lbaPtr, cha
    2383  }  }
    2384    
    2385  void dumpSysconfigGrub(void) {  void dumpSysconfigGrub(void) {
    2386      char * boot;      char * boot = NULL;
    2387      int lba;      int lba;
    2388    
    2389      if (!parseSysconfigGrub(&lba, &boot)) {      if (isSuseSystem()) {
    2390   if (lba) printf("lba\n");          if (parseSuseGrubConf(&lba, &boot)) {
    2391   if (boot) printf("boot=%s\n", boot);      free(boot);
    2392        return;
    2393     }
    2394        } else {
    2395            if (parseSysconfigGrub(&lba, &boot)) {
    2396        free(boot);
    2397        return;
    2398     }
    2399        }
    2400    
    2401        if (lba) printf("lba\n");
    2402        if (boot) {
    2403     printf("boot=%s\n", boot);
    2404     free(boot);
    2405      }      }
    2406  }  }
    2407    
    # Line 2146  struct singleLine * addLineTmpl(struct s Line 2450  struct singleLine * addLineTmpl(struct s
    2450  {  {
    2451      struct singleLine * newLine = lineDup(tmplLine);      struct singleLine * newLine = lineDup(tmplLine);
    2452    
    2453        if (isEfi && cfi == &grub2ConfigType) {
    2454     enum lineType_e old = newLine->type;
    2455     newLine->type = preferredLineType(newLine->type, cfi);
    2456     if (old != newLine->type)
    2457        newLine->elements[0].item = getKeyByType(newLine->type, cfi);
    2458        }
    2459    
    2460      if (val) {      if (val) {
    2461   /* override the inherited value with our own.   /* override the inherited value with our own.
    2462   * This is a little weak because it only applies to elements[1]   * This is a little weak because it only applies to elements[1]
    # Line 2155  struct singleLine * addLineTmpl(struct s Line 2466  struct singleLine * addLineTmpl(struct s
    2466   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2467    
    2468   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2469   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)) {
    2470      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2471      if (rootspec != NULL) {      if (rootspec != NULL) {
    2472   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 2192  struct singleLine *  addLine(struct sing Line 2503  struct singleLine *  addLine(struct sing
    2503      /* 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
    2504       * stack since it calls addLineTmpl which will make copies.       * stack since it calls addLineTmpl which will make copies.
    2505       */       */
       
    2506      if (type == LT_TITLE && cfi->titleBracketed) {      if (type == LT_TITLE && cfi->titleBracketed) {
    2507   /* we're doing a bracketed title (zipl) */   /* we're doing a bracketed title (zipl) */
    2508   tmpl.type = type;   tmpl.type = type;
    # Line 2526  int updateActualImage(struct grubConfig Line 2836  int updateActualImage(struct grubConfig
    2836      firstElement = 2;      firstElement = 2;
    2837    
    2838   } else {   } else {
    2839      line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);
    2840      if (!line) {      if (!line) {
    2841   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    2842   continue;   continue;
    # Line 2691  int updateInitrd(struct grubConfig * cfg Line 3001  int updateInitrd(struct grubConfig * cfg
    3001      if (!image) return 0;      if (!image) return 0;
    3002    
    3003      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3004          kernelLine = getLineByType(LT_KERNEL, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);
    3005          if (!kernelLine) continue;          if (!kernelLine) continue;
    3006    
    3007          line = getLineByType(LT_INITRD, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
    3008          if (line)          if (line)
    3009              removeLine(entry, line);              removeLine(entry, line);
    3010          if (prefix) {          if (prefix) {
    # Line 2705  int updateInitrd(struct grubConfig * cfg Line 3015  int updateInitrd(struct grubConfig * cfg
    3015   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3016   if (endLine)   if (endLine)
    3017      removeLine(entry, endLine);      removeLine(entry, endLine);
    3018          line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),
    3019     kernelLine->indent, initrd);
    3020          if (!line)          if (!line)
    3021      return 1;      return 1;
    3022   if (endLine) {   if (endLine) {
    # Line 2911  int checkForGrub(struct grubConfig * con Line 3222  int checkForGrub(struct grubConfig * con
    3222      int fd;      int fd;
    3223      unsigned char bootSect[512];      unsigned char bootSect[512];
    3224      char * boot;      char * boot;
    3225        int onSuse = isSuseSystem();
    3226    
    3227      if (parseSysconfigGrub(NULL, &boot))  
    3228   return 0;      if (onSuse) {
    3229     if (parseSuseGrubConf(NULL, &boot))
    3230        return 0;
    3231        } else {
    3232     if (parseSysconfigGrub(NULL, &boot))
    3233        return 0;
    3234        }
    3235    
    3236      /* assume grub is not installed -- not an error condition */      /* assume grub is not installed -- not an error condition */
    3237      if (!boot)      if (!boot)
    # Line 2932  int checkForGrub(struct grubConfig * con Line 3250  int checkForGrub(struct grubConfig * con
    3250      }      }
    3251      close(fd);      close(fd);
    3252    
    3253        /* The more elaborate checks do not work on SuSE. The checks done
    3254         * seem to be reasonble (at least for now), so just return success
    3255         */
    3256        if (onSuse)
    3257     return 2;
    3258    
    3259      return checkDeviceBootloader(boot, bootSect);      return checkDeviceBootloader(boot, bootSect);
    3260  }  }
    3261    
    # Line 2965  int checkForExtLinux(struct grubConfig * Line 3289  int checkForExtLinux(struct grubConfig *
    3289      return checkDeviceBootloader(boot, bootSect);      return checkDeviceBootloader(boot, bootSect);
    3290  }  }
    3291    
    3292    int checkForYaboot(struct grubConfig * config) {
    3293        /*
    3294         * This is a simplistic check that we consider good enough for own puporses
    3295         *
    3296         * If we were to properly check if yaboot is *installed* we'd need to:
    3297         * 1) get the system boot device (LT_BOOT)
    3298         * 2) considering it's a raw filesystem, check if the yaboot binary matches
    3299         *    the content on the boot device
    3300         * 3) if not, copy the binary to a temporary file and run "addnote" on it
    3301         * 4) check again if binary and boot device contents match
    3302         */
    3303        if (!access("/etc/yaboot.conf", R_OK))
    3304     return 2;
    3305    
    3306        return 1;
    3307    }
    3308    
    3309    int checkForElilo(struct grubConfig * config) {
    3310        if (!access("/etc/elilo.conf", R_OK))
    3311     return 2;
    3312    
    3313        return 1;
    3314    }
    3315    
    3316  static char * getRootSpecifier(char * str) {  static char * getRootSpecifier(char * str) {
    3317      char * idx, * rootspec = NULL;      char * idx, * rootspec = NULL;
    3318    
    # Line 3081  int addNewKernel(struct grubConfig * con Line 3429  int addNewKernel(struct grubConfig * con
    3429      while (*chptr && isspace(*chptr)) chptr++;      while (*chptr && isspace(*chptr)) chptr++;
    3430      if (*chptr == '#') continue;      if (*chptr == '#') continue;
    3431    
    3432      if (tmplLine->type == LT_KERNEL &&      if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
         tmplLine->numElements >= 2) {  
    3433   if (!template->multiboot && (needs & NEED_MB)) {   if (!template->multiboot && (needs & NEED_MB)) {
    3434      /* it's not a multiboot template and this is the kernel      /* it's not a multiboot template and this is the kernel
    3435       * line.  Try to be intelligent about inserting the       * line.  Try to be intelligent about inserting the
    # Line 3159  int addNewKernel(struct grubConfig * con Line 3506  int addNewKernel(struct grubConfig * con
    3506      /* template is multi but new is not,      /* template is multi but new is not,
    3507       * insert the kernel in the first module slot       * insert the kernel in the first module slot
    3508       */       */
    3509      tmplLine->type = LT_KERNEL;      tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
    3510      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
    3511      tmplLine->elements[0].item =      tmplLine->elements[0].item =
    3512   strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
    3513     config->cfi)->key);
    3514      newLine = addLineTmpl(new, tmplLine, newLine,      newLine = addLineTmpl(new, tmplLine, newLine,
    3515    newKernelPath + strlen(prefix), config->cfi);    newKernelPath + strlen(prefix),
    3516      config->cfi);
    3517      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
    3518   } else if (needs & NEED_INITRD) {   } else if (needs & NEED_INITRD) {
    3519      char *initrdVal;      char *initrdVal;
    3520      /* template is multi but new is not,      /* template is multi but new is not,
    3521       * insert the initrd in the second module slot       * insert the initrd in the second module slot
    3522       */       */
    3523      tmplLine->type = LT_INITRD;      tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
    3524      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
    3525      tmplLine->elements[0].item =      tmplLine->elements[0].item =
    3526   strdup(getKeywordByType(LT_INITRD, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
    3527     config->cfi)->key);
    3528      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
    3529      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
    3530      free(initrdVal);      free(initrdVal);
    3531      needs &= ~NEED_INITRD;      needs &= ~NEED_INITRD;
    3532   }   }
    3533    
    3534      } else if (tmplLine->type == LT_INITRD &&      } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
            tmplLine->numElements >= 2) {  
    3535   if (needs & NEED_INITRD &&   if (needs & NEED_INITRD &&
    3536      new->multiboot && !template->multiboot &&      new->multiboot && !template->multiboot &&
    3537      config->cfi->mbInitRdIsModule) {      config->cfi->mbInitRdIsModule) {
    # Line 3236  int addNewKernel(struct grubConfig * con Line 3585  int addNewKernel(struct grubConfig * con
    3585      static const char *prefix = "'Loading ";      static const char *prefix = "'Loading ";
    3586      if (tmplLine->numElements > 1 &&      if (tmplLine->numElements > 1 &&
    3587      strstr(tmplLine->elements[1].item, prefix) &&      strstr(tmplLine->elements[1].item, prefix) &&
    3588      masterLine->next && masterLine->next->type == LT_KERNEL) {      masterLine->next &&
    3589        iskernel(masterLine->next->type)) {
    3590   char *newTitle = malloc(strlen(prefix) +   char *newTitle = malloc(strlen(prefix) +
    3591   strlen(newKernelTitle) + 2);   strlen(newKernelTitle) + 2);
    3592    
    # Line 3263  int addNewKernel(struct grubConfig * con Line 3613  int addNewKernel(struct grubConfig * con
    3613   */   */
    3614   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3615      case LT_KERNEL:      case LT_KERNEL:
    3616        case LT_KERNEL_EFI:
    3617   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    3618      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    3619   } else {   } else {
    3620      newLine = addLine(new, config->cfi, LT_KERNEL,      newLine = addLine(new, config->cfi,
    3621              preferredLineType(LT_KERNEL, config->cfi),
    3622        config->primaryIndent,        config->primaryIndent,
    3623        newKernelPath + strlen(prefix));        newKernelPath + strlen(prefix));
    3624      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
    # Line 3342  int addNewKernel(struct grubConfig * con Line 3694  int addNewKernel(struct grubConfig * con
    3694      if (needs & NEED_KERNEL) {      if (needs & NEED_KERNEL) {
    3695   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
    3696    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
    3697        config->cfi)) ?        config->cfi))
    3698    LT_MBMODULE : LT_KERNEL,     ? LT_MBMODULE
    3699     : preferredLineType(LT_KERNEL, config->cfi),
    3700    config->secondaryIndent,    config->secondaryIndent,
    3701    newKernelPath + strlen(prefix));    newKernelPath + strlen(prefix));
    3702   needs &= ~NEED_KERNEL;   needs &= ~NEED_KERNEL;
    # Line 3359  int addNewKernel(struct grubConfig * con Line 3712  int addNewKernel(struct grubConfig * con
    3712   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
    3713   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
    3714    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
    3715        config->cfi)) ?        config->cfi))
    3716    LT_MBMODULE : LT_INITRD,     ? LT_MBMODULE
    3717       : preferredLineType(LT_INITRD, config->cfi),
    3718    config->secondaryIndent,    config->secondaryIndent,
    3719    initrdVal);    initrdVal);
    3720   free(initrdVal);   free(initrdVal);
    # Line 3435  int main(int argc, const char ** argv) { Line 3789  int main(int argc, const char ** argv) {
    3789      int displayDefault = 0;      int displayDefault = 0;
    3790      int displayDefaultIndex = 0;      int displayDefaultIndex = 0;
    3791      int displayDefaultTitle = 0;      int displayDefaultTitle = 0;
    3792        int defaultIndex = -1;
    3793      struct poptOption options[] = {      struct poptOption options[] = {
    3794   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,   { "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
    3795      _("add an entry for the specified kernel"), _("kernel-path") },      _("add an entry for the specified kernel"), _("kernel-path") },
    # Line 3452  int main(int argc, const char ** argv) { Line 3807  int main(int argc, const char ** argv) {
    3807   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,   { "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
    3808      _("filestystem which contains /boot directory (for testing only)"),      _("filestystem which contains /boot directory (for testing only)"),
    3809      _("bootfs") },      _("bootfs") },
    3810  #if defined(__i386__) || defined(__x86_64__)  #if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
    3811   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,   { "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
    3812      _("check if lilo is installed on lilo.conf boot sector") },      _("check which bootloader is installed on boot sector") },
    3813  #endif  #endif
    3814   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,   { "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
    3815      _("path to grub config file to update (\"-\" for stdin)"),      _("path to grub config file to update (\"-\" for stdin)"),
    # Line 3475  int main(int argc, const char ** argv) { Line 3830  int main(int argc, const char ** argv) {
    3830      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    3831   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    3832      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    3833     { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    3834        _("force grub2 stanzas to use efi") },
    3835   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
    3836      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
    3837   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
    # Line 3507  int main(int argc, const char ** argv) { Line 3864  int main(int argc, const char ** argv) {
    3864   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,   { "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
    3865      _("make the first entry referencing the specified kernel "      _("make the first entry referencing the specified kernel "
    3866        "the default"), _("kernel-path") },        "the default"), _("kernel-path") },
    3867     { "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
    3868        _("make the given entry index the default entry"),
    3869        _("entry-index") },
    3870   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,   { "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
    3871      _("configure silo bootloader") },      _("configure silo bootloader") },
    3872   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,   { "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
    # Line 3615  int main(int argc, const char ** argv) { Line 3975  int main(int argc, const char ** argv) {
    3975      }      }
    3976    
    3977      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||
    3978    newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    3979    defaultKernel || displayDefaultIndex || displayDefaultTitle)) {      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    3980        (defaultIndex >= 0))) {
    3981   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "   fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
    3982    "specified option"));    "specified option"));
    3983   return 1;   return 1;
    # Line 3658  int main(int argc, const char ** argv) { Line 4019  int main(int argc, const char ** argv) {
    4019   makeDefault = 1;   makeDefault = 1;
    4020   defaultKernel = NULL;   defaultKernel = NULL;
    4021      }      }
    4022        else if (defaultKernel && (defaultIndex >= 0)) {
    4023     fprintf(stderr, _("grubby: --set-default and --set-default-index "
    4024      "may not be used together\n"));
    4025     return 1;
    4026        }
    4027    
    4028      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
    4029   fprintf(stderr, _("grubby: output file must be specified if stdin "   fprintf(stderr, _("grubby: output file must be specified if stdin "
    # Line 3666  int main(int argc, const char ** argv) { Line 4032  int main(int argc, const char ** argv) {
    4032      }      }
    4033    
    4034      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
    4035   && !kernelInfo && !bootloaderProbe && !updateKernelPath   && !kernelInfo && !bootloaderProbe && !updateKernelPath
    4036          && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {   && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
    4037     && (defaultIndex == -1)) {
    4038   fprintf(stderr, _("grubby: no action specified\n"));   fprintf(stderr, _("grubby: no action specified\n"));
    4039   return 1;   return 1;
    4040      }      }
    # Line 3694  int main(int argc, const char ** argv) { Line 4061  int main(int argc, const char ** argv) {
    4061      }      }
    4062    
    4063      if (bootloaderProbe) {      if (bootloaderProbe) {
    4064   int lrc = 0, grc = 0, gr2c = 0, erc = 0;   int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
    4065   struct grubConfig * lconfig, * gconfig;   struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
    4066    
    4067   const char *grub2config = grub2FindConfig(&grub2ConfigType);   const char *grub2config = grub2FindConfig(&grub2ConfigType);
    4068   if (grub2config) {   if (grub2config) {
    # Line 3723  int main(int argc, const char ** argv) { Line 4090  int main(int argc, const char ** argv) {
    4090   lrc = checkForLilo(lconfig);   lrc = checkForLilo(lconfig);
    4091   }   }
    4092    
    4093     if (!access(eliloConfigType.defaultConfig, F_OK)) {
    4094        econfig = readConfig(eliloConfigType.defaultConfig,
    4095     &eliloConfigType);
    4096        if (!econfig)
    4097     erc = 1;
    4098        else
    4099     erc = checkForElilo(econfig);
    4100     }
    4101    
    4102   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {   if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
    4103      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);      lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
    4104      if (!lconfig)      if (!lconfig)
    4105   erc = 1;   extrc = 1;
    4106      else      else
    4107   erc = checkForExtLinux(lconfig);   extrc = checkForExtLinux(lconfig);
    4108   }   }
    4109    
    4110   if (lrc == 1 || grc == 1 || gr2c == 1) return 1;  
    4111     if (!access(yabootConfigType.defaultConfig, F_OK)) {
    4112        yconfig = readConfig(yabootConfigType.defaultConfig,
    4113     &yabootConfigType);
    4114        if (!yconfig)
    4115     yrc = 1;
    4116        else
    4117     yrc = checkForYaboot(yconfig);
    4118     }
    4119    
    4120     if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
    4121     erc == 1)
    4122        return 1;
    4123    
    4124   if (lrc == 2) printf("lilo\n");   if (lrc == 2) printf("lilo\n");
    4125   if (gr2c == 2) printf("grub2\n");   if (gr2c == 2) printf("grub2\n");
    4126   if (grc == 2) printf("grub\n");   if (grc == 2) printf("grub\n");
    4127   if (erc == 2) printf("extlinux\n");   if (extrc == 2) printf("extlinux\n");
    4128     if (yrc == 2) printf("yaboot\n");
    4129     if (erc == 2) printf("elilo\n");
    4130    
    4131   return 0;   return 0;
    4132      }      }
    # Line 3754  int main(int argc, const char ** argv) { Line 4144  int main(int argc, const char ** argv) {
    4144   if (!entry) return 0;   if (!entry) return 0;
    4145   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4146    
    4147   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
    4148   if (!line) return 0;   if (!line) return 0;
    4149    
    4150          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 3803  int main(int argc, const char ** argv) { Line 4193  int main(int argc, const char ** argv) {
    4193      markRemovedImage(config, removeKernelPath, bootPrefix);      markRemovedImage(config, removeKernelPath, bootPrefix);
    4194      markRemovedImage(config, removeMBKernel, bootPrefix);      markRemovedImage(config, removeMBKernel, bootPrefix);
    4195      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
    4196      bootPrefix, flags);      bootPrefix, flags, defaultIndex);
    4197      setFallbackImage(config, newKernelPath != NULL);      setFallbackImage(config, newKernelPath != NULL);
    4198      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4199                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    Legend:
    Removed from v.1844  
    changed lines
      Added in v.1940