/[magellan-source]/tags/grubby-8_32/grubby.c

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

Parent Directory | Revision Log | View Patch Patch

-trunk/mkinitrd-magellan/grubby/grubby.c
revision 926 by niro,
Wed Oct 28 13:29:38 2009 UTC
+trunk/grubby/grubby.c
revision 2255 by niro,
Mon Oct 21 14:00:38 2013 UTC
 Line 36
  #include <signal.h>
  #include <blkid/blkid.h>
+ #include "log.h"
+ #ifndef DEBUG
  #define DEBUG 0
+ #endif
  #if DEBUG
  #define dbgPrintf(format, args...) fprintf(stderr, format , ## args)
-Line 44
+Line 48
  #define dbgPrintf(format, args...)
  #endif
+ int debug = 0;	/* Currently just for template debugging */
  #define _(A) (A)
  #define MAX_EXTRA_INITRDS	  16	/* code segment checked by --bootloader-probe */
  #define CODE_SEG_SIZE	  128	/* code segment checked by --bootloader-probe */
+ #define NOOP_OPCODE 0x90
+ #define JMP_SHORT_OPCODE 0xeb
+ int isEfi = 0;
+ char *saved_command_line = NULL;
  /* comments get lumped in with indention */
  struct lineElement {
      char * item;
-Line 56 
 struct lineElement {
+Line 69 
 struct lineElement {
  };
  enum lineType_e {
-     LT_WHITESPACE = 1 << 0,
+     LT_WHITESPACE   = 1 << 0,
-     LT_TITLE      = 1 << 1,
+     LT_TITLE        = 1 << 1,
-     LT_KERNEL     = 1 << 2,
+     LT_KERNEL       = 1 << 2,
-     LT_INITRD     = 1 << 3,
+     LT_INITRD       = 1 << 3,
-     LT_HYPER      = 1 << 4,
+     LT_HYPER        = 1 << 4,
-     LT_DEFAULT    = 1 << 5,
+     LT_DEFAULT      = 1 << 5,
-     LT_MBMODULE   = 1 << 6,
+     LT_MBMODULE     = 1 << 6,
-     LT_ROOT       = 1 << 7,
+     LT_ROOT         = 1 << 7,
-     LT_FALLBACK   = 1 << 8,
+     LT_FALLBACK     = 1 << 8,
-     LT_KERNELARGS = 1 << 9,
+     LT_KERNELARGS   = 1 << 9,
-     LT_BOOT       = 1 << 10,
+     LT_BOOT         = 1 << 10,
-     LT_BOOTROOT   = 1 << 11,
+     LT_BOOTROOT     = 1 << 11,
-     LT_LBA        = 1 << 12,
+     LT_LBA          = 1 << 12,
-     LT_OTHER      = 1 << 13,
+     LT_OTHER        = 1 << 13,
-     LT_GENERIC    = 1 << 14,
+     LT_GENERIC      = 1 << 14,
-     LT_UNKNOWN    = 1 << 15,
+     LT_ECHO	    = 1 << 16,
+     LT_MENUENTRY    = 1 << 17,
+     LT_ENTRY_END    = 1 << 18,
+     LT_SET_VARIABLE = 1 << 19,
+     LT_KERNEL_EFI   = 1 << 20,
+     LT_INITRD_EFI   = 1 << 21,
+     LT_UNKNOWN      = 1 << 22,
  };
  struct singleLine {
-Line 99 
 struct singleEntry {
+Line 118 
 struct singleEntry {
  #define NEED_TITLE   (1 << 2)
  #define NEED_ARGS    (1 << 3)
  #define NEED_MB      (1 << 4)
+ #define NEED_END     (1 << 5)
  #define MAIN_DEFAULT	    (1 << 0)
  #define DEFAULT_SAVED       -2
+ #define DEFAULT_SAVED_GRUB2 -3
  struct keywordTypes {
      char * key;
-Line 110 
 struct keywordTypes {
+Line 131 
 struct keywordTypes {
      char separatorChar;
  };
+ struct configFileInfo;
+ typedef const char *(*findConfigFunc)(struct configFileInfo *);
+ typedef const int (*writeLineFunc)(struct configFileInfo *,
+ 				struct singleLine *line);
+ typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
+ typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
  struct configFileInfo {
      char * defaultConfig;
+     findConfigFunc findConfig;
+     writeLineFunc writeLine;
+     getEnvFunc getEnv;
+     setEnvFunc setEnv;
      struct keywordTypes * keywords;
+     int caseInsensitive;
      int defaultIsIndex;
+     int defaultIsVariable;
      int defaultSupportSaved;
-     enum lineType_e entrySeparator;
+     int defaultIsSaved;
+     enum lineType_e entryStart;
+     enum lineType_e entryEnd;
      int needsBootPrefix;
      int argsInQuotes;
      int maxTitleLength;
      int titleBracketed;
+     int titlePosition;
      int mbHyperFirst;
      int mbInitRdIsModule;
      int mbConcatArgs;
      int mbAllowExtraInitRds;
+     char *envFile;
  };
  struct keywordTypes grubKeywords[] = {
-Line 138 
 struct keywordTypes grubKeywords[] = {
+Line 177 
 struct keywordTypes grubKeywords[] = {
      { NULL,	    0, 0 },
  };
+ const char *grubFindConfig(struct configFileInfo *cfi) {
+     static const char *configFiles[] = {
+ 	"/boot/grub/grub.conf",
+ 	"/boot/grub/menu.lst",
+ 	"/etc/grub.conf",
+ 	NULL
+     };
+     static int i = -1;
+     if (i == -1) {
+ 	for (i = 0; configFiles[i] != NULL; i++) {
+ 	    dbgPrintf("Checking \"%s\": ", configFiles[i]);
+ 	    if (!access(configFiles[i], R_OK)) {
+ 		dbgPrintf("found\n");
+ 		return configFiles[i];
+ 	    }
+ 	    dbgPrintf("not found\n");
+ 	}
+     }
+     return configFiles[i];
+ }
  struct configFileInfo grubConfigType = {
-     "/boot/grub/grub.conf",			    /* defaultConfig */
+     .findConfig = grubFindConfig,
-     grubKeywords,			    /* keywords */
+     .keywords = grubKeywords,
-,					    /* defaultIsIndex */
+     .defaultIsIndex = 1,
-,					    /* defaultSupportSaved */
+     .defaultSupportSaved = 1,
-     LT_TITLE,				    /* entrySeparator */
+     .entryStart = LT_TITLE,
-,					    /* needsBootPrefix */
+     .needsBootPrefix = 1,
-,					    /* argsInQuotes */
+     .mbHyperFirst = 1,
-,					    /* maxTitleLength */
+     .mbInitRdIsModule = 1,
-,                                      /* titleBracketed */
+     .mbAllowExtraInitRds = 1,
-,                                      /* mbHyperFirst */
+ };
-,                                      /* mbInitRdIsModule */
-,                                      /* mbConcatArgs */
+ struct keywordTypes grub2Keywords[] = {
-,                                      /* mbAllowExtraInitRds */
+     { "menuentry",  LT_MENUENTRY,   ' ' },
+     { "}",          LT_ENTRY_END,   ' ' },
+     { "echo",       LT_ECHO,        ' ' },
+     { "set",        LT_SET_VARIABLE,' ', '=' },
+     { "root",       LT_BOOTROOT,    ' ' },
+     { "default",    LT_DEFAULT,     ' ' },
+     { "fallback",   LT_FALLBACK,    ' ' },
+     { "linux",      LT_KERNEL,      ' ' },
+     { "linuxefi",   LT_KERNEL_EFI,  ' ' },
+     { "initrd",     LT_INITRD,      ' ', ' ' },
+     { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
+     { "module",     LT_MBMODULE,    ' ' },
+     { "kernel",     LT_HYPER,       ' ' },
+     { NULL, 0, 0 },
+ };
+ const char *grub2FindConfig(struct configFileInfo *cfi) {
+     static const char *configFiles[] = {
+ 	"/boot/grub/grub-efi.cfg",
+ 	"/boot/grub/grub.cfg",
+ 	NULL
+     };
+     static int i = -1;
+     static const char *grub_cfg = "/boot/grub/grub.cfg";
+     int rc = -1;
+     if (i == -1) {
+ 	for (i = 0; configFiles[i] != NULL; i++) {
+ 	    dbgPrintf("Checking \"%s\": ", configFiles[i]);
+ 	    if ((rc = access(configFiles[i], R_OK))) {
+ 		if (errno == EACCES) {
+ 		    printf("Unable to access bootloader configuration file "
+ 		    	   "\"%s\": %m\n", configFiles[i]);
+ 		    exit(1);
+ 		}
+ 		continue;
+ 	    } else {
+ 		dbgPrintf("found\n");
+ 		return configFiles[i];
+ 	    }
+ 	}
+     }
+     /* Ubuntu renames grub2 to grub, so check for the grub.d directory
+      * that isn't in grub1, and if it exists, return the config file path
+      * that they use. */
+     if (configFiles[i] == NULL && !access("/etc/grub.d/", R_OK)) {
+ 	dbgPrintf("found\n");
+ 	return grub_cfg;
+     }
+     dbgPrintf("not found\n");
+     return configFiles[i];
+ }
+ /* kind of hacky.  It'll give the first 1024 bytes, ish. */
+ static char *grub2GetEnv(struct configFileInfo *info, char *name)
+ {
+     static char buf[1025];
+     char *s = NULL;
+     char *ret = NULL;
+     char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";
+     int rc = asprintf(&s, "grub2-editenv %s list | grep '^%s='", envFile, name);
+     if (rc < 0)
+ 	return NULL;
+     FILE *f = popen(s, "r");
+     if (!f)
+ 	goto out;
+     memset(buf, '\0', sizeof (buf));
+     ret = fgets(buf, 1024, f);
+     pclose(f);
+     if (ret) {
+ 	ret += strlen(name) + 1;
+ 	ret[strlen(ret) - 1] = '\0';
+     }
+     dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
+ out:
+     free(s);
+     return ret;
+ }
+ static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
+ {
+     char *s = NULL;
+     int rc = 0;
+     char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";
+     rc = asprintf(&s, "grub2-editenv %s set '%s=%s'", envFile, name, value);
+     if (rc <0)
+ 	return -1;
+     dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
+     rc = system(s);
+     free(s);
+     return rc;
+ }
+ /* this is a gigantic hack to avoid clobbering grub2 variables... */
+ static int is_special_grub2_variable(const char *name)
+ {
+     if (!strcmp(name,"\"${next_entry}\""))
+ 	return 1;
+     if (!strcmp(name,"\"${prev_saved_entry}\""))
+ 	return 1;
+     return 0;
+ }
+ int sizeOfSingleLine(struct singleLine * line) {
+   int count = 0;
+   for (int i = 0; i < line->numElements; i++) {
+     int indentSize = 0;
+     count = count + strlen(line->elements[i].item);
+     indentSize = strlen(line->elements[i].indent);
+     if (indentSize > 0)
+       count = count + indentSize;
+     else
+       /* be extra safe and add room for whitespaces */
+       count = count + 1;
+   }
+   /* room for trailing terminator */
+   count = count + 1;
+   return count;
+ }
+ static int isquote(char q)
+ {
+     if (q == '\'' || q == '\"')
+ 	return 1;
+     return 0;
+ }
+ static int iskernel(enum lineType_e type) {
+     return (type == LT_KERNEL || type == LT_KERNEL_EFI);
+ }
+ static int isinitrd(enum lineType_e type) {
+     return (type == LT_INITRD || type == LT_INITRD_EFI);
+ }
+ char *grub2ExtractTitle(struct singleLine * line) {
+     char * current;
+     char * current_indent;
+     int current_len;
+     int current_indent_len;
+     int i;
+     /* bail out if line does not start with menuentry */
+     if (strcmp(line->elements[0].item, "menuentry"))
+       return NULL;
+     i = 1;
+     current = line->elements[i].item;
+     current_len = strlen(current);
+     /* if second word is quoted, strip the quotes and return single word */
+     if (isquote(*current) && isquote(current[current_len - 1])) {
+ 	char *tmp;
+ 	tmp = strdup(current);
+ 	*(tmp + current_len - 1) = '\0';
+ 	return ++tmp;
+     }
+     /* if no quotes, return second word verbatim */
+     if (!isquote(*current))
+ 	return current;
+     /* second element start with a quote, so we have to find the element
+      * whose last character is also quote (assuming it's the closing one) */
+     int resultMaxSize;
+     char * result;
+     resultMaxSize = sizeOfSingleLine(line);
+     result = malloc(resultMaxSize);
+     snprintf(result, resultMaxSize, "%s", ++current);
+     i++;
+     for (; i < line->numElements; ++i) {
+ 	current = line->elements[i].item;
+ 	current_len = strlen(current);
+ 	current_indent = line->elements[i].indent;
+ 	current_indent_len = strlen(current_indent);
+ 	strncat(result, current_indent, current_indent_len);
+ 	if (!isquote(current[current_len-1])) {
+ 	    strncat(result, current, current_len);
+ 	} else {
+ 	    strncat(result, current, current_len - 1);
+ 	    break;
+ 	}
+     }
+     return result;
+ }
+ struct configFileInfo grub2ConfigType = {
+     .findConfig = grub2FindConfig,
+     .getEnv = grub2GetEnv,
+     .setEnv = grub2SetEnv,
+     .keywords = grub2Keywords,
+     .defaultIsIndex = 1,
+     .defaultSupportSaved = 1,
+     .defaultIsVariable = 1,
+     .entryStart = LT_MENUENTRY,
+     .entryEnd = LT_ENTRY_END,
+     .titlePosition = 1,
+     .needsBootPrefix = 1,
+     .mbHyperFirst = 1,
+     .mbInitRdIsModule = 1,
+     .mbAllowExtraInitRds = 1,
  };
  struct keywordTypes yabootKeywords[] = {
-Line 249 
 struct keywordTypes extlinuxKeywords[] =
+Line 527 
 struct keywordTypes extlinuxKeywords[] =
  };
  int useextlinuxmenu;
  struct configFileInfo eliloConfigType = {
-     "/boot/efi/EFI/redhat/elilo.conf",	    /* defaultConfig */
+     .defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",
-     eliloKeywords,			    /* keywords */
+     .keywords = eliloKeywords,
-,					    /* defaultIsIndex */
+     .entryStart = LT_KERNEL,
-,					    /* defaultSupportSaved */
+     .needsBootPrefix = 1,
-     LT_KERNEL,				    /* entrySeparator */
+     .argsInQuotes = 1,
-,			                    /* needsBootPrefix */
+     .mbConcatArgs = 1,
-,					    /* argsInQuotes */
-,					    /* maxTitleLength */
-,                                      /* titleBracketed */
-,                                      /* mbHyperFirst */
-,                                      /* mbInitRdIsModule */
-,                                      /* mbConcatArgs */
-,                                      /* mbAllowExtraInitRds */
  };
  struct configFileInfo liloConfigType = {
-     "/etc/lilo.conf",			    /* defaultConfig */
+     .defaultConfig = "/etc/lilo.conf",
-     liloKeywords,			    /* keywords */
+     .keywords = liloKeywords,
-,					    /* defaultIsIndex */
+     .entryStart = LT_KERNEL,
-,					    /* defaultSupportSaved */
+     .argsInQuotes = 1,
-     LT_KERNEL,				    /* entrySeparator */
+     .maxTitleLength = 15,
-,					    /* needsBootPrefix */
-,					    /* argsInQuotes */
-,					    /* maxTitleLength */
-,                                      /* titleBracketed */
-,                                      /* mbHyperFirst */
-,                                      /* mbInitRdIsModule */
-,                                      /* mbConcatArgs */
-,                                      /* mbAllowExtraInitRds */
  };
  struct configFileInfo yabootConfigType = {
-     "/etc/yaboot.conf",			    /* defaultConfig */
+     .defaultConfig = "/etc/yaboot.conf",
-     yabootKeywords,			    /* keywords */
+     .keywords = yabootKeywords,
-,					    /* defaultIsIndex */
+     .entryStart = LT_KERNEL,
-,					    /* defaultSupportSaved */
+     .needsBootPrefix = 1,
-     LT_KERNEL,				    /* entrySeparator */
+     .argsInQuotes = 1,
-,					    /* needsBootPrefix */
+     .maxTitleLength = 15,
-,					    /* argsInQuotes */
+     .mbAllowExtraInitRds = 1,
-,					    /* maxTitleLength */
-,                                      /* titleBracketed */
-,                                      /* mbHyperFirst */
-,                                      /* mbInitRdIsModule */
-,                                      /* mbConcatArgs */
-,                                      /* mbAllowExtraInitRds */
  };
  struct configFileInfo siloConfigType = {
-     "/etc/silo.conf",			    /* defaultConfig */
+     .defaultConfig = "/etc/silo.conf",
-     siloKeywords,			    /* keywords */
+     .keywords = siloKeywords,
-,					    /* defaultIsIndex */
+     .entryStart = LT_KERNEL,
-,					    /* defaultSupportSaved */
+     .needsBootPrefix = 1,
-     LT_KERNEL,				    /* entrySeparator */
+     .argsInQuotes = 1,
-,					    /* needsBootPrefix */
+     .maxTitleLength = 15,
-,					    /* argsInQuotes */
-,					    /* maxTitleLength */
-,                                      /* titleBracketed */
-,                                      /* mbHyperFirst */
-,                                      /* mbInitRdIsModule */
-,                                      /* mbConcatArgs */
-,                                      /* mbAllowExtraInitRds */
  };
  struct configFileInfo ziplConfigType = {
-     "/etc/zipl.conf",			    /* defaultConfig */
+     .defaultConfig = "/etc/zipl.conf",
-     ziplKeywords,			    /* keywords */
+     .keywords = ziplKeywords,
-,					    /* defaultIsIndex */
+     .entryStart = LT_TITLE,
-,					    /* defaultSupportSaved */
+     .argsInQuotes = 1,
-     LT_TITLE,				    /* entrySeparator */
+     .titleBracketed = 1,
-,					    /* needsBootPrefix */
-,					    /* argsInQuotes */
-,					    /* maxTitleLength */
-,                                      /* titleBracketed */
-,                                      /* mbHyperFirst */
-,                                      /* mbInitRdIsModule */
-,                                      /* mbConcatArgs */
-,                                      /* mbAllowExtraInitRds */
  };
  struct configFileInfo extlinuxConfigType = {
-     "/boot/extlinux/extlinux.conf",         /* defaultConfig */
+     .defaultConfig = "/boot/extlinux/extlinux.conf",
-     extlinuxKeywords,                       /* keywords */
+     .keywords = extlinuxKeywords,
-,                                      /* defaultIsIndex */
+     .caseInsensitive = 1,
-,                                      /* defaultSupportSaved */
+     .entryStart = LT_TITLE,
-     LT_TITLE,                               /* entrySeparator */
+     .needsBootPrefix = 1,
-,                                      /* needsBootPrefix */
+     .maxTitleLength = 255,
-,                                      /* argsInQuotes */
+     .mbAllowExtraInitRds = 1,
-,                                    /* maxTitleLength */
-,                                      /* titleBracketed */
-,                                      /* mbHyperFirst */
-,                                      /* mbInitRdIsModule */
-,                                      /* mbConcatArgs */
-,                                      /* mbAllowExtraInitRds */
  };
  struct grubConfig {
-Line 356 
 struct grubConfig {
+Line 592 
 struct grubConfig {
      struct configFileInfo * cfi;
  };
+ blkid_cache blkid;
  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);
  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
  				     const char * path, const char * prefix,
  				     int * index);
+ struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
+ 				      int * index);
  static int readFile(int fd, char ** bufPtr);
  static void lineInit(struct singleLine * line);
  struct singleLine * lineDup(struct singleLine * line);
-Line 369 
 static int lineWrite(FILE * out, struct
+Line 609 
 static int lineWrite(FILE * out, struct
  static int getNextLine(char ** bufPtr, struct singleLine * line,
  		       struct configFileInfo * cfi);
  static char * getRootSpecifier(char * str);
+ static void requote(struct singleLine *line, struct configFileInfo * cfi);
  static void insertElement(struct singleLine * line,
  			  const char * item, int insertHere,
  			  struct configFileInfo * cfi);
-Line 423 
 static char * sdupprintf(const char *for
+Line 664 
 static char * sdupprintf(const char *for
      return buf;
  }
+ static enum lineType_e preferredLineType(enum lineType_e type,
+ 					 struct configFileInfo *cfi) {
+     if (isEfi && cfi == &grub2ConfigType) {
+ 	switch (type) {
+ 	case LT_KERNEL:
+ 	    return LT_KERNEL_EFI;
+ 	case LT_INITRD:
+ 	    return LT_INITRD_EFI;
+ 	default:
+ 	    return type;
+ 	}
+     }
+     return type;
+ }
  static struct keywordTypes * getKeywordByType(enum lineType_e type,
  					      struct configFileInfo * cfi) {
-     struct keywordTypes * kw;
+     for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
-     for (kw = cfi->keywords; kw->key; kw++) {
  	if (kw->type == type)
  	    return kw;
      }
      return NULL;
  }
- static char * getpathbyspec(char *device) {
+ static char *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {
-     static blkid_cache blkid;
+     struct keywordTypes *kt = getKeywordByType(type, cfi);
+     if (kt)
+ 	return kt->key;
+     return "unknown";
+ }
+ static char * getpathbyspec(char *device) {
      if (!blkid)
          blkid_get_cache(&blkid, NULL);
      return blkid_get_devname(blkid, device, NULL);
  }
+ static char * getuuidbydev(char *device) {
+     if (!blkid)
+ 	blkid_get_cache(&blkid, NULL);
+     return blkid_get_tag_value(blkid, "UUID", device);
+ }
  static enum lineType_e getTypeByKeyword(char * keyword,
  					struct configFileInfo * cfi) {
-     struct keywordTypes * kw;
+     for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
-     for (kw = cfi->keywords; kw->key; kw++) {
+ 	if (cfi->caseInsensitive) {
- 	if (!strcmp(keyword, kw->key))
+ 	    if (!strcasecmp(keyword, kw->key))
- 	    return kw->type;
+                 return kw->type;
+ 	} else {
+ 	    if (!strcmp(keyword, kw->key))
+ 	        return kw->type;
+ 	}
      }
      return LT_UNKNOWN;
  }
-Line 477 
 static int isBracketedTitle(struct singl
+Line 748 
 static int isBracketedTitle(struct singl
      return 0;
  }
- static int isEntrySeparator(struct singleLine * line,
+ static int isEntryStart(struct singleLine * line,
                              struct configFileInfo * cfi) {
-     return line->type == cfi->entrySeparator || line->type == LT_OTHER ||
+     return line->type == cfi->entryStart || line->type == LT_OTHER ||
  	(cfi->titleBracketed && isBracketedTitle(line));
  }
  /* extract the title from within brackets (for zipl) */
  static char * extractTitle(struct singleLine * line) {
      /* bracketed title... let's extract it (leaks a byte) */
-     char * title;
+     char * title = NULL;
-     title = strdup(line->elements[0].item);
+     if (line->type == LT_TITLE) {
-     title++;
+ 	title = strdup(line->elements[0].item);
-     *(title + strlen(title) - 1) = '\0';
+ 	title++;
+ 	*(title + strlen(title) - 1) = '\0';
+     } else if (line->type == LT_MENUENTRY)
+ 	title = strdup(line->elements[1].item);
+     else
+ 	return NULL;
      return title;
  }
-Line 532 
 static void lineInit(struct singleLine *
+Line 808 
 static void lineInit(struct singleLine *
  }
  struct singleLine * lineDup(struct singleLine * line) {
-     int i;
      struct singleLine * newLine = malloc(sizeof(*newLine));
      newLine->indent = strdup(line->indent);
-Line 542 
 struct singleLine * lineDup(struct singl
+Line 817 
 struct singleLine * lineDup(struct singl
      newLine->elements = malloc(sizeof(*newLine->elements) *
  			       newLine->numElements);
-     for (i = 0; i < newLine->numElements; i++) {
+     for (int i = 0; i < newLine->numElements; i++) {
  	newLine->elements[i].indent = strdup(line->elements[i].indent);
  	newLine->elements[i].item = strdup(line->elements[i].item);
      }
-Line 551 
 struct singleLine * lineDup(struct singl
+Line 826 
 struct singleLine * lineDup(struct singl
  }
  static void lineFree(struct singleLine * line) {
-     int i;
      if (line->indent) free(line->indent);
-     for (i = 0; i < line->numElements; i++) {
+     for (int i = 0; i < line->numElements; i++) {
  	free(line->elements[i].item);
  	free(line->elements[i].indent);
      }
-Line 566 
 static void lineFree(struct singleLine *
+Line 839 
 static void lineFree(struct singleLine *
  static int lineWrite(FILE * out, struct singleLine * line,
  		     struct configFileInfo * cfi) {
-     int i;
      if (fprintf(out, "%s", line->indent) == -1) return -1;
-     for (i = 0; i < line->numElements; i++) {
+     for (int i = 0; i < line->numElements; i++) {
+ 	/* Need to handle this, because we strip the quotes from
+ 	 * menuentry when read it. */
+ 	if (line->type == LT_MENUENTRY && i == 1) {
+ 	    if(!isquote(*line->elements[i].item))
+ 		fprintf(out, "\'%s\'", line->elements[i].item);
+ 	    else
+ 		fprintf(out, "%s", line->elements[i].item);
+ 	    fprintf(out, "%s", line->elements[i].indent);
+ 	    continue;
+ 	}
  	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
  	    if (fputc('"', out) == EOF) return -1;
-Line 664 
 static int getNextLine(char ** bufPtr, s
+Line 947 
 static int getNextLine(char ** bufPtr, s
  	    if (*line->elements[0].item == '#') {
  		char * fullLine;
  		int len;
- 		int i;
  		len = strlen(line->indent);
- 		for (i = 0; i < line->numElements; i++)
+ 		for (int i = 0; i < line->numElements; i++)
  		    len += strlen(line->elements[i].item) +
  			   strlen(line->elements[i].indent);
-Line 676 
 static int getNextLine(char ** bufPtr, s
+Line 958 
 static int getNextLine(char ** bufPtr, s
  		free(line->indent);
  		line->indent = fullLine;
- 		for (i = 0; i < line->numElements; i++) {
+ 		for (int i = 0; i < line->numElements; i++) {
  		    strcat(fullLine, line->elements[i].item);
  		    strcat(fullLine, line->elements[i].indent);
  		    free(line->elements[i].item);
-Line 695 
 static int getNextLine(char ** bufPtr, s
+Line 977 
 static int getNextLine(char ** bufPtr, s
  		 * elements up more
  		 */
  		if (!isspace(kw->separatorChar)) {
- 		    int i;
  		    char indent[2] = "";
  		    indent[0] = kw->separatorChar;
- 		    for (i = 1; i < line->numElements; i++) {
+ 		    for (int i = 1; i < line->numElements; i++) {
  			char *p;
- 			int j;
  			int numNewElements;
  			numNewElements = 0;
-Line 716 
 static int getNextLine(char ** bufPtr, s
+Line 996 
 static int getNextLine(char ** bufPtr, s
  					    sizeof(*line->elements) * elementsAlloced);
  			}
- 			for (j = line->numElements; j > i; j--) {
+ 			for (int j = line->numElements; j > i; j--) {
  				line->elements[j + numNewElements] = line->elements[j];
  			}
  			line->numElements += numNewElements;
-Line 729 
 static int getNextLine(char ** bufPtr, s
+Line 1009 
 static int getNextLine(char ** bufPtr, s
  					break;
  				}
- 				free(line->elements[i].indent);
+ 				line->elements[i + 1].indent = line->elements[i].indent;
  				line->elements[i].indent = strdup(indent);
  				*p++ = '\0';
  				i++;
  				line->elements[i].item = strdup(p);
- 				line->elements[i].indent = strdup("");
- 				p = line->elements[i].item;
  			}
  		    }
  		}
-Line 756 
 static struct grubConfig * readConfig(co
+Line 1034 
 static struct grubConfig * readConfig(co
      struct singleLine * last = NULL, * line, * defaultLine = NULL;
      char * end;
      struct singleEntry * entry = NULL;
-     int i, len;
+     int len;
      char * buf;
-     if (!strcmp(inName, "-")) {
+     if (inName == NULL) {
+         printf("Could not find bootloader configuration\n");
+         exit(1);
+     } else if (!strcmp(inName, "-")) {
  	in = 0;
      } else {
  	if ((in = open(inName, O_RDONLY)) < 0) {
-Line 802 
 static struct grubConfig * readConfig(co
+Line 1083 
 static struct grubConfig * readConfig(co
  	    cfg->secondaryIndent = strdup(line->indent);
  	}
- 	if (isEntrySeparator(line, cfi)) {
+ 	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
  	    sawEntry = 1;
  	    if (!entry) {
  		cfg->entries = malloc(sizeof(*entry));
-Line 818 
 static struct grubConfig * readConfig(co
+Line 1099 
 static struct grubConfig * readConfig(co
  	    entry->next = NULL;
  	}
- 	if (line->type == LT_DEFAULT && line->numElements == 2) {
+ 	if (line->type == LT_SET_VARIABLE) {
+ 	    dbgPrintf("found 'set' command (%d elements): ", line->numElements);
+ 	    dbgPrintf("%s", line->indent);
+ 	    for (int i = 0; i < line->numElements; i++)
+ 		dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
+ 	    dbgPrintf("\n");
+ 	    struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
+ 	    if (kwType && line->numElements == 3 &&
+ 		    !strcmp(line->elements[1].item, kwType->key) &&
+ 		    !is_special_grub2_variable(line->elements[2].item)) {
+ 		dbgPrintf("Line sets default config\n");
+ 		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
+ 		defaultLine = line;
+ 	    }
+ 	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
  	    cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
  	    defaultLine = line;
-         } else if (line->type == LT_KERNEL) {
+         } else if (iskernel(line->type)) {
  	    /* if by some freak chance this is multiboot and the "module"
  	     * lines came earlier in the template, make sure to use LT_HYPER
  	     * instead of LT_KERNEL now
-Line 836 
 static struct grubConfig * readConfig(co
+Line 1131 
 static struct grubConfig * readConfig(co
  	     * This only applies to grub, but that's the only place we
  	     * should find LT_MBMODULE lines anyway.
  	     */
- 	    struct singleLine * l;
+ 	    for (struct singleLine *l = entry->lines; l; l = l->next) {
- 	    for (l = entry->lines; l; l = l->next) {
  		if (l->type == LT_HYPER)
  		    break;
- 		else if (l->type == LT_KERNEL) {
+ 		else if (iskernel(l->type)) {
  		    l->type = LT_HYPER;
  		    break;
  		}
-Line 857 
 static struct grubConfig * readConfig(co
+Line 1151 
 static struct grubConfig * readConfig(co
  	} else if (line->type == LT_TITLE && line->numElements > 1) {
  	    /* make the title a single argument (undoing our parsing) */
  	    len = 0;
- 	    for (i = 1; i < line->numElements; i++) {
+ 	    for (int i = 1; i < line->numElements; i++) {
  		len += strlen(line->elements[i].item);
  		len += strlen(line->elements[i].indent);
  	    }
  	    buf = malloc(len + 1);
  	    *buf = '\0';
- 	    for (i = 1; i < line->numElements; i++) {
+ 	    for (int i = 1; i < line->numElements; i++) {
  		strcat(buf, line->elements[i].item);
  		free(line->elements[i].item);
-Line 878 
 static struct grubConfig * readConfig(co
+Line 1172 
 static struct grubConfig * readConfig(co
  		    line->elements[line->numElements - 1].indent;
  	    line->elements[1].item = buf;
  	    line->numElements = 2;
+ 	} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
+ 	    /* let --remove-kernel="TITLE=what" work */
+ 	    len = 0;
+ 	    char *extras;
+ 	    char *title;
+ 	    for (int i = 1; i < line->numElements; i++) {
+ 		len += strlen(line->elements[i].item);
+ 		len += strlen(line->elements[i].indent);
+ 	    }
+ 	    buf = malloc(len + 1);
+ 	    *buf = '\0';
+ 	    /* allocate mem for extra flags. */
+ 	    extras = malloc(len + 1);
+ 	    *extras = '\0';
+ 	    /* get title. */
+ 	    for (int i = 0; i < line->numElements; i++) {
+ 		if (!strcmp(line->elements[i].item, "menuentry"))
+ 		    continue;
+ 		if (isquote(*line->elements[i].item))
+ 		    title = line->elements[i].item + 1;
+ 		else
+ 		    title = line->elements[i].item;
+ 		len = strlen(title);
+ 	        if (isquote(title[len-1])) {
+ 		    strncat(buf, title,len-1);
+ 		    break;
+ 		} else {
+ 		    strcat(buf, title);
+ 		    strcat(buf, line->elements[i].indent);
+ 		}
+ 	    }
+ 	    /* get extras */
+ 	    int count = 0;
+ 	    for (int i = 0; i < line->numElements; i++) {
+ 		if (count >= 2) {
+ 		    strcat(extras, line->elements[i].item);
+ 		    strcat(extras, line->elements[i].indent);
+ 		}
+ 		if (!strcmp(line->elements[i].item, "menuentry"))
+ 		    continue;
+ 		/* count ' or ", there should be two in menuentry line. */
+ 		if (isquote(*line->elements[i].item))
+ 		    count++;
+ 		len = strlen(line->elements[i].item);
+ 		if (isquote(line->elements[i].item[len -1]))
+ 		    count++;
+ 		/* ok, we get the final ' or ", others are extras. */
+             }
+ 	    line->elements[1].indent =
+ 		line->elements[line->numElements - 2].indent;
+ 	    line->elements[1].item = buf;
+ 	    line->elements[2].indent =
+ 		line->elements[line->numElements - 2].indent;
+ 	    line->elements[2].item = extras;
+ 	    line->numElements = 3;
  	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
  	    /* Strip off any " which may be present; they'll be put back
  	       on write. This is one of the few (the only?) places that grubby
-Line 887 
 static struct grubConfig * readConfig(co
+Line 1245 
 static struct grubConfig * readConfig(co
  	    if (line->numElements >= 2) {
  		int last, len;
- 		if (*line->elements[1].item == '"')
+ 		if (isquote(*line->elements[1].item))
  		    memmove(line->elements[1].item, line->elements[1].item + 1,
  			    strlen(line->elements[1].item + 1) + 1);
  		last = line->numElements - 1;
  		len = strlen(line->elements[last].item) - 1;
- 		if (line->elements[last].item[len] == '"')
+ 		if (isquote(line->elements[last].item[len]))
  		    line->elements[last].item[len] = '\0';
  	    }
  	}
-Line 931 
 static struct grubConfig * readConfig(co
+Line 1289 
 static struct grubConfig * readConfig(co
  		entry->lines = line;
  	    else
  		last->next = line;
- 	    dbgPrintf("readConfig added %d to %p\n", line->type, entry);
+ 	    dbgPrintf("readConfig added %s to %p\n", getKeyByType(line->type, cfi), entry);
+ 	    /* we could have seen this outside of an entry... if so, we
+ 	     * ignore it like any other line we don't grok */
+ 	    if (line->type == LT_ENTRY_END && sawEntry)
+ 		sawEntry = 0;
  	} else {
  	    if (!cfg->theLines)
  		cfg->theLines = line;
  	    else
  		last->next = line;
- 	    dbgPrintf("readConfig added %d to cfg\n", line->type);
+ 	    dbgPrintf("readConfig added %s to cfg\n", getKeyByType(line->type, cfi));
  	}
  	last = line;
-Line 945 
 static struct grubConfig * readConfig(co
+Line 1308 
 static struct grubConfig * readConfig(co
      free(incoming);
+     dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
      if (defaultLine) {
- 	if (cfi->defaultSupportSaved &&
+         if (defaultLine->numElements > 2 &&
+ 	    cfi->defaultSupportSaved &&
+ 	    !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
+ 		cfg->cfi->defaultIsSaved = 1;
+ 		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
+ 		if (cfg->cfi->getEnv) {
+ 		    char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
+ 		    if (defTitle) {
+ 			int index = 0;
+ 			entry = findEntryByTitle(cfg, defTitle, &index);
+ 			if (entry)
+ 			    cfg->defaultImage = index;
+ 		    }
+ 		}
+ 	} else if (cfi->defaultIsVariable) {
+ 	    char *value = defaultLine->elements[2].item;
+ 	    while (*value && (*value == '"' || *value == '\'' ||
+ 		    *value == ' ' || *value == '\t'))
+ 		value++;
+ 	    cfg->defaultImage = strtol(value, &end, 10);
+ 	    while (*end && (*end == '"' || *end == '\'' ||
+ 		    *end == ' ' || *end == '\t'))
+ 		end++;
+ 	    if (*end) cfg->defaultImage = -1;
+ 	} else if (cfi->defaultSupportSaved &&
  		!strncmp(defaultLine->elements[1].item, "saved", 5)) {
  	    cfg->defaultImage = DEFAULT_SAVED;
  	} else if (cfi->defaultIsIndex) {
  	    cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
  	    if (*end) cfg->defaultImage = -1;
  	} else if (defaultLine->numElements >= 2) {
- 	    i = 0;
+ 	    int i = 0;
  	    while ((entry = findEntryByIndex(cfg, i))) {
  		for (line = entry->lines; line; line = line->next)
  		    if (line->type == LT_TITLE) break;
-Line 976 
 static struct grubConfig * readConfig(co
+Line 1364 
 static struct grubConfig * readConfig(co
  	        cfg->defaultImage = -1;
  	    }
  	}
+     } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
+ 	char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
+ 	if (defTitle) {
+ 	    int index = 0;
+ 	    entry = findEntryByTitle(cfg, defTitle, &index);
+ 	    if (entry)
+ 		cfg->defaultImage = index;
+ 	}
      } else {
          cfg->defaultImage = 0;
      }
-Line 993 
 static void writeDefault(FILE * out, cha
+Line 1389 
 static void writeDefault(FILE * out, cha
      if (cfg->defaultImage == DEFAULT_SAVED)
  	fprintf(out, "%sdefault%ssaved\n", indent, separator);
-     else if (cfg->defaultImage > -1) {
+     else if (cfg->cfi->defaultIsSaved) {
+ 	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
+ 	if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
+ 	    char *title;
+ 	    entry = findEntryByIndex(cfg, cfg->defaultImage);
+ 	    line = getLineByType(LT_MENUENTRY, entry->lines);
+ 	    if (!line)
+ 		line = getLineByType(LT_TITLE, entry->lines);
+ 	    if (line) {
+ 		title = extractTitle(line);
+ 		if (title)
+ 		    cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
+ 	    }
+ 	}
+     } else if (cfg->defaultImage > -1) {
  	if (cfg->cfi->defaultIsIndex) {
- 	    fprintf(out, "%sdefault%s%d\n", indent, separator,
+ 	    if (cfg->cfi->defaultIsVariable) {
- 		    cfg->defaultImage);
+ 	        fprintf(out, "%sset default=\"%d\"\n", indent,
+ 			cfg->defaultImage);
+ 	    } else {
+ 		fprintf(out, "%sdefault%s%d\n", indent, separator,
+ 			cfg->defaultImage);
+ 	    }
  	} else {
  	    int image = cfg->defaultImage;
-Line 1048 
 static int writeConfig(struct grubConfig
+Line 1463 
 static int writeConfig(struct grubConfig
  	    /* most likely the symlink is relative, so change our
  	       directory to the dir of the symlink */
-             rc = chdir(dirname(strdupa(outName)));
+ 	    char *dir = strdupa(outName);
+ 	    rc = chdir(dirname(dir));
  	    do {
  		buf = alloca(len + 1);
  		rc = readlink(basename(outName), buf, len);
-Line 1086 
 static int writeConfig(struct grubConfig
+Line 1502 
 static int writeConfig(struct grubConfig
      }
      line = cfg->theLines;
+     struct keywordTypes *defaultKw = getKeywordByType(LT_DEFAULT, cfg->cfi);
      while (line) {
- 	if (line->type == LT_DEFAULT) {
+         if (line->type == LT_SET_VARIABLE && defaultKw &&
+ 		line->numElements == 3 &&
+ 		!strcmp(line->elements[1].item, defaultKw->key) &&
+ 		!is_special_grub2_variable(line->elements[2].item)) {
+ 	    writeDefault(out, line->indent, line->elements[0].indent, cfg);
+ 	    needs &= ~MAIN_DEFAULT;
+ 	} else if (line->type == LT_DEFAULT) {
  	    writeDefault(out, line->indent, line->elements[0].indent, cfg);
  	    needs &= ~MAIN_DEFAULT;
  	} else if (line->type == LT_FALLBACK) {
-Line 1155 
 static int numEntries(struct grubConfig
+Line 1578 
 static int numEntries(struct grubConfig
      return i;
  }
+ static char *findDiskForRoot()
+ {
+     int fd;
+     char buf[65536];
+     char *devname;
+     char *chptr;
+     int rc;
+     if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
+         fprintf(stderr, "grubby: failed to open %s: %s\n",
+                 _PATH_MOUNTED, strerror(errno));
+         return NULL;
+     }
+     rc = read(fd, buf, sizeof(buf) - 1);
+     if (rc <= 0) {
+         fprintf(stderr, "grubby: failed to read %s: %s\n",
+                 _PATH_MOUNTED, strerror(errno));
+         close(fd);
+         return NULL;
+     }
+     close(fd);
+     buf[rc] = '\0';
+     chptr = buf;
+     char *foundanswer = NULL;
+     while (chptr && chptr != buf+rc) {
+         devname = chptr;
+         /*
+          * The first column of a mtab entry is the device, but if the entry is a
+          * special device it won't start with /, so move on to the next line.
+          */
+         if (*devname != '/') {
+             chptr = strchr(chptr, '\n');
+             if (chptr)
+                 chptr++;
+             continue;
+         }
+         /* Seek to the next space */
+         chptr = strchr(chptr, ' ');
+         if (!chptr) {
+             fprintf(stderr, "grubby: error parsing %s: %s\n",
+                     _PATH_MOUNTED, strerror(errno));
+             return NULL;
+         }
+         /*
+          * The second column of a mtab entry is the mount point, we are looking
+          * for '/' obviously.
+          */
+         if (*(++chptr) == '/' && *(++chptr) == ' ') {
+             /* remember the last / entry in mtab */
+            foundanswer = devname;
+         }
+         /* Next line */
+         chptr = strchr(chptr, '\n');
+         if (chptr)
+             chptr++;
+     }
+     /* Return the last / entry found */
+     if (foundanswer) {
+         chptr = strchr(foundanswer, ' ');
+         *chptr = '\0';
+         return strdup(foundanswer);
+     }
+     return NULL;
+ }
+ void printEntry(struct singleEntry * entry, FILE *f) {
+     int i;
+     struct singleLine * line;
+     for (line = entry->lines; line; line = line->next) {
+ 	log_message(f, "DBG: %s", line->indent);
+ 	for (i = 0; i < line->numElements; i++) {
+ 	    /* Need to handle this, because we strip the quotes from
+ 	     * menuentry when read it. */
+ 	    if (line->type == LT_MENUENTRY && i == 1) {
+ 		if(!isquote(*line->elements[i].item))
+ 		    log_message(f, "\'%s\'", line->elements[i].item);
+ 		else
+ 		    log_message(f, "%s", line->elements[i].item);
+ 		log_message(f, "%s", line->elements[i].indent);
+ 		continue;
+ 	    }
+ 	    log_message(f, "%s%s",
+ 		    line->elements[i].item, line->elements[i].indent);
+ 	}
+ 	log_message(f, "\n");
+     }
+ }
+ void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
+ {
+     static int once;
+     va_list argp, argq;
+     va_start(argp, fmt);
+     va_copy(argq, argp);
+     if (!once) {
+ 	log_time(NULL);
+ 	log_message(NULL, "command line: %s\n", saved_command_line);
+     }
+     log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
+     log_vmessage(NULL, fmt, argq);
+     printEntry(entry, NULL);
+     va_end(argq);
+     if (!debug) {
+ 	once = 1;
+     	va_end(argp);
+ 	return;
+     }
+     if (okay) {
+ 	va_end(argp);
+ 	return;
+     }
+     if (!once)
+ 	log_message(stderr, "DBG: command line: %s\n", saved_command_line);
+     once = 1;
+     fprintf(stderr, "DBG: Image entry failed: ");
+     vfprintf(stderr, fmt, argp);
+     printEntry(entry, stderr);
+     va_end(argp);
+ }
+ #define beginswith(s, c) ((s) && (s)[0] == (c))
+ static int endswith(const char *s, char c)
+ {
+ 	int slen;
+ 	if (!s || !s[0])
+ 		return 0;
+ 	slen = strlen(s) - 1;
+ 	return s[slen] == c;
+ }
  int suitableImage(struct singleEntry * entry, const char * bootPrefix,
  		  int skipRemoved, int flags) {
      struct singleLine * line;
      char * fullName;
      int i;
-     struct stat sb, sb2;
      char * dev;
      char * rootspec;
+     char * rootdev;
-     if (skipRemoved && entry->skip) return 0;
+     if (skipRemoved && entry->skip) {
+ 	notSuitablePrintf(entry, 0, "marked to skip\n");
+ 	return 0;
+     }
-     line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+     line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
-     if (!line || line->numElements < 2) return 0;
+     if (!line) {
+ 	notSuitablePrintf(entry, 0, "no line found\n");
+ 	return 0;
+     }
+     if (line->numElements < 2) {
+ 	notSuitablePrintf(entry, 0, "line has only %d elements\n",
+ 	    line->numElements);
+ 	return 0;
+     }
-     if (flags & GRUBBY_BADIMAGE_OKAY) return 1;
+     if (flags & GRUBBY_BADIMAGE_OKAY) {
+ 	    notSuitablePrintf(entry, 1, "\n");
+ 	    return 1;
+     }
      fullName = alloca(strlen(bootPrefix) +
  		      strlen(line->elements[1].item) + 1);
      rootspec = getRootSpecifier(line->elements[1].item);
-     sprintf(fullName, "%s%s", bootPrefix,
+     int rootspec_offset = rootspec ? strlen(rootspec) : 0;
-             line->elements[1].item + (rootspec ? strlen(rootspec) : 0));
+     int hasslash = endswith(bootPrefix, '/') ||
-     if (access(fullName, R_OK)) return 0;
+     	beginswith(line->elements[1].item + rootspec_offset, '/');
+     sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
+             line->elements[1].item + rootspec_offset);
+     if (access(fullName, R_OK)) {
+ 	notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
+ 	return 0;
+     }
      for (i = 2; i < line->numElements; i++)
  	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
      if (i < line->numElements) {
-Line 1195 
 int suitableImage(struct singleEntry * e
+Line 1788 
 int suitableImage(struct singleEntry * e
  	    line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
              /* failed to find one */
-             if (!line) return 0;
+             if (!line) {
+ 		notSuitablePrintf(entry, 0, "no line found\n");
+ 		return 0;
+             }
  	    for (i = 1; i < line->numElements; i++)
  	        if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
  	    if (i < line->numElements)
  	        dev = line->elements[i].item + 5;
  	    else {
+ 		notSuitablePrintf(entry, 0, "no root= entry found\n");
  		/* it failed too...  can't find root= */
  	        return 0;
              }
-Line 1209 
 int suitableImage(struct singleEntry * e
+Line 1806 
 int suitableImage(struct singleEntry * e
      }
      dev = getpathbyspec(dev);
-     if (!dev)
+     if (!getpathbyspec(dev)) {
+         notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
          return 0;
+     } else
+ 	dev = getpathbyspec(dev);
-     i = stat(dev, &sb);
+     rootdev = findDiskForRoot();
-     if (i)
+     if (!rootdev) {
+         notSuitablePrintf(entry, 0, "can't find root device\n");
  	return 0;
+     }
-     stat("/", &sb2);
+     if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
+         notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
+ 		getuuidbydev(rootdev), getuuidbydev(dev));
+         free(rootdev);
+         return 0;
+     }
-     if (sb.st_rdev != sb2.st_dev)
+     if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
+         notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
+ 		getuuidbydev(rootdev), getuuidbydev(dev));
+ 	free(rootdev);
          return 0;
+     }
+     free(rootdev);
+     notSuitablePrintf(entry, 1, "\n");
      return 1;
  }
-Line 1263 
 struct singleEntry * findEntryByPath(str
+Line 1877 
 struct singleEntry * findEntryByPath(str
  	entry = findEntryByIndex(config, indexVars[i]);
  	if (!entry) return NULL;
- 	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+ 	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
  	if (!line) return NULL;
  	if (index) *index = indexVars[i];
-Line 1301 
 struct singleEntry * findEntryByPath(str
+Line 1915 
 struct singleEntry * findEntryByPath(str
  	if (!strncmp(kernel, "TITLE=", 6)) {
  	    prefix = "";
- 	    checkType = LT_TITLE;
+ 	    checkType = LT_TITLE|LT_MENUENTRY;
  	    kernel += 6;
  	}
-Line 1312 
 struct singleEntry * findEntryByPath(str
+Line 1926 
 struct singleEntry * findEntryByPath(str
  	    /* check all the lines matching checkType */
  	    for (line = entry->lines; line; line = line->next) {
- 		line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?
+ 		enum lineType_e ct = checkType;
- 				     LT_KERNEL|LT_MBMODULE|LT_HYPER :
+ 		if (entry->multiboot && checkType == LT_KERNEL)
- 				     checkType, line);
+ 		    ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;
- 		if (!line) break;  /* not found in this entry */
+ 		else if (checkType & LT_KERNEL)
+ 		    ct = checkType | LT_KERNEL_EFI;
+ 		line = getLineByType(ct, line);
+ 		if (!line)
+ 		    break;  /* not found in this entry */
- 		if (line && line->numElements >= 2) {
+ 		if (line && line->type != LT_MENUENTRY &&
+ 			line->numElements >= 2) {
  		    rootspec = getRootSpecifier(line->elements[1].item);
  		    if (!strcmp(line->elements[1].item +
  				((rootspec != NULL) ? strlen(rootspec) : 0),
  				kernel + strlen(prefix)))
  			break;
  		}
+ 		if(line->type == LT_MENUENTRY &&
+ 			!strcmp(line->elements[1].item, kernel))
+ 		    break;
  	    }
  	    /* make sure this entry has a kernel identifier; this skips
  	     * non-Linux boot entries (could find netbsd etc, though, which is
  	     * unfortunate)
  	     */
- 	    if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))
+ 	    if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))
  		break; /* found 'im! */
  	}
-Line 1340 
 struct singleEntry * findEntryByPath(str
+Line 1962 
 struct singleEntry * findEntryByPath(str
      return entry;
  }
+ struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
+ 				      int * index) {
+     struct singleEntry * entry;
+     struct singleLine * line;
+     int i;
+     char * newtitle;
+     for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
+ 	if (index && i < *index)
+ 	    continue;
+ 	line = getLineByType(LT_TITLE, entry->lines);
+ 	if (!line)
+ 	    line = getLineByType(LT_MENUENTRY, entry->lines);
+ 	if (!line)
+ 	    continue;
+ 	newtitle = grub2ExtractTitle(line);
+ 	if (!newtitle)
+ 	    continue;
+ 	if (!strcmp(title, newtitle))
+ 	    break;
+     }
+     if (!entry)
+ 	return NULL;
+     if (index)
+ 	*index = i;
+     return entry;
+ }
  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
      struct singleEntry * entry;
-Line 1362 
 struct singleEntry * findTemplate(struct
+Line 2014 
 struct singleEntry * findTemplate(struct
      struct singleEntry * entry, * entry2;
      int index;
-     if (cfg->defaultImage > -1) {
+     if (cfg->cfi->defaultIsSaved) {
+ 	if (cfg->cfi->getEnv) {
+ 	    char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
+ 	    if (defTitle) {
+ 		int index = 0;
+ 		entry = findEntryByTitle(cfg, defTitle, &index);
+ 	    }
+ 	}
+     } else if (cfg->defaultImage > -1) {
  	entry = findEntryByIndex(cfg, cfg->defaultImage);
  	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
  	    if (indexPtr) *indexPtr = cfg->defaultImage;
-Line 1415 
 void markRemovedImage(struct grubConfig
+Line 2075 
 void markRemovedImage(struct grubConfig
  		      const char * prefix) {
      struct singleEntry * entry;
-     if (!image) return;
+     if (!image)
+ 	return;
+     /* check and see if we're removing the default image */
+     if (isdigit(*image)) {
+ 	entry = findEntryByPath(cfg, image, prefix, NULL);
+ 	if(entry)
+ 	    entry->skip = 1;
+ 	return;
+     }
      while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
  	entry->skip = 1;
-Line 1423 
 void markRemovedImage(struct grubConfig
+Line 2092 
 void markRemovedImage(struct grubConfig
  void setDefaultImage(struct grubConfig * config, int hasNew,
  		     const char * defaultKernelPath, int newIsDefault,
- 		     const char * prefix, int flags) {
+ 		     const char * prefix, int flags, int index) {
      struct singleEntry * entry, * entry2, * newDefault;
      int i, j;
      if (newIsDefault) {
  	config->defaultImage = 0;
  	return;
+     } else if ((index >= 0) && config->cfi->defaultIsIndex) {
+ 	if (findEntryByIndex(config, index))
+ 	    config->defaultImage = index;
+ 	else
+ 	    config->defaultImage = -1;
+ 	return;
      } else if (defaultKernelPath) {
  	i = 0;
  	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
-Line 1442 
 void setDefaultImage(struct grubConfig *
+Line 2117 
 void setDefaultImage(struct grubConfig *
      /* defaultImage now points to what we'd like to use, but before any order
         changes */
-     if (config->defaultImage == DEFAULT_SAVED)
+     if ((config->defaultImage == DEFAULT_SAVED) ||
+ 	(config->defaultImage == DEFAULT_SAVED_GRUB2))
        /* default is set to saved, we don't want to change it */
        return;
-Line 1503 
 void displayEntry(struct singleEntry * e
+Line 2179 
 void displayEntry(struct singleEntry * e
      printf("index=%d\n", index);
-     line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+     line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
      if (!line) {
          printf("non linux entry\n");
          return;
      }
-     printf("kernel=%s\n", line->elements[1].item);
+     if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
+ 	printf("kernel=%s\n", line->elements[1].item);
+     else
+ 	printf("kernel=%s%s\n", prefix, line->elements[1].item);
      if (line->numElements >= 3) {
  	printf("args=\"");
-Line 1565 
 void displayEntry(struct singleEntry * e
+Line 2244 
 void displayEntry(struct singleEntry * e
  	printf("root=%s\n", s);
      }
-     line = getLineByType(LT_INITRD, entry->lines);
+     line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
      if (line && line->numElements >= 2) {
- 	printf("initrd=%s", prefix);
+ 	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
+ 	    printf("initrd=");
+ 	else
+ 	    printf("initrd=%s", prefix);
  	for (i = 1; i < line->numElements; i++)
  	    printf("%s%s", line->elements[i].item, line->elements[i].indent);
  	printf("\n");
      }
+     line = getLineByType(LT_TITLE, entry->lines);
+     if (line) {
+ 	printf("title=%s\n", line->elements[1].item);
+     } else {
+ 	char * title;
+ 	line = getLineByType(LT_MENUENTRY, entry->lines);
+ 	title = grub2ExtractTitle(line);
+ 	if (title)
+ 	    printf("title=%s\n", title);
+     }
+ }
+ int isSuseSystem(void) {
+     const char * path;
+     const static char default_path[] = "/etc/SuSE-release";
+     if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
+ 	path = default_path;
+     if (!access(path, R_OK))
+ 	return 1;
+     return 0;
+ }
+ int isSuseGrubConf(const char * path) {
+     FILE * grubConf;
+     char * line = NULL;
+     size_t len = 0, res = 0;
+     grubConf = fopen(path, "r");
+     if (!grubConf) {
+         dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
+ 	return 0;
+     }
+     while ((res = getline(&line, &len, grubConf)) != -1) {
+ 	if (!strncmp(line, "setup", 5)) {
+ 	    fclose(grubConf);
+ 	    free(line);
+ 	    return 1;
+ 	}
+     }
+     dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
+ 	      path);
+     fclose(grubConf);
+     free(line);
+     return 0;
+ }
+ int suseGrubConfGetLba(const char * path, int * lbaPtr) {
+     FILE * grubConf;
+     char * line = NULL;
+     size_t res = 0, len = 0;
+     if (!path) return 1;
+     if (!lbaPtr) return 1;
+     grubConf = fopen(path, "r");
+     if (!grubConf) return 1;
+     while ((res = getline(&line, &len, grubConf)) != -1) {
+ 	if (line[res - 1] == '\n')
+ 	    line[res - 1] = '\0';
+ 	else if (len > res)
+ 	    line[res] = '\0';
+ 	else {
+ 	    line = realloc(line, res + 1);
+ 	    line[res] = '\0';
+ 	}
+ 	if (!strncmp(line, "setup", 5)) {
+ 	    if (strstr(line, "--force-lba")) {
+ 	        *lbaPtr = 1;
+ 	    } else {
+ 	        *lbaPtr = 0;
+ 	    }
+ 	    dbgPrintf("lba: %i\n", *lbaPtr);
+ 	    break;
+ 	}
+     }
+     free(line);
+     fclose(grubConf);
+     return 0;
+ }
+ int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
+     FILE * grubConf;
+     char * line = NULL;
+     size_t res = 0, len = 0;
+     char * lastParamPtr = NULL;
+     char * secLastParamPtr = NULL;
+     char installDeviceNumber = '\0';
+     char * bounds = NULL;
+     if (!path) return 1;
+     if (!devicePtr) return 1;
+     grubConf = fopen(path, "r");
+     if (!grubConf) return 1;
+     while ((res = getline(&line, &len, grubConf)) != -1) {
+ 	if (strncmp(line, "setup", 5))
+ 	    continue;
+ 	if (line[res - 1] == '\n')
+ 	    line[res - 1] = '\0';
+ 	else if (len > res)
+ 	    line[res] = '\0';
+ 	else {
+ 	    line = realloc(line, res + 1);
+ 	    line[res] = '\0';
+ 	}
+ 	lastParamPtr = bounds = line + res;
+ 	/* Last parameter in grub may be an optional IMAGE_DEVICE */
+ 	while (!isspace(*lastParamPtr))
+ 	    lastParamPtr--;
+ 	lastParamPtr++;
+ 	secLastParamPtr = lastParamPtr - 2;
+ 	dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
+ 	if (lastParamPtr + 3 > bounds) {
+ 	    dbgPrintf("lastParamPtr going over boundary");
+ 	    fclose(grubConf);
+ 	    free(line);
+ 	    return 1;
+ 	}
+ 	if (!strncmp(lastParamPtr, "(hd", 3))
+ 	    lastParamPtr += 3;
+ 	dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
+ 	/*
+ 	 * Second last parameter will decide wether last parameter is
+ 	 * an IMAGE_DEVICE or INSTALL_DEVICE
+ 	 */
+ 	while (!isspace(*secLastParamPtr))
+ 	    secLastParamPtr--;
+ 	secLastParamPtr++;
+ 	if (secLastParamPtr + 3 > bounds) {
+ 	    dbgPrintf("secLastParamPtr going over boundary");
+ 	    fclose(grubConf);
+ 	    free(line);
+ 	    return 1;
+ 	}
+ 	dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
+ 	if (!strncmp(secLastParamPtr, "(hd", 3)) {
+ 	    secLastParamPtr += 3;
+ 	    dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
+ 	    installDeviceNumber = *secLastParamPtr;
+ 	} else {
+ 	    installDeviceNumber = *lastParamPtr;
+ 	}
+ 	*devicePtr = malloc(6);
+ 	snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
+ 	dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
+ 	fclose(grubConf);
+ 	free(line);
+ 	return 0;
+     }
+     free(line);
+     fclose(grubConf);
+     return 1;
+ }
+ int grubGetBootFromDeviceMap(const char * device,
+ 			     char ** bootPtr) {
+     FILE * deviceMap;
+     char * line = NULL;
+     size_t res = 0, len = 0;
+     char * devicePtr;
+     char * bounds = NULL;
+     const char * path;
+     const static char default_path[] = "/boot/grub/device.map";
+     if (!device) return 1;
+     if (!bootPtr) return 1;
+     if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
+ 	path = default_path;
+     dbgPrintf("opening grub device.map file from: %s\n", path);
+     deviceMap = fopen(path, "r");
+     if (!deviceMap)
+ 	return 1;
+     while ((res = getline(&line, &len, deviceMap)) != -1) {
+         if (!strncmp(line, "#", 1))
+ 	    continue;
+ 	if (line[res - 1] == '\n')
+ 	    line[res - 1] = '\0';
+ 	else if (len > res)
+ 	    line[res] = '\0';
+ 	else {
+ 	    line = realloc(line, res + 1);
+ 	    line[res] = '\0';
+ 	}
+ 	devicePtr = line;
+ 	bounds = line + res;
+ 	while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
+ 	    devicePtr++;
+ 	dbgPrintf("device: %s\n", devicePtr);
+ 	if (!strncmp(devicePtr, device, strlen(device))) {
+ 	    devicePtr += strlen(device);
+ 	    while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
+ 	        devicePtr++;
+ 	    *bootPtr = strdup(devicePtr);
+ 	    break;
+ 	}
+     }
+     free(line);
+     fclose(deviceMap);
+     return 0;
+ }
+ int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
+     char * grubDevice;
+     if (suseGrubConfGetInstallDevice(path, &grubDevice))
+ 	dbgPrintf("error looking for grub installation device\n");
+     else
+ 	dbgPrintf("grubby installation device: %s\n", grubDevice);
+     if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
+ 	dbgPrintf("error looking for grub boot device\n");
+     else
+ 	dbgPrintf("grubby boot device: %s\n", *bootPtr);
+     free(grubDevice);
+     return 0;
+ }
+ int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
+     /*
+      * This SuSE grub configuration file at this location is not your average
+      * grub configuration file, but instead the grub commands used to setup
+      * grub on that system.
+      */
+     const char * path;
+     const static char default_path[] = "/etc/grub.conf";
+     if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
+ 	path = default_path;
+     if (!isSuseGrubConf(path)) return 1;
+     if (lbaPtr) {
+         *lbaPtr = 0;
+         if (suseGrubConfGetLba(path, lbaPtr))
+             return 1;
+     }
+     if (bootPtr) {
+         *bootPtr = NULL;
+         suseGrubConfGetBoot(path, bootPtr);
+     }
+     return 0;
  }
  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
-Line 1623 
 int parseSysconfigGrub(int * lbaPtr, cha
+Line 2578 
 int parseSysconfigGrub(int * lbaPtr, cha
  }
  void dumpSysconfigGrub(void) {
-     char * boot;
+     char * boot = NULL;
      int lba;
-     if (!parseSysconfigGrub(&lba, &boot)) {
+     if (isSuseSystem()) {
- 	if (lba) printf("lba\n");
+         if (parseSuseGrubConf(&lba, &boot)) {
- 	if (boot) printf("boot=%s\n", boot);
+ 	    free(boot);
+ 	    return;
+ 	}
+     } else {
+         if (parseSysconfigGrub(&lba, &boot)) {
+ 	    free(boot);
+ 	    return;
+ 	}
+     }
+     if (lba) printf("lba\n");
+     if (boot) {
+ 	printf("boot=%s\n", boot);
+ 	free(boot);
      }
  }
-Line 1677 
 struct singleLine * addLineTmpl(struct s
+Line 2645 
 struct singleLine * addLineTmpl(struct s
  {
      struct singleLine * newLine = lineDup(tmplLine);
+     if (isEfi && cfi == &grub2ConfigType) {
+ 	enum lineType_e old = newLine->type;
+ 	newLine->type = preferredLineType(newLine->type, cfi);
+ 	if (old != newLine->type)
+ 	    newLine->elements[0].item = getKeyByType(newLine->type, cfi);
+     }
      if (val) {
  	/* override the inherited value with our own.
  	 * This is a little weak because it only applies to elements[1]
-Line 1686 
 struct singleLine * addLineTmpl(struct s
+Line 2661 
 struct singleLine * addLineTmpl(struct s
  	insertElement(newLine, val, 1, cfi);
  	/* but try to keep the rootspec from the template... sigh */
- 	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)) {
  	    char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
  	    if (rootspec != NULL) {
  		free(newLine->elements[1].item);
-Line 1723 
 struct singleLine *  addLine(struct sing
+Line 2698 
 struct singleLine *  addLine(struct sing
      /* NB: This function shouldn't allocate items on the heap, rather on the
       * stack since it calls addLineTmpl which will make copies.
       */
      if (type == LT_TITLE && cfi->titleBracketed) {
  	/* we're doing a bracketed title (zipl) */
  	tmpl.type = type;
-Line 1733 
 struct singleLine *  addLine(struct sing
+Line 2707 
 struct singleLine *  addLine(struct sing
  	sprintf(tmpl.elements[0].item, "[%s]", val);
  	tmpl.elements[0].indent = "";
  	val = NULL;
+     } else if (type == LT_MENUENTRY) {
+ 	char *lineend = "--class gnu-linux --class gnu --class os {";
+ 	if (!val) {
+ 	    fprintf(stderr, "Line type LT_MENUENTRY requires a value\n");
+ 	    abort();
+ 	}
+ 	kw = getKeywordByType(type, cfi);
+ 	if (!kw) {
+ 	    fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
+ 	    abort();
+ 	}
+ 	tmpl.indent = "";
+ 	tmpl.type = type;
+ 	tmpl.numElements = 3;
+ 	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
+ 	tmpl.elements[0].item = kw->key;
+ 	tmpl.elements[0].indent = alloca(2);
+ 	sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
+ 	tmpl.elements[1].item = (char *)val;
+ 	tmpl.elements[1].indent = alloca(2);
+ 	sprintf(tmpl.elements[1].indent, "%c", kw->nextChar);
+ 	tmpl.elements[2].item = alloca(strlen(lineend)+1);
+ 	strcpy(tmpl.elements[2].item, lineend);
+ 	tmpl.elements[2].indent = "";
      } else {
  	kw = getKeywordByType(type, cfi);
- 	if (!kw) abort();
+ 	if (!kw) {
+ 	    fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
+ 	    abort();
+ 	}
  	tmpl.type = type;
  	tmpl.numElements = val ? 2 : 1;
  	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
-Line 1759 
 struct singleLine *  addLine(struct sing
+Line 2760 
 struct singleLine *  addLine(struct sing
  	if (!line->next && !prev) prev = line;
      }
-     if (prev == entry->lines)
+     struct singleLine *menuEntry;
- 	tmpl.indent = defaultIndent ?: "";
+     menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
-     else
+     if (tmpl.type == LT_ENTRY_END) {
- 	tmpl.indent = prev->indent;
+ 	if (menuEntry)
+ 	    tmpl.indent = menuEntry->indent;
+ 	else
+ 	    tmpl.indent = defaultIndent ?: "";
+     } else if (tmpl.type != LT_MENUENTRY) {
+ 	if (menuEntry)
+ 	    tmpl.indent = "\t";
+ 	else if (prev == entry->lines)
+ 	    tmpl.indent = defaultIndent ?: "";
+ 	else
+ 	    tmpl.indent = prev->indent;
+     }
      return addLineTmpl(entry, &tmpl, prev, val, cfi);
  }
-Line 1789 
 void removeLine(struct singleEntry * ent
+Line 2801 
 void removeLine(struct singleEntry * ent
      free(line);
  }
+ static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
+ {
+     struct singleLine newLine = {
+ 	.indent = tmplLine->indent,
+ 	.type = tmplLine->type,
+ 	.next = tmplLine->next,
+     };
+     int firstQuotedItem = -1;
+     int quoteLen = 0;
+     int j;
+     int element = 0;
+     char *c;
+     c = malloc(strlen(tmplLine->elements[0].item) + 1);
+     strcpy(c, tmplLine->elements[0].item);
+     insertElement(&newLine, c, element++, cfi);
+     free(c);
+     c = NULL;
+     for (j = 1; j < tmplLine->numElements; j++) {
+ 	if (firstQuotedItem == -1) {
+ 	    quoteLen += strlen(tmplLine->elements[j].item);
+ 	    if (isquote(tmplLine->elements[j].item[0])) {
+ 		firstQuotedItem = j;
+ 	        quoteLen += strlen(tmplLine->elements[j].indent);
+ 	    } else {
+ 		c = malloc(quoteLen + 1);
+ 		strcpy(c, tmplLine->elements[j].item);
+ 		insertElement(&newLine, c, element++, cfi);
+ 		free(c);
+ 		quoteLen = 0;
+ 	    }
+ 	} else {
+ 	    int itemlen = strlen(tmplLine->elements[j].item);
+ 	    quoteLen += itemlen;
+ 	    quoteLen += strlen(tmplLine->elements[j].indent);
+ 	    if (isquote(tmplLine->elements[j].item[itemlen - 1])) {
+ 		c = malloc(quoteLen + 1);
+ 		c[0] = '\0';
+ 		for (int i = firstQuotedItem; i < j+1; i++) {
+ 		    strcat(c, tmplLine->elements[i].item);
+ 		    strcat(c, tmplLine->elements[i].indent);
+ 		}
+ 		insertElement(&newLine, c, element++, cfi);
+ 		free(c);
+ 		firstQuotedItem = -1;
+ 		quoteLen = 0;
+ 	    }
+ 	}
+     }
+     while (tmplLine->numElements)
+ 	removeElement(tmplLine, 0);
+     if (tmplLine->elements)
+ 	free(tmplLine->elements);
+     tmplLine->numElements = newLine.numElements;
+     tmplLine->elements = newLine.elements;
+ }
  static void insertElement(struct singleLine * line,
  			  const char * item, int insertHere,
  			  struct configFileInfo * cfi)
-Line 1895 
 int updateActualImage(struct grubConfig
+Line 2969 
 int updateActualImage(struct grubConfig
      const char ** arg;
      int useKernelArgs, useRoot;
      int firstElement;
-     int *usedElements, *usedArgs;
+     int *usedElements;
      int doreplace;
      if (!image) return 0;
-Line 1930 
 int updateActualImage(struct grubConfig
+Line 3004 
 int updateActualImage(struct grubConfig
      useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
  	       && !multibootArgs);
-     for (k = 0, arg = newArgs; *arg; arg++, k++) ;
-     usedArgs = calloc(k, sizeof(*usedArgs));
      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
  	if (multibootArgs && !entry->multiboot)
-Line 1960 
 int updateActualImage(struct grubConfig
+Line 3031 
 int updateActualImage(struct grubConfig
  	    firstElement = 2;
  	} else {
- 	    line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);
+ 	    line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);
  	    if (!line) {
  		/* no LT_KERNEL or LT_MBMODULE in this entry? */
  		continue;
-Line 2008 
 int updateActualImage(struct grubConfig
+Line 3079 
 int updateActualImage(struct grubConfig
          usedElements = calloc(line->numElements, sizeof(*usedElements));
  	for (k = 0, arg = newArgs; *arg; arg++, k++) {
-             if (usedArgs[k]) continue;
  	    doreplace = 1;
  	    for (i = firstElement; i < line->numElements; i++) {
-Line 2023 
 int updateActualImage(struct grubConfig
+Line 3093 
 int updateActualImage(struct grubConfig
                      continue;
  		if (!argMatch(line->elements[i].item, *arg)) {
                      usedElements[i]=1;
-                     usedArgs[k]=1;
  		    break;
                  }
              }
-Line 2093 
 int updateActualImage(struct grubConfig
+Line 3162 
 int updateActualImage(struct grubConfig
  	}
      }
-     free(usedArgs);
      free(newArgs);
      free(oldArgs);
-Line 2119 
 int updateImage(struct grubConfig * cfg,
+Line 3187 
 int updateImage(struct grubConfig * cfg,
      return rc;
  }
+ int updateInitrd(struct grubConfig * cfg, const char * image,
+                  const char * prefix, const char * initrd) {
+     struct singleEntry * entry;
+     struct singleLine * line, * kernelLine, *endLine = NULL;
+     int index = 0;
+     if (!image) return 0;
+     for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
+         kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);
+         if (!kernelLine) continue;
+         line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
+         if (line)
+             removeLine(entry, line);
+         if (prefix) {
+             int prefixLen = strlen(prefix);
+             if (!strncmp(initrd, prefix, prefixLen))
+                 initrd += prefixLen;
+         }
+ 	endLine = getLineByType(LT_ENTRY_END, entry->lines);
+ 	if (endLine)
+ 	    removeLine(entry, endLine);
+         line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),
+ 			kernelLine->indent, initrd);
+         if (!line)
+ 	    return 1;
+ 	if (endLine) {
+ 	    line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
+             if (!line)
+ 		return 1;
+ 	}
+         break;
+     }
+     return 0;
+ }
  int checkDeviceBootloader(const char * device, const unsigned char * boot) {
      int fd;
      unsigned char bootSect[512];
-Line 2142 
 int checkDeviceBootloader(const char * d
+Line 3249 
 int checkDeviceBootloader(const char * d
      if (memcmp(boot, bootSect, 3))
  	return 0;
-     if (boot[1] == 0xeb) {
+     if (boot[1] == JMP_SHORT_OPCODE) {
  	offset = boot[2] + 2;
      } else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
  	offset = (boot[3] << 8) + boot[2] + 2;
-     } else if (boot[0] == 0xeb) {
+     } else if (boot[0] == JMP_SHORT_OPCODE) {
- 	offset = boot[1] + 2;
+       offset = boot[1] + 2;
+         /*
+ 	 * it looks like grub, when copying stage1 into the mbr, patches stage1
+ 	 * right after the JMP location, replacing other instructions such as
+ 	 * JMPs for NOOPs. So, relax the check a little bit by skipping those
+ 	 * different bytes.
+ 	 */
+       if ((bootSect[offset + 1] == NOOP_OPCODE)
+ 	  && (bootSect[offset + 2] == NOOP_OPCODE)) {
+ 	offset = offset + 3;
+       }
      } else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
  	offset = (boot[2] << 8) + boot[1] + 2;
      } else {
-Line 2289 
 int checkForLilo(struct grubConfig * con
+Line 3406 
 int checkForLilo(struct grubConfig * con
      return checkDeviceBootloader(line->elements[1].item, boot);
  }
+ int checkForGrub2(struct grubConfig * config) {
+     if (!access("/etc/grub.d/", R_OK))
+ 	return 2;
+     return 1;
+ }
  int checkForGrub(struct grubConfig * config) {
      int fd;
      unsigned char bootSect[512];
      char * boot;
+     int onSuse = isSuseSystem();
-     if (parseSysconfigGrub(NULL, &boot))
- 	return 0;
+     if (onSuse) {
+ 	if (parseSuseGrubConf(NULL, &boot))
+ 	    return 0;
+     } else {
+ 	if (parseSysconfigGrub(NULL, &boot))
+ 	    return 0;
+     }
      /* assume grub is not installed -- not an error condition */
      if (!boot)
-Line 2314 
 int checkForGrub(struct grubConfig * con
+Line 3445 
 int checkForGrub(struct grubConfig * con
      }
      close(fd);
+     /* The more elaborate checks do not work on SuSE. The checks done
+      * seem to be reasonble (at least for now), so just return success
+      */
+     if (onSuse)
+ 	return 2;
      return checkDeviceBootloader(boot, bootSect);
  }
-Line 2347 
 int checkForExtLinux(struct grubConfig *
+Line 3484 
 int checkForExtLinux(struct grubConfig *
      return checkDeviceBootloader(boot, bootSect);
  }
+ int checkForYaboot(struct grubConfig * config) {
+     /*
+      * This is a simplistic check that we consider good enough for own puporses
+      *
+      * If we were to properly check if yaboot is *installed* we'd need to:
+      * 1) get the system boot device (LT_BOOT)
+      * 2) considering it's a raw filesystem, check if the yaboot binary matches
+      *    the content on the boot device
+      * 3) if not, copy the binary to a temporary file and run "addnote" on it
+      * 4) check again if binary and boot device contents match
+      */
+     if (!access("/etc/yaboot.conf", R_OK))
+ 	return 2;
+     return 1;
+ }
+ int checkForElilo(struct grubConfig * config) {
+     if (!access("/etc/elilo.conf", R_OK))
+ 	return 2;
+     return 1;
+ }
  static char * getRootSpecifier(char * str) {
      char * idx, * rootspec = NULL;
-Line 2361 
 static char * getRootSpecifier(char * st
+Line 3522 
 static char * getRootSpecifier(char * st
  static char * getInitrdVal(struct grubConfig * config,
  			   const char * prefix, struct singleLine *tmplLine,
  			   const char * newKernelInitrd,
- 			   char ** extraInitrds, int extraInitrdCount)
+ 			   const char ** extraInitrds, int extraInitrdCount)
  {
      char *initrdVal, *end;
      int i;
-Line 2406 
 static char * getInitrdVal(struct grubCo
+Line 3567 
 static char * getInitrdVal(struct grubCo
  int addNewKernel(struct grubConfig * config, struct singleEntry * template,
  	         const char * prefix,
- 		 char * newKernelPath, char * newKernelTitle,
+ 		 const char * newKernelPath, const char * newKernelTitle,
- 		 char * newKernelArgs, char * newKernelInitrd,
+ 		 const char * newKernelArgs, const char * newKernelInitrd,
- 		 char ** extraInitrds, int extraInitrdCount,
+ 		 const char ** extraInitrds, int extraInitrdCount,
-                  char * newMBKernel, char * newMBKernelArgs) {
+                  const char * newMBKernel, const char * newMBKernelArgs) {
      struct singleEntry * new;
      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
      int needs;
-Line 2463 
 int addNewKernel(struct grubConfig * con
+Line 3624 
 int addNewKernel(struct grubConfig * con
  	    while (*chptr && isspace(*chptr)) chptr++;
  	    if (*chptr == '#') continue;
- 	    if (tmplLine->type == LT_KERNEL &&
+ 	    if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
- 		tmplLine->numElements >= 2) {
  		if (!template->multiboot && (needs & NEED_MB)) {
  		    /* it's not a multiboot template and this is the kernel
  		     * line.  Try to be intelligent about inserting the
-Line 2541 
 int addNewKernel(struct grubConfig * con
+Line 3701 
 int addNewKernel(struct grubConfig * con
  		    /* template is multi but new is not,
  		     * insert the kernel in the first module slot
  		     */
- 		    tmplLine->type = LT_KERNEL;
+ 		    tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
  		    free(tmplLine->elements[0].item);
  		    tmplLine->elements[0].item =
- 			strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);
+ 			strdup(getKeywordByType(tmplLine->type,
+ 						config->cfi)->key);
  		    newLine = addLineTmpl(new, tmplLine, newLine,
- 					  newKernelPath + strlen(prefix), config->cfi);
+ 					  newKernelPath + strlen(prefix),
+ 					  config->cfi);
  		    needs &= ~NEED_KERNEL;
  		} else if (needs & NEED_INITRD) {
  		    char *initrdVal;
  		    /* template is multi but new is not,
  		     * insert the initrd in the second module slot
  		     */
- 		    tmplLine->type = LT_INITRD;
+ 		    tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
  		    free(tmplLine->elements[0].item);
  		    tmplLine->elements[0].item =
- 			strdup(getKeywordByType(LT_INITRD, config->cfi)->key);
+ 			strdup(getKeywordByType(tmplLine->type,
+ 						config->cfi)->key);
  		    initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
  		    newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
  		    free(initrdVal);
  		    needs &= ~NEED_INITRD;
  		}
- 	    } else if (tmplLine->type == LT_INITRD &&
+ 	    } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
- 		       tmplLine->numElements >= 2) {
  		if (needs & NEED_INITRD &&
  		    new->multiboot && !template->multiboot &&
  		    config->cfi->mbInitRdIsModule) {
-Line 2590 
 int addNewKernel(struct grubConfig * con
+Line 3752 
 int addNewKernel(struct grubConfig * con
  		    needs &= ~NEED_INITRD;
  		}
+ 	    } else if (tmplLine->type == LT_MENUENTRY &&
+ 		       (needs & NEED_TITLE)) {
+ 		requote(tmplLine, config->cfi);
+ 		char *nkt = malloc(strlen(newKernelTitle)+3);
+ 		strcpy(nkt, "'");
+ 		strcat(nkt, newKernelTitle);
+ 		strcat(nkt, "'");
+ 		newLine = addLineTmpl(new, tmplLine, newLine, nkt, config->cfi);
+ 		free(nkt);
+ 		needs &= ~NEED_TITLE;
  	    } else if (tmplLine->type == LT_TITLE &&
  		       (needs & NEED_TITLE)) {
  		if (tmplLine->numElements >= 2) {
-Line 2603 
 int addNewKernel(struct grubConfig * con
+Line 3775 
 int addNewKernel(struct grubConfig * con
  				      tmplLine->indent, newKernelTitle);
  		    needs &= ~NEED_TITLE;
  		}
+ 	    } else if (tmplLine->type == LT_ECHO) {
+ 		    requote(tmplLine, config->cfi);
+ 		    static const char *prefix = "'Loading ";
+ 		    if (tmplLine->numElements > 1 &&
+ 			    strstr(tmplLine->elements[1].item, prefix) &&
+ 			    masterLine->next &&
+ 			    iskernel(masterLine->next->type)) {
+ 			char *newTitle = malloc(strlen(prefix) +
+ 						strlen(newKernelTitle) + 2);
+ 			strcpy(newTitle, prefix);
+ 			strcat(newTitle, newKernelTitle);
+ 			strcat(newTitle, "'");
+ 			newLine = addLine(new, config->cfi, LT_ECHO,
+ 					tmplLine->indent, newTitle);
+ 			free(newTitle);
+ 		    } else {
+ 			/* pass through other lines from the template */
+ 			newLine = addLineTmpl(new, tmplLine, newLine, NULL,
+ 						config->cfi);
+ 		    }
  	    } else {
  		/* pass through other lines from the template */
  		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
-Line 2614 
 int addNewKernel(struct grubConfig * con
+Line 3806 
 int addNewKernel(struct grubConfig * con
  	/* don't have a template, so start the entry with the
  	 * appropriate starting line
  	 */
- 	switch (config->cfi->entrySeparator) {
+ 	switch (config->cfi->entryStart) {
  	    case LT_KERNEL:
+ 	    case LT_KERNEL_EFI:
  		if (new->multiboot && config->cfi->mbHyperFirst) {
  		    /* fall through to LT_HYPER */
  		} else {
- 		    newLine = addLine(new, config->cfi, LT_KERNEL,
+ 		    newLine = addLine(new, config->cfi,
+ 		    		      preferredLineType(LT_KERNEL, config->cfi),
  				      config->primaryIndent,
  				      newKernelPath + strlen(prefix));
  		    needs &= ~NEED_KERNEL;
-Line 2633 
 int addNewKernel(struct grubConfig * con
+Line 3827 
 int addNewKernel(struct grubConfig * con
  		needs &= ~NEED_MB;
  		break;
+ 	    case LT_MENUENTRY: {
+ 		char *nkt = malloc(strlen(newKernelTitle)+3);
+ 		strcpy(nkt, "'");
+ 		strcat(nkt, newKernelTitle);
+ 		strcat(nkt, "'");
+ 	        newLine = addLine(new, config->cfi, LT_MENUENTRY,
+ 				  config->primaryIndent, nkt);
+ 		free(nkt);
+ 		needs &= ~NEED_TITLE;
+ 		needs |= NEED_END;
+ 		break;
+ 	    }
  	    case LT_TITLE:
  		if( useextlinuxmenu != 0 ){	// We just need useextlinuxmenu to not be zero (set above)
  			char * templabel;
-Line 2666 
 int addNewKernel(struct grubConfig * con
+Line 3872 
 int addNewKernel(struct grubConfig * con
      /* add the remainder of the lines, i.e. those that either
       * weren't present in the template, or in the case of no template,
-      * all the lines following the entrySeparator.
+      * all the lines following the entryStart.
       */
      if (needs & NEED_TITLE) {
  	newLine = addLine(new, config->cfi, LT_TITLE,
-Line 2683 
 int addNewKernel(struct grubConfig * con
+Line 3889 
 int addNewKernel(struct grubConfig * con
      if (needs & NEED_KERNEL) {
  	newLine = addLine(new, config->cfi,
  			  (new->multiboot && getKeywordByType(LT_MBMODULE,
- 							      config->cfi)) ?
+ 							      config->cfi))
- 			  LT_MBMODULE : LT_KERNEL,
+ 			  	? LT_MBMODULE
+ 				: preferredLineType(LT_KERNEL, config->cfi),
  			  config->secondaryIndent,
  			  newKernelPath + strlen(prefix));
  	needs &= ~NEED_KERNEL;
-Line 2700 
 int addNewKernel(struct grubConfig * con
+Line 3907 
 int addNewKernel(struct grubConfig * con
  	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
  	newLine = addLine(new, config->cfi,
  			  (new->multiboot && getKeywordByType(LT_MBMODULE,
- 							      config->cfi)) ?
+ 							      config->cfi))
- 			  LT_MBMODULE : LT_INITRD,
+ 			   ? LT_MBMODULE
+ 			   : preferredLineType(LT_INITRD, config->cfi),
  			  config->secondaryIndent,
  			  initrdVal);
  	free(initrdVal);
  	needs &= ~NEED_INITRD;
      }
+     if (needs & NEED_END) {
+ 	newLine = addLine(new, config->cfi, LT_ENTRY_END,
+ 			config->secondaryIndent, NULL);
+ 	needs &= ~NEED_END;
+     }
      if (needs) {
  	printf(_("grubby: needs=%d, aborting\n"), needs);
-Line 2728 
 static void traceback(int signum)
+Line 3941 
 static void traceback(int signum)
      memset(array, '\0', sizeof (array));
      size = backtrace(array, 40);
-     fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",
+     fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
              (unsigned long)size);
      backtrace_symbols_fd(array, size, STDERR_FILENO);
      exit(1);
-Line 2736 
 static void traceback(int signum)
+Line 3949 
 static void traceback(int signum)
  int main(int argc, const char ** argv) {
      poptContext optCon;
-     char * grubConfig = NULL;
+     const char * grubConfig = NULL;
      char * outputFile = NULL;
      int arg = 0;
      int flags = 0;
      int badImageOkay = 0;
+     int configureGrub2 = 0;
      int configureLilo = 0, configureELilo = 0, configureGrub = 0;
      int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
      int configureExtLinux = 0;
-Line 2762 
 int main(int argc, const char ** argv) {
+Line 3976 
 int main(int argc, const char ** argv) {
      char * removeArgs = NULL;
      char * kernelInfo = NULL;
      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
+     char * envPath = NULL;
      const char * chptr = NULL;
      struct configFileInfo * cfi = NULL;
      struct grubConfig * config;
      struct singleEntry * template = NULL;
      int copyDefault = 0, makeDefault = 0;
      int displayDefault = 0;
+     int displayDefaultIndex = 0;
+     int displayDefaultTitle = 0;
+     int defaultIndex = -1;
      struct poptOption options[] = {
  	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
  	    _("add an entry for the specified kernel"), _("kernel-path") },
-Line 2785 
 int main(int argc, const char ** argv) {
+Line 4003 
 int main(int argc, const char ** argv) {
  	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
  	    _("filestystem which contains /boot directory (for testing only)"),
  	    _("bootfs") },
- #if defined(__i386__) || defined(__x86_64__)
+ #if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
  	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
- 	    _("check if lilo is installed on lilo.conf boot sector") },
+ 	    _("check which bootloader is installed on boot sector") },
  #endif
  	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
  	    _("path to grub config file to update (\"-\" for stdin)"),
-Line 2798 
 int main(int argc, const char ** argv) {
+Line 4016 
 int main(int argc, const char ** argv) {
  	      "the kernel referenced by the default image does not exist, "
  	      "the first linux entry whose kernel does exist is used as the "
  	      "template"), NULL },
+ 	{ "debug", 0, 0, &debug, 0,
+ 	    _("print debugging information for failures") },
  	{ "default-kernel", 0, 0, &displayDefault, 0,
  	    _("display the path of the default kernel") },
+ 	{ "default-index", 0, 0, &displayDefaultIndex, 0,
+ 	    _("display the index of the default kernel") },
+ 	{ "default-title", 0, 0, &displayDefaultTitle, 0,
+ 	    _("display the title of the default kernel") },
  	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
  	    _("configure elilo bootloader") },
+ 	{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
+ 	    _("force grub2 stanzas to use efi") },
+ 	{ "env", 0, POPT_ARG_STRING, &envPath, 0,
+ 	    _("path for environment data"),
+ 	    _("path") },
  	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
  	    _("configure extlinux bootloader (from syslinux)") },
  	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
  	    _("configure grub bootloader") },
+ 	{ "grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,
+ 	    _("configure grub2 bootloader") },
  	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,
  	    _("display boot information for specified kernel"),
  	    _("kernel-path") },
  	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
  	    _("initrd image for the new kernel"), _("initrd-path") },
  	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
- 	    _("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },
+ 	    _("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
  	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
  	    _("configure lilo bootloader") },
  	{ "make-default", 0, 0, &makeDefault, 0,
-Line 2832 
 int main(int argc, const char ** argv) {
+Line 4063 
 int main(int argc, const char ** argv) {
  	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
  	    _("make the first entry referencing the specified kernel "
  	      "the default"), _("kernel-path") },
+ 	{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
+ 	    _("make the given entry index the default entry"),
+ 	    _("entry-index") },
  	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
  	    _("configure silo bootloader") },
  	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
-Line 2853 
 int main(int argc, const char ** argv) {
+Line 4087 
 int main(int argc, const char ** argv) {
      signal(SIGSEGV, traceback);
+     int i = 0;
+     for (int j = 1; j < argc; j++)
+ 	i += strlen(argv[j]) + 1;
+     saved_command_line = malloc(i);
+     if (!saved_command_line) {
+ 	fprintf(stderr, "grubby: %m\n");
+ 	exit(1);
+     }
+     saved_command_line[0] = '\0';
+     for (int j = 1; j < argc; j++) {
+ 	strcat(saved_command_line, argv[j]);
+ 	strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
+     }
      optCon = poptGetContext("grubby", argc, argv, options, 0);
      poptReadDefaultConfig(optCon, 1);
-Line 2885 
 int main(int argc, const char ** argv) {
+Line 4133 
 int main(int argc, const char ** argv) {
  	return 1;
      }
-     if ((configureLilo + configureGrub + configureELilo +
+     if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
  		configureYaboot + configureSilo + configureZipl +
  		configureExtLinux ) > 1) {
  	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));
-Line 2894 
 int main(int argc, const char ** argv) {
+Line 4142 
 int main(int argc, const char ** argv) {
  	fprintf(stderr,
  	    _("grubby: cannot specify config file with --bootloader-probe\n"));
  	return 1;
+     } else if (configureGrub2) {
+ 	cfi = &grub2ConfigType;
+ 	if (envPath)
+ 	    cfi->envFile = envPath;
      } else if (configureLilo) {
  	cfi = &liloConfigType;
      } else if (configureGrub) {
-Line 2912 
 int main(int argc, const char ** argv) {
+Line 4164 
 int main(int argc, const char ** argv) {
      }
      if (!cfi) {
+         if (grub2FindConfig(&grub2ConfigType))
+ 	    cfi = &grub2ConfigType;
+ 	else
        #ifdef __ia64__
- 	cfi = &eliloConfigType;
+ 	    cfi = &eliloConfigType;
        #elif __powerpc__
- 	cfi = &yabootConfigType;
+ 	    cfi = &yabootConfigType;
        #elif __sparc__
-         cfi = &siloConfigType;
+             cfi = &siloConfigType;
        #elif __s390__
-         cfi = &ziplConfigType;
+             cfi = &ziplConfigType;
        #elif __s390x__
-         cfi = &ziplConfigtype;
+             cfi = &ziplConfigtype;
        #else
- 	cfi = &grubConfigType;
+ 	    cfi = &grubConfigType;
        #endif
      }
-     if (!grubConfig)
+     if (!grubConfig) {
- 	grubConfig = cfi->defaultConfig;
+ 	if (cfi->findConfig)
+ 	    grubConfig = cfi->findConfig(cfi);
+ 	if (!grubConfig)
+ 	    grubConfig = cfi->defaultConfig;
+     }
      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||
- 			  newKernelPath || removeKernelPath || makeDefault ||
+ 			    newKernelPath || removeKernelPath || makeDefault ||
- 			  defaultKernel)) {
+ 			    defaultKernel || displayDefaultIndex || displayDefaultTitle ||
+ 			    (defaultIndex >= 0))) {
  	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
  			  "specified option"));
  	return 1;
-Line 2948 
 int main(int argc, const char ** argv) {
+Line 4208 
 int main(int argc, const char ** argv) {
      if (newKernelPath && !newKernelTitle) {
  	fprintf(stderr, _("grubby: kernel title must be specified\n"));
  	return 1;
-     } else if (!newKernelPath && (newKernelTitle  || newKernelInitrd ||
+     } else if (!newKernelPath && (newKernelTitle  || copyDefault ||
- 				  newKernelInitrd || copyDefault     ||
+ 				  (newKernelInitrd && !updateKernelPath)||
  				  makeDefault || extraInitrdCount > 0)) {
  	fprintf(stderr, _("grubby: kernel path expected\n"));
  	return 1;
-Line 2974 
 int main(int argc, const char ** argv) {
+Line 4234 
 int main(int argc, const char ** argv) {
  	makeDefault = 1;
  	defaultKernel = NULL;
      }
+     else if (defaultKernel && (defaultIndex >= 0)) {
+ 	fprintf(stderr, _("grubby: --set-default and --set-default-index "
+ 			  "may not be used together\n"));
+ 	return 1;
+     }
-     if (!strcmp(grubConfig, "-") && !outputFile) {
+     if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
  	fprintf(stderr, _("grubby: output file must be specified if stdin "
  			"is used\n"));
  	return 1;
      }
      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
  	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
-         && !removeMBKernel) {
+ 	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
+ 	&& (defaultIndex == -1)) {
  	fprintf(stderr, _("grubby: no action specified\n"));
  	return 1;
      }
-Line 3010 
 int main(int argc, const char ** argv) {
+Line 4276 
 int main(int argc, const char ** argv) {
      }
      if (bootloaderProbe) {
- 	int lrc = 0, grc = 0, erc = 0;
+ 	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
- 	struct grubConfig * lconfig, * gconfig;
+ 	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
+ 	const char *grub2config = grub2FindConfig(&grub2ConfigType);
+ 	if (grub2config) {
+ 	    gconfig = readConfig(grub2config, &grub2ConfigType);
+ 	    if (!gconfig)
+ 		gr2c = 1;
+ 	    else
+ 		gr2c = checkForGrub2(gconfig);
+ 	}
- 	if (!access(grubConfigType.defaultConfig, F_OK)) {
+ 	const char *grubconfig = grubFindConfig(&grubConfigType);
- 	    gconfig = readConfig(grubConfigType.defaultConfig, &grubConfigType);
+ 	if (!access(grubconfig, F_OK)) {
+ 	    gconfig = readConfig(grubconfig, &grubConfigType);
  	    if (!gconfig)
  		grc = 1;
  	    else
-Line 3029 
 int main(int argc, const char ** argv) {
+Line 4305 
 int main(int argc, const char ** argv) {
  		lrc = checkForLilo(lconfig);
  	}
+ 	if (!access(eliloConfigType.defaultConfig, F_OK)) {
+ 	    econfig = readConfig(eliloConfigType.defaultConfig,
+ 				 &eliloConfigType);
+ 	    if (!econfig)
+ 		erc = 1;
+ 	    else
+ 		erc = checkForElilo(econfig);
+ 	}
  	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
  	    lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
  	    if (!lconfig)
- 		erc = 1;
+ 		extrc = 1;
  	    else
- 		erc = checkForExtLinux(lconfig);
+ 		extrc = checkForExtLinux(lconfig);
  	}
- 	if (lrc == 1 || grc == 1) return 1;
+ 	if (!access(yabootConfigType.defaultConfig, F_OK)) {
+ 	    yconfig = readConfig(yabootConfigType.defaultConfig,
+ 				 &yabootConfigType);
+ 	    if (!yconfig)
+ 		yrc = 1;
+ 	    else
+ 		yrc = checkForYaboot(yconfig);
+ 	}
+ 	if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
+ 		erc == 1)
+ 	    return 1;
  	if (lrc == 2) printf("lilo\n");
+ 	if (gr2c == 2) printf("grub2\n");
  	if (grc == 2) printf("grub\n");
- 	if (erc == 2) printf("extlinux\n");
+ 	if (extrc == 2) printf("extlinux\n");
+ 	if (yrc == 2) printf("yaboot\n");
+ 	if (erc == 2) printf("elilo\n");
  	return 0;
      }
+     if (grubConfig == NULL) {
+ 	printf("Could not find bootloader configuration file.\n");
+ 	exit(1);
+     }
      config = readConfig(grubConfig, cfi);
      if (!config) return 1;
-Line 3055 
 int main(int argc, const char ** argv) {
+Line 4360 
 int main(int argc, const char ** argv) {
          char * rootspec;
  	if (config->defaultImage == -1) return 0;
+ 	if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
+ 		cfi->defaultIsSaved)
+ 	    config->defaultImage = 0;
  	entry = findEntryByIndex(config, config->defaultImage);
  	if (!entry) return 0;
  	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
- 	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+ 	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
  	if (!line) return 0;
          rootspec = getRootSpecifier(line->elements[1].item);
-Line 3067 
 int main(int argc, const char ** argv) {
+Line 4375 
 int main(int argc, const char ** argv) {
                 ((rootspec != NULL) ? strlen(rootspec) : 0));
  	return 0;
+     } else if (displayDefaultTitle) {
+ 	struct singleLine * line;
+ 	struct singleEntry * entry;
+ 	if (config->defaultImage == -1) return 0;
+ 	if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
+ 		cfi->defaultIsSaved)
+ 	    config->defaultImage = 0;
+ 	entry = findEntryByIndex(config, config->defaultImage);
+ 	if (!entry) return 0;
+ 	if (!configureGrub2) {
+ 	  line = getLineByType(LT_TITLE, entry->lines);
+ 	  if (!line) return 0;
+ 	  printf("%s\n", line->elements[1].item);
+ 	} else {
+ 	  char * title;
+ 	  dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
+ 	  line = getLineByType(LT_MENUENTRY, entry->lines);
+ 	  if (!line) return 0;
+ 	  title = grub2ExtractTitle(line);
+ 	  if (title)
+ 	    printf("%s\n", title);
+ 	}
+ 	return 0;
+     } else if (displayDefaultIndex) {
+         if (config->defaultImage == -1) return 0;
+ 	if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
+ 		cfi->defaultIsSaved)
+ 	    config->defaultImage = 0;
+         printf("%i\n", config->defaultImage);
+         return 0;
      } else if (kernelInfo)
  	return displayInfo(config, kernelInfo, bootPrefix);
-Line 3078 
 int main(int argc, const char ** argv) {
+Line 4423 
 int main(int argc, const char ** argv) {
      markRemovedImage(config, removeKernelPath, bootPrefix);
      markRemovedImage(config, removeMBKernel, bootPrefix);
      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
- 		    bootPrefix, flags);
+ 		    bootPrefix, flags, defaultIndex);
      setFallbackImage(config, newKernelPath != NULL);
      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
+     if (updateKernelPath && newKernelInitrd) {
+             if (updateInitrd(config, updateKernelPath, bootPrefix,
+                              newKernelInitrd)) return 1;
+     }
      if (addNewKernel(config, template, bootPrefix, newKernelPath,
                       newKernelTitle, newKernelArgs, newKernelInitrd,
-                      extraInitrds, extraInitrdCount,
+                      (const char **)extraInitrds, extraInitrdCount,
                       newMBKernel, newMBKernelArgs)) return 1;
-Line 3095 
 int main(int argc, const char ** argv) {
+Line 4444 
 int main(int argc, const char ** argv) {
      }
      if (!outputFile)
- 	outputFile = grubConfig;
+ 	outputFile = (char *)grubConfig;
      return writeConfig(config, outputFile, bootPrefix);
  }

 Legend:



Removed from v.926
 


changed lines


 
Added in v.2255
 Legend:



Removed from v.926
 


changed lines


 
Added in v.2255
-Removed from v.926
+Added in v.2255