/[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 532 by niro,
Sat Sep  1 22:45:15 2007 UTC
+trunk/grubby/grubby.c
revision 2694 by niro,
Wed Jul 16 10:48:13 2014 UTC
 Line 1
- /* Copyright (C) 2001-2005 Red Hat, Inc.
+ /*
+  * grubby.c
-    This program is free software; you can redistribute it and/or
+  *
-    modify it under the terms of the General Public License as published
+  * Copyright (C) 2001-2008 Red Hat, Inc.
-    by the Free Software Foundation; either version 2 of the License, or
+  * All rights reserved.
-    (at your option) any later version.
+  *
+  * This program is free software; you can redistribute it and/or modify
-    This program is distributed in the hope that it will be useful,
+  * it under the terms of the GNU General Public License as published by
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * the Free Software Foundation; either version 2 of the License, or
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * (at your option) any later version.
-    General Public License for more details.
+  *
+  * This program is distributed in the hope that it will be useful,
-    You should have received a copy of the GNU General Public
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
-    License along with this program; if not, write to the Free
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+  * GNU General Public License for more details.
--1307 USA.  */
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
+ #ifndef _GNU_SOURCE
+ #define _GNU_SOURCE
+ #endif
  #include <ctype.h>
  #include <errno.h>
  #include <fcntl.h>
-Line 25
+Line 31
  #include <string.h>
  #include <sys/stat.h>
  #include <unistd.h>
+ #include <libgen.h>
+ #include <execinfo.h>
+ #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)
+ #else
+ #define dbgPrintf(format, args...)
+ #endif
- #include "mount_by_label.h"
+ 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;
+ #if defined(__arch64__)
+ #define isEfiOnly	1
+ #else
+ #define isEfiOnly	0
+ #endif
+ char *saved_command_line = NULL;
  /* comments get lumped in with indention */
  struct lineElement {
      char * item;
      char * indent;
  };
- enum lineType_e { LT_WHITESPACE, LT_TITLE, LT_KERNEL, LT_INITRD, LT_DEFAULT,
+ enum lineType_e {
-        LT_UNKNOWN, LT_ROOT, LT_FALLBACK, LT_KERNELARGS, LT_BOOT,
+     LT_WHITESPACE   = 1 << 0,
-        LT_BOOTROOT, LT_LBA, LT_MBMODULE, LT_OTHER, LT_GENERIC };
+     LT_TITLE        = 1 << 1,
+     LT_KERNEL       = 1 << 2,
+     LT_INITRD       = 1 << 3,
+     LT_HYPER        = 1 << 4,
+     LT_DEFAULT      = 1 << 5,
+     LT_MBMODULE     = 1 << 6,
+     LT_ROOT         = 1 << 7,
+     LT_FALLBACK     = 1 << 8,
+     LT_KERNELARGS   = 1 << 9,
+     LT_BOOT         = 1 << 10,
+     LT_BOOTROOT     = 1 << 11,
+     LT_LBA          = 1 << 12,
+     LT_OTHER        = 1 << 13,
+     LT_GENERIC      = 1 << 14,
+     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_KERNEL_16    = 1 << 22,
+     LT_INITRD_16    = 1 << 23,
+     LT_DEVTREE      = 1 << 24,
+     LT_UNKNOWN      = 1 << 25,
+ };
  struct singleLine {
      char * indent;
-Line 61 
 struct singleEntry {
+Line 121 
 struct singleEntry {
  #define GRUB_CONFIG_NO_DEFAULT	    (1 << 0)	/* don't write out default=0 */
- #define KERNEL_KERNEL	    (1 << 0)
+ /* These defines are (only) used in addNewKernel() */
- #define KERNEL_INITRD	    (1 << 2)
+ #define NEED_KERNEL  (1 << 0)
- #define KERNEL_TITLE	    (1 << 3)
+ #define NEED_INITRD  (1 << 1)
- #define KERNEL_ARGS	    (1 << 4)
+ #define NEED_TITLE   (1 << 2)
- #define KERNEL_MB           (1 << 5)
+ #define NEED_ARGS    (1 << 3)
+ #define NEED_MB      (1 << 4)
+ #define NEED_END     (1 << 5)
+ #define NEED_DEVTREE (1 << 6)
  #define MAIN_DEFAULT	    (1 << 0)
  #define DEFAULT_SAVED       -2
+ #define DEFAULT_SAVED_GRUB2 -3
  struct keywordTypes {
      char * key;
      enum lineType_e type;
      char nextChar;
- } ;
+     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;
+     int defaultIsUnquoted;
+     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 94 
 struct keywordTypes grubKeywords[] = {
+Line 182 
 struct keywordTypes grubKeywords[] = {
      { "default",    LT_DEFAULT,	    ' ' },
      { "fallback",   LT_FALLBACK,    ' ' },
      { "kernel",	    LT_KERNEL,	    ' ' },
-     { "initrd",	    LT_INITRD,	    ' ' },
+     { "initrd",	    LT_INITRD,	    ' ',	' ' },
      { "module",     LT_MBMODULE,    ' ' },
+     { "kernel",     LT_HYPER,       ' ' },
      { NULL,	    0, 0 },
  };
+ const char *grubFindConfig(struct configFileInfo *cfi) {
+     static const char *configFiles[] = {
+ 	"/boot/grub/grub.conf",
+ 	"/boot/grub/menu.lst",
+ 	"/etc/grub.conf",
+ 	"/boot/grub2/grub.cfg",
+ 	"/boot/grub2-efi/grub.cfg",
+ 	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,
+ };
+ struct keywordTypes grub2Keywords[] = {
+     { "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,  ' ' },
+     { "linux16",    LT_KERNEL_16,   ' ' },
+     { "initrd",     LT_INITRD,      ' ', ' ' },
+     { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
+     { "initrd16",   LT_INITRD_16,   ' ', ' ' },
+     { "module",     LT_MBMODULE,    ' ' },
+     { "kernel",     LT_HYPER,       ' ' },
+     { "devicetree", LT_DEVTREE,  ' ' },
+     { 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/grub/grubenv";
+     int rc = asprintf(&s, "grub-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 sPopCount(const char *s, const char *c)
+ {
+     int ret = 0;
+     if (!s)
+ 	return -1;
+     for (int i = 0; s[i] != '\0'; i++)
+ 	for (int j = 0; c[j] != '\0'; j++)
+ 	    if (s[i] == c[j])
+ 		ret++;
+     return ret;
+ }
+ static char *shellEscape(const char *s)
+ {
+     int l = strlen(s) + sPopCount(s, "'") * 2;
+     char *ret = calloc(l+1, sizeof (*ret));
+     if (!ret)
+ 	return NULL;
+     for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
+ 	if (s[i] == '\'')
+ 	    ret[j++] = '\\';
+ 	ret[j] = s[i];
+     }
+     return ret;
+ }
+ static void unquote(char *s)
+ {
+     int l = strlen(s);
+     if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
+ 	memmove(s, s+1, l-2);
+ 	s[l-2] = '\0';
+     }
+ }
+ static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
+ {
+     char *s = NULL;
+     int rc = 0;
+     char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
+     unquote(value);
+     value = shellEscape(value);
+     if (!value)
+ 	    return -1;
+     rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
+     free(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 || type == LT_KERNEL_16);
+ }
+ static int isinitrd(enum lineType_e type) {
+     return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
+ }
+ 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 142 
 struct keywordTypes yabootKeywords[] = {
+Line 522 
 struct keywordTypes yabootKeywords[] = {
      { "partition",  LT_GENERIC,	    '=' },
      { "device",	    LT_GENERIC,	    '=' },
      { "fstype",	    LT_GENERIC,	    '=' },
-     { "initrd",	    LT_INITRD,	    '=' },
+     { "initrd",	    LT_INITRD,	    '=',	';' },
      { "append",	    LT_KERNELARGS,  '=' },
      { "boot",	    LT_BOOT,	    '=' },
      { "lba",	    LT_LBA,	    ' ' },
-Line 162 
 struct keywordTypes liloKeywords[] = {
+Line 542 
 struct keywordTypes liloKeywords[] = {
      { NULL,	    0, 0 },
  };
+ struct keywordTypes eliloKeywords[] = {
+     { "label",	    LT_TITLE,	    '=' },
+     { "root",	    LT_ROOT,	    '=' },
+     { "default",    LT_DEFAULT,	    '=' },
+     { "image",	    LT_KERNEL,	    '=' },
+     { "initrd",	    LT_INITRD,	    '=' },
+     { "append",	    LT_KERNELARGS,  '=' },
+     { "vmm",	    LT_HYPER,       '=' },
+     { NULL,	    0, 0 },
+ };
  struct keywordTypes siloKeywords[] = {
      { "label",	    LT_TITLE,	    '=' },
      { "root",	    LT_ROOT,	    '=' },
-Line 183 
 struct keywordTypes ziplKeywords[] = {
+Line 574 
 struct keywordTypes ziplKeywords[] = {
      { NULL,         0, 0 },
  };
+ struct keywordTypes extlinuxKeywords[] = {
+     { "label",	    LT_TITLE,	    ' ' },
+     { "root",	    LT_ROOT,	    ' ' },
+     { "default",    LT_DEFAULT,	    ' ' },
+     { "kernel",	    LT_KERNEL,	    ' ' },
+     { "initrd",	    LT_INITRD,      ' ',	',' },
+     { "append",	    LT_KERNELARGS,  ' ' },
+     { "prompt",     LT_UNKNOWN,     ' ' },
+     { NULL,	    0, 0 },
+ };
+ int useextlinuxmenu;
  struct configFileInfo eliloConfigType = {
-     "/boot/efi/EFI/redhat/elilo.conf",	    /* defaultConfig */
+     .defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",
-     liloKeywords,			    /* keywords */
+     .keywords = eliloKeywords,
-,					    /* defaultIsIndex */
+     .entryStart = LT_KERNEL,
-,					    /* defaultSupportSaved */
+     .needsBootPrefix = 1,
-     LT_KERNEL,				    /* entrySeparator */
+     .argsInQuotes = 1,
-,			                    /* needsBootPrefix */
+     .mbConcatArgs = 1,
-,					    /* argsInQuotes */
-,					    /* maxTitleLength */
-,                                      /* titleBracketed */
  };
  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 */
  };
  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 */
  };
  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 */
  };
  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 */
+ struct configFileInfo extlinuxConfigType = {
-,                                      /* titleBracketed */
+     .defaultConfig = "/boot/extlinux/extlinux.conf",
+     .keywords = extlinuxKeywords,
+     .caseInsensitive = 1,
+     .entryStart = LT_TITLE,
+     .needsBootPrefix = 1,
+     .maxTitleLength = 255,
+     .mbAllowExtraInitRds = 1,
+     .defaultIsUnquoted = 1,
  };
  struct grubConfig {
-Line 255 
 struct grubConfig {
+Line 652 
 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);
- static char * strndup(char * from, int len);
+ 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);
  static void lineFree(struct singleLine * line);
  static int lineWrite(FILE * out, struct singleLine * line,
  		     struct configFileInfo * cfi);
  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 char * strndup(char * from, int len) {
+ static void insertElement(struct singleLine * line,
-     char * to;
+ 			  const char * item, int insertHere,
+ 			  struct configFileInfo * cfi);
-     to = malloc(len + 1);
+ static void removeElement(struct singleLine * line, int removeHere);
-     strncpy(to, from, len);
+ static struct keywordTypes * getKeywordByType(enum lineType_e type,
-     to[len] = '\0';
+ 					      struct configFileInfo * cfi);
+ static enum lineType_e getTypeByKeyword(char * keyword,
-     return to;
+ 					struct configFileInfo * cfi);
- }
+ static struct singleLine * getLineByType(enum lineType_e type,
+ 					 struct singleLine * line);
+ static int checkForExtLinux(struct grubConfig * config);
+ struct singleLine * addLineTmpl(struct singleEntry * entry,
+                                 struct singleLine * tmplLine,
+                                 struct singleLine * prevLine,
+                                 const char * val,
+ 				struct configFileInfo * cfi);
+ struct singleLine *  addLine(struct singleEntry * entry,
+                              struct configFileInfo * cfi,
+                              enum lineType_e type, char * defaultIndent,
+                              const char * val);
  static char * sdupprintf(const char *format, ...)
  #ifdef __GNUC__
-Line 313 
 static char * sdupprintf(const char *for
+Line 724 
 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 isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
+ 	case LT_INITRD:
+ 	    return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
+ 	default:
+ 	    return type;
+ 	}
+ #if defined(__i386__) || defined(__x86_64__)
+     } else if (cfi == &grub2ConfigType) {
+ 	switch (type) {
+ 	case LT_KERNEL:
+ 	    return LT_KERNEL_16;
+ 	case LT_INITRD:
+ 	    return LT_INITRD_16;
+ 	default:
+ 	    return type;
+ 	}
+ #endif
+     }
+     return type;
+ }
+ static struct keywordTypes * getKeywordByType(enum lineType_e type,
+ 					      struct configFileInfo * cfi) {
+     for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
+ 	if (kw->type == type)
+ 	    return kw;
+     }
+     return NULL;
+ }
+ static char *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {
+     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) {
+     for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
+ 	if (cfi->caseInsensitive) {
+ 	    if (!strcasecmp(keyword, kw->key))
+                 return kw->type;
+ 	} else {
+ 	    if (!strcmp(keyword, kw->key))
+ 	        return kw->type;
+ 	}
+     }
+     return LT_UNKNOWN;
+ }
+ static struct singleLine * getLineByType(enum lineType_e type,
+ 					 struct singleLine * line) {
+     dbgPrintf("getLineByType(%d): ", type);
+     for (; line; line = line->next) {
+ 	dbgPrintf("%d:%s ", line->type,
+ 		  line->numElements ? line->elements[0].item : "(empty)");
+ 	if (line->type & type) break;
+     }
+     dbgPrintf(line ? "\n" : " (failed)\n");
+     return line;
+ }
  static int isBracketedTitle(struct singleLine * line) {
-     if ((*line->elements[0].item == '[') && (line->numElements == 1)) {
+     if (line->numElements == 1 && *line->elements[0].item == '[') {
          int len = strlen(line->elements[0].item);
          if (*(line->elements[0].item + len - 1) == ']') {
              /* FIXME: this is a hack... */
-Line 326 
 static int isBracketedTitle(struct singl
+Line 819 
 static int isBracketedTitle(struct singl
      return 0;
  }
- /* figure out if this is a entry separator */
+ static int isEntryStart(struct singleLine * line,
- static int isEntrySeparator(struct singleLine * line,
                              struct configFileInfo * cfi) {
-     if (line->type == LT_WHITESPACE)
+     return line->type == cfi->entryStart || line->type == LT_OTHER ||
- 	return 0;
+ 	(cfi->titleBracketed && isBracketedTitle(line));
-     if (line->type == cfi->entrySeparator)
-         return 1;
-     if (line->type == LT_OTHER)
-         return 1;
-     if (cfi->titleBracketed && isBracketedTitle(line)) {
-         return 1;
-     }
-     return 0;
  }
  /* 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 389 
 static void lineInit(struct singleLine *
+Line 878 
 static void lineInit(struct singleLine *
      line->next = NULL;
  }
- static void lineFree(struct singleLine * line) {
+ struct singleLine * lineDup(struct singleLine * line) {
-     int i;
+     struct singleLine * newLine = malloc(sizeof(*newLine));
+     newLine->indent = strdup(line->indent);
+     newLine->next = NULL;
+     newLine->type = line->type;
+     newLine->numElements = line->numElements;
+     newLine->elements = malloc(sizeof(*newLine->elements) *
+ 			       newLine->numElements);
+     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);
+     }
+     return newLine;
+ }
+ static void lineFree(struct singleLine * line) {
      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 405 
 static void lineFree(struct singleLine *
+Line 910 
 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;
  	if (fprintf(out, "%s", line->elements[i].item) == -1) return -1;
- 	if (fprintf(out, "%s", line->elements[i].indent) == -1) return -1;
+ 	if (i < line->numElements - 1)
+ 	    if (fprintf(out, "%s", line->elements[i].indent) == -1) return -1;
      }
      if (line->type == LT_KERNELARGS && cfi->argsInQuotes)
-Line 433 
 static int getNextLine(char ** bufPtr, s
+Line 949 
 static int getNextLine(char ** bufPtr, s
      char * chptr;
      int elementsAlloced = 0;
      struct lineElement * element;
-     struct keywordTypes * keywords = cfi->keywords;
      int first = 1;
-     int i;
      lineFree(line);
-Line 489 
 static int getNextLine(char ** bufPtr, s
+Line 1003 
 static int getNextLine(char ** bufPtr, s
      if (!line->numElements)
  	line->type = LT_WHITESPACE;
      else {
- 	for (i = 0; keywords[i].key; i++)
+ 	line->type = getTypeByKeyword(line->elements[0].item, cfi);
- 	    if (!strcmp(line->elements[0].item, keywords[i].key)) break;
+ 	if (line->type == LT_UNKNOWN) {
- 	if (keywords[i].key) {
- 	    line->type = keywords[i].type;
- 	} else {
- 	    line->type = LT_UNKNOWN;
              /* zipl does [title] instead of something reasonable like all
               * the other boot loaders.  kind of ugly */
              if (cfi->titleBracketed && isBracketedTitle(line)) {
-Line 510 
 static int getNextLine(char ** bufPtr, s
+Line 1018 
 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 522 
 static int getNextLine(char ** bufPtr, s
+Line 1029 
 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 532 
 static int getNextLine(char ** bufPtr, s
+Line 1039 
 static int getNextLine(char ** bufPtr, s
  		line->type = LT_WHITESPACE;
  		line->numElements = 0;
  	    }
+ 	} else {
+ 		struct keywordTypes *kw;
+ 		kw = getKeywordByType(line->type, cfi);
+ 		/* space isn't the only separator, we need to split
+ 		 * elements up more
+ 		 */
+ 		if (!isspace(kw->separatorChar)) {
+ 		    char indent[2] = "";
+ 		    indent[0] = kw->separatorChar;
+ 		    for (int i = 1; i < line->numElements; i++) {
+ 			char *p;
+ 			int numNewElements;
+ 			numNewElements = 0;
+ 			p = line->elements[i].item;
+ 			while (*p != '\0') {
+ 				if (*p == kw->separatorChar)
+ 					numNewElements++;
+ 				p++;
+ 			}
+ 			if (line->numElements + numNewElements >= elementsAlloced) {
+ 				elementsAlloced += numNewElements + 5;
+ 				line->elements = realloc(line->elements,
+ 					    sizeof(*line->elements) * elementsAlloced);
+ 			}
+ 			for (int j = line->numElements; j > i; j--) {
+ 				line->elements[j + numNewElements] = line->elements[j];
+ 			}
+ 			line->numElements += numNewElements;
+ 			p = line->elements[i].item;
+ 			while (*p != '\0') {
+ 				while (*p != kw->separatorChar && *p != '\0') p++;
+ 				if (*p == '\0') {
+ 					break;
+ 				}
+ 				line->elements[i + 1].indent = line->elements[i].indent;
+ 				line->elements[i].indent = strdup(indent);
+ 				*p++ = '\0';
+ 				i++;
+ 				line->elements[i].item = strdup(p);
+ 			}
+ 		    }
+ 		}
  	}
      }
      return 0;
  }
+ static int isnumber(const char *s)
+ {
+     int i;
+     for (i = 0; s[i] != '\0'; i++)
+ 	if (s[i] < '0' || s[i] > '9')
+ 	    return 0;
+     return i;
+ }
  static struct grubConfig * readConfig(const char * inName,
  				      struct configFileInfo * cfi) {
      int in;
-Line 549 
 static struct grubConfig * readConfig(co
+Line 1114 
 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 595 
 static struct grubConfig * readConfig(co
+Line 1163 
 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 611 
 static struct grubConfig * readConfig(co
+Line 1179 
 static struct grubConfig * readConfig(co
  	    entry->next = NULL;
  	}
- 	if (line->type == LT_DEFAULT && line->numElements == 2) {
+ 	if (line->type == LT_SET_VARIABLE) {
- 	    cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
+ 	    dbgPrintf("found 'set' command (%d elements): ", line->numElements);
- 	    defaultLine = line;
+ 	    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 (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
+ 	     */
+ 	    if (entry && entry->multiboot)
+ 		line->type = LT_HYPER;
          } else if (line->type == LT_MBMODULE) {
+ 	    /* go back and fix the LT_KERNEL line to indicate LT_HYPER
+ 	     * instead, now that we know this is a multiboot entry.
+ 	     * This only applies to grub, but that's the only place we
+ 	     * should find LT_MBMODULE lines anyway.
+ 	     */
+ 	    for (struct singleLine *l = entry->lines; l; l = l->next) {
+ 		if (l->type == LT_HYPER)
+ 		    break;
+ 		else if (iskernel(l->type)) {
+ 		    l->type = LT_HYPER;
+ 		    break;
+ 		}
+ 	    }
              entry->multiboot = 1;
+ 	} else if (line->type == LT_HYPER) {
+ 	    entry->multiboot = 1;
  	} else if (line->type == LT_FALLBACK && line->numElements == 2) {
  	    cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
  	    if (*end) cfg->fallbackImage = -1;
- 	} else if (line->type == LT_TITLE && line->numElements > 1) {
- 	    /* make the title a single argument (undoing our parsing) */
+ 	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
+                 (line->type == LT_TITLE && line->numElements > 1)) {
+ 	    /* make the title/default 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 643 
 static struct grubConfig * readConfig(co
+Line 1250 
 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 651 
 static struct grubConfig * readConfig(co
+Line 1323 
 static struct grubConfig * readConfig(co
  	    if (line->numElements >= 2) {
  		int last, len;
- 		if (*line->elements[1].item == '"')
+ 		if (isquote(*line->elements[1].item))
- 		    memcpy(line->elements[1].item, line->elements[1].item + 1,
+ 		    memmove(line->elements[1].item, line->elements[1].item + 1,
- 			   strlen(line->elements[1].item + 1) + 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';
  	    }
+ 	}
+ 	if (line->type == LT_DEFAULT && line->numElements == 2) {
+ 	    cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
+ 	    defaultLine = line;
  	}
  	/* If we find a generic config option which should live at the
-Line 680 
 static struct grubConfig * readConfig(co
+Line 1356 
 static struct grubConfig * readConfig(co
  		movedLine = 1;
  		continue; /* without setting 'last' */
  	}
  	/* If a second line of whitespace happens after a generic option
  	   which was moved, drop it. */
  	if (movedLine && line->type == LT_WHITESPACE && last->type == LT_WHITESPACE) {
-Line 695 
 static struct grubConfig * readConfig(co
+Line 1372 
 static struct grubConfig * readConfig(co
  		entry->lines = line;
  	    else
  		last->next = line;
+ 	    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 {
+ 	    else
  		last->next = line;
- 	    }
+ 	    dbgPrintf("readConfig added %s to cfg\n", getKeyByType(line->type, cfi));
  	}
  	last = line;
-Line 708 
 static struct grubConfig * readConfig(co
+Line 1391 
 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;
+ 			if (isnumber(defTitle)) {
+ 			    index = atoi(defTitle);
+ 			    entry = findEntryByIndex(cfg, index);
+ 			} else {
+ 			    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 730 
 static struct grubConfig * readConfig(co
+Line 1443 
 static struct grubConfig * readConfig(co
                                  extractTitle(line))) break;
                  }
  		i++;
+ 		entry = NULL;
  	    }
- 	    if (entry) cfg->defaultImage = i;
+ 	    if (entry){
+ 	        cfg->defaultImage = i;
+ 	    }else{
+ 	        cfg->defaultImage = -1;
+ 	    }
  	}
+     } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
+ 	char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
+ 	if (defTitle) {
+ 	    int index = 0;
+ 	    if (isnumber(defTitle)) {
+ 		index = atoi(defTitle);
+ 		entry = findEntryByIndex(cfg, index);
+ 	    } else {
+ 		entry = findEntryByTitle(cfg, defTitle, &index);
+ 	    }
+ 	    if (entry)
+ 		cfg->defaultImage = index;
+ 	}
+     } else {
+         cfg->defaultImage = 0;
      }
      return cfg;
-Line 749 
 static void writeDefault(FILE * out, cha
+Line 1482 
 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 769 
 static void writeDefault(FILE * out, cha
+Line 1521 
 static void writeDefault(FILE * out, cha
  	    if (!entry) return;
- 	    line = entry->lines;
+ 	    line = getLineByType(LT_TITLE, entry->lines);
- 	    while (line && line->type != LT_TITLE) line = line->next;
  	    if (line && line->numElements >= 2)
  		fprintf(out, "%sdefault%s%s\n", indent, separator,
-Line 804 
 static int writeConfig(struct grubConfig
+Line 1555 
 static int writeConfig(struct grubConfig
  	    int rc;
  	    /* most likely the symlink is relative, so change our
- 	       directory to / */
+ 	       directory to the dir of the symlink */
- 	    rc = chdir("/");
+ 	    char *dir = strdupa(outName);
+ 	    rc = chdir(dirname(dir));
  	    do {
  		buf = alloca(len + 1);
- 		rc = readlink(outName, buf, len);
+ 		rc = readlink(basename(outName), buf, len);
  		if (rc == len) len += 256;
  	    } while (rc == len);
-Line 843 
 static int writeConfig(struct grubConfig
+Line 1595 
 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 912 
 static int numEntries(struct grubConfig
+Line 1671 
 static int numEntries(struct grubConfig
      return i;
  }
- int suitableImage(struct singleEntry * entry, const char * bootPrefix,
+ static char *findDiskForRoot()
- 		  int skipRemoved, int flags) {
+ {
-     struct singleLine * line;
+     int fd;
-     char * fullName;
+     char buf[65536];
-     int i;
+     char *devname;
-     struct stat sb, sb2;
+     char *chptr;
-     char * dev;
+     int rc;
-     char * end;
-     char * rootspec;
-     line = entry->lines;
+     if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
-     while (line && line->type != LT_KERNEL) line = line->next;
+         fprintf(stderr, "grubby: failed to open %s: %s\n",
+                 _PATH_MOUNTED, strerror(errno));
-     if (!line) return 0;
+         return NULL;
-     if (skipRemoved && entry->skip) return 0;
+     }
-     if (line->numElements < 2) return 0;
-     if (flags & GRUBBY_BADIMAGE_OKAY) return 1;
+     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;
+     char * dev;
+     char * rootspec;
+     char * rootdev;
+     if (skipRemoved && entry->skip) {
+ 	notSuitablePrintf(entry, 0, "marked to skip\n");
+ 	return 0;
+     }
+     line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
+     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) {
+ 	    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 != NULL) ?
+     int hasslash = endswith(bootPrefix, '/') ||
-                                       strlen(rootspec) : 0));
+     	beginswith(line->elements[1].item + rootspec_offset, '/');
-     if (access(fullName, R_OK)) return 0;
+     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) {
  	dev = line->elements[i].item + 5;
      } else {
  	/* look for a lilo style LT_ROOT line */
- 	line = entry->lines;
+ 	line = getLineByType(LT_ROOT, entry->lines);
- 	while (line && line->type != LT_ROOT) line = line->next;
  	if (line && line->numElements >= 2) {
  	    dev = line->elements[1].item;
  	} else {
-             int type;
+ 	    /* didn't succeed in finding a LT_ROOT, let's try LT_KERNELARGS.
- 	    /* didn't succeed in finding a LT_ROOT, let's try LT_KERNELARGS */
+ 	     * grub+multiboot uses LT_MBMODULE for the args, so check that too.
- 	    line = entry->lines;
+ 	     */
+ 	    line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
-             type = ((entry->multiboot) ? LT_MBMODULE : LT_KERNELARGS);
- 	    while (line && line->type != type) line = line->next;
              /* 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;
              }
  	}
      }
-     if (!strncmp(dev, "LABEL=", 6)) {
+     dev = getpathbyspec(dev);
- 	dev += 6;
+     if (!getpathbyspec(dev)) {
+         notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
- 	/* check which device has this label */
+         return 0;
- 	dev = get_spec_by_volume_label(dev, &i, &i);
+     } else
- 	if (!dev) return 0;
+ 	dev = getpathbyspec(dev);
+     rootdev = findDiskForRoot();
+     if (!rootdev) {
+         notSuitablePrintf(entry, 0, "can't find root device\n");
+ 	return 0;
      }
-     if (*dev == '/') {
+     if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
- 	if (stat(dev, &sb))
+         notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
- 	    return 0;
+ 		getuuidbydev(rootdev), getuuidbydev(dev));
-     } else {
+         free(rootdev);
- 	sb.st_rdev = strtol(dev, &end, 16);
+         return 0;
- 	if (*end) return 0;
+     }
+     if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
+         notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
+ 		getuuidbydev(rootdev), getuuidbydev(dev));
+ 	free(rootdev);
+         return 0;
      }
-     stat("/", &sb2);
-     if (sb.st_rdev != sb2.st_dev) return 0;
+     free(rootdev);
+     notSuitablePrintf(entry, 1, "\n");
      return 1;
  }
-Line 1034 
 struct singleEntry * findEntryByPath(str
+Line 1970 
 struct singleEntry * findEntryByPath(str
  	entry = findEntryByIndex(config, indexVars[i]);
  	if (!entry) return NULL;
- 	line = entry->lines;
+ 	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
- 	while (line && line->type != LT_KERNEL)
- 	    line = line->next;
  	if (!line) return NULL;
  	if (index) *index = indexVars[i];
-Line 1075 
 struct singleEntry * findEntryByPath(str
+Line 2008 
 struct singleEntry * findEntryByPath(str
  	if (!strncmp(kernel, "TITLE=", 6)) {
  	    prefix = "";
- 	    checkType = LT_TITLE;
+ 	    checkType = LT_TITLE|LT_MENUENTRY;
  	    kernel += 6;
  	}
- 	while ((entry = findEntryByIndex(config, i))) {
+ 	for (entry = findEntryByIndex(config, i); entry; entry = entry->next, i++) {
- 	    line = entry->lines;
+ 	    if (entry->skip) continue;
- 	    while (line && line->type != checkType) line=line->next;
+ 	    dbgPrintf("findEntryByPath looking for %d %s in %p\n", checkType, kernel, entry);
- 	    if (line && line->numElements >= 2 && !entry->skip) {
+ 	    /* check all the lines matching checkType */
-                 rootspec = getRootSpecifier(line->elements[1].item);
+ 	    for (line = entry->lines; line; line = line->next) {
- 	        if (!strcmp(line->elements[1].item  +
+ 		enum lineType_e ct = checkType;
-                             ((rootspec != NULL) ? strlen(rootspec) : 0),
+ 		if (entry->multiboot && checkType == LT_KERNEL)
-                             kernel + strlen(prefix)))
+ 		    ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
-                     break;
+ 		else if (checkType & LT_KERNEL)
-             }
+ 		    ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
+ 		line = getLineByType(ct, line);
-             /* have to check multiboot lines too */
+ 		if (!line)
-             if (entry->multiboot) {
+ 		    break;  /* not found in this entry */
-                 while (line && line->type != LT_MBMODULE) line = line->next;
-                 if (line && line->numElements >= 2 && !entry->skip) {
+ 		if (line && line->type != LT_MENUENTRY &&
-                     rootspec = getRootSpecifier(line->elements[1].item);
+ 			line->numElements >= 2) {
-                     if (!strcmp(line->elements[1].item  +
+ 		    rootspec = getRootSpecifier(line->elements[1].item);
-                                 ((rootspec != NULL) ? strlen(rootspec) : 0),
+ 		    if (!strcmp(line->elements[1].item +
-                                 kernel + strlen(prefix)))
+ 				((rootspec != NULL) ? strlen(rootspec) : 0),
-                         break;
+ 				kernel + strlen(prefix)))
-                 }
+ 			break;
-             }
+ 		}
+ 		if(line->type == LT_MENUENTRY &&
+ 			!strcmp(line->elements[1].item, kernel))
+ 		    break;
+ 	    }
- 	    i++;
+ 	    /* 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|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
+ 		break; /* found 'im! */
  	}
  	if (index) *index = i;
      }
-     if (!entry) return NULL;
+     return entry;
+ }
-     /* make sure this entry has a kernel identifier; this skips non-Linux
+ struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
-        boot entries (could find netbsd etc, though, which is unfortunate) */
+ 				      int * index) {
-     line = entry->lines;
+     struct singleEntry * entry;
-     while (line && line->type != LT_KERNEL) line = line->next;
+     struct singleLine * line;
-     if (!line) {
+     int i;
- 	if (!index) index = &i;
+     char * newtitle;
- 	(*index)++;
- 	return findEntryByPath(config, kernel, prefix, index);
+     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;
  }
-Line 1147 
 struct singleEntry * findTemplate(struct
+Line 2107 
 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;
+ 		if (isnumber(defTitle)) {
+ 		    index = atoi(defTitle);
+ 		    entry = findEntryByIndex(cfg, index);
+ 		} else {
+ 		    entry = findEntryByTitle(cfg, defTitle, &index);
+ 		}
+ 		if (entry)
+ 		    cfg->defaultImage = index;
+ 	    }
+ 	}
+     } else if (cfg->defaultImage > -1) {
  	entry = findEntryByIndex(cfg, cfg->defaultImage);
  	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
  	    if (indexPtr) *indexPtr = cfg->defaultImage;
-Line 1200 
 void markRemovedImage(struct grubConfig
+Line 2175 
 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 1208 
 void markRemovedImage(struct grubConfig
+Line 2192 
 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 1227 
 void setDefaultImage(struct grubConfig *
+Line 2217 
 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 1286 
 void displayEntry(struct singleEntry * e
+Line 2277 
 void displayEntry(struct singleEntry * e
      char * root = NULL;
      int i;
-     line = entry->lines;
-     while (line && line->type != LT_KERNEL) line = line->next;
      printf("index=%d\n", index);
-     printf("kernel=%s\n", line->elements[1].item);
+     line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
+     if (!line) {
+         printf("non linux entry\n");
+         return;
+     }
+     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 1308 
 void displayEntry(struct singleEntry * e
+Line 2305 
 void displayEntry(struct singleEntry * e
  	}
  	printf("\"\n");
      } else {
- 	line = entry->lines;
+ 	line = getLineByType(LT_KERNELARGS, entry->lines);
- 	while (line && line->type != LT_KERNELARGS) line=line->next;
  	if (line) {
  	    char * s;
-Line 1334 
 void displayEntry(struct singleEntry * e
+Line 2329 
 void displayEntry(struct singleEntry * e
      }
      if (!root) {
- 	line = entry->lines;
+ 	line = getLineByType(LT_ROOT, entry->lines);
- 	while (line && line->type != LT_ROOT) line = line->next;
  	if (line && line->numElements >= 2)
  	    root=line->elements[1].item;
      }
-Line 1351 
 void displayEntry(struct singleEntry * e
+Line 2344 
 void displayEntry(struct singleEntry * e
  	printf("root=%s\n", s);
      }
-     line = entry->lines;
+     line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
-     while (line && line->type != LT_INITRD) line = line->next;
      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 1369 
 int parseSysconfigGrub(int * lbaPtr, cha
+Line 2637 
 int parseSysconfigGrub(int * lbaPtr, cha
      char * start;
      char * param;
-     in = fopen("/etc/sysconfig/grub", "r");
+     in = fopen("/etc/conf.d/grub", "r");
      if (!in) return 1;
      if (lbaPtr) *lbaPtr = 0;
-Line 1410 
 int parseSysconfigGrub(int * lbaPtr, cha
+Line 2678 
 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 1431 
 int displayInfo(struct grubConfig * conf
+Line 2712 
 int displayInfo(struct grubConfig * conf
  	return 1;
      }
-     /* this is a horrible hack to support /etc/sysconfig/grub; there must
+     /* this is a horrible hack to support /etc/conf.d/grub; there must
         be a better way */
      if (config->cfi == &grubConfigType) {
  	dumpSysconfigGrub();
      } else {
- 	line = config->theLines;
+ 	line = getLineByType(LT_BOOT, config->theLines);
- 	while (line && line->type != LT_BOOT) line = line->next;
  	if (line && line->numElements >= 1) {
  	    printf("boot=%s\n", line->elements[1].item);
  	}
- 	line = config->theLines;
+ 	line = getLineByType(LT_LBA, config->theLines);
- 	while (line && line->type != LT_LBA) line = line->next;
  	if (line) printf("lba\n");
      }
-Line 1458 
 int displayInfo(struct grubConfig * conf
+Line 2737 
 int displayInfo(struct grubConfig * conf
      return 0;
  }
+ struct singleLine * addLineTmpl(struct singleEntry * entry,
+ 				struct singleLine * tmplLine,
+ 				struct singleLine * prevLine,
+ 				const char * val,
+ 				struct configFileInfo * cfi)
+ {
+     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]
+ 	 */
+ 	if (newLine->numElements > 1)
+ 	    removeElement(newLine, 1);
+ 	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|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
+ 	    char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
+ 	    if (rootspec != NULL) {
+ 		free(newLine->elements[1].item);
+ 		newLine->elements[1].item =
+ 		    sdupprintf("%s%s", rootspec, val);
+ 	    }
+ 	}
+     }
+     dbgPrintf("addLineTmpl(%s)\n", newLine->numElements ?
+ 	      newLine->elements[0].item : "");
+     if (!entry->lines) {
+ 	/* first one on the list */
+ 	entry->lines = newLine;
+     } else if (prevLine) {
+ 	/* add after prevLine */
+ 	newLine->next = prevLine->next;
+ 	prevLine->next = newLine;
+     }
+     return newLine;
+ }
  /* val may be NULL */
  struct singleLine *  addLine(struct singleEntry * entry,
  			     struct configFileInfo * cfi,
- 			     enum lineType_e type, const char * defaultIndent,
+ 			     enum lineType_e type, char * defaultIndent,
- 			     char * val) {
+ 			     const char * val) {
      struct singleLine * line, * prev;
-     int i;
+     struct keywordTypes * kw;
+     struct singleLine tmpl;
-     for (i = 0; cfi->keywords[i].key; i++)
+     /* NB: This function shouldn't allocate items on the heap, rather on the
- 	if (cfi->keywords[i].type == type) break;
+      * stack since it calls addLineTmpl which will make copies.
-     if (type != LT_TITLE || !cfi->titleBracketed)
+      */
-         if (!cfi->keywords[i].key) abort();
+     if (type == LT_TITLE && cfi->titleBracketed) {
+ 	/* we're doing a bracketed title (zipl) */
+ 	tmpl.type = type;
+ 	tmpl.numElements = 1;
+ 	tmpl.elements = alloca(sizeof(*tmpl.elements));
+ 	tmpl.elements[0].item = alloca(strlen(val)+3);
+ 	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) {
+ 	    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);
+ 	tmpl.elements[0].item = kw->key;
+ 	tmpl.elements[0].indent = alloca(2);
+ 	sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
+ 	if (val) {
+ 	    tmpl.elements[1].item = (char *)val;
+ 	    tmpl.elements[1].indent = "";
+ 	}
+     }
      /* The last non-empty line gives us the indention to us and the line
         to insert after. Note that comments are considered empty lines, which
         may not be ideal? If there are no lines or we are looking at the
         first line, we use defaultIndent (the first line is normally indented
         differently from the rest) */
-     if (entry->lines) {
+     for (line = entry->lines, prev = NULL; line; line = line->next) {
- 	line = entry->lines;
+ 	if (line->numElements) prev = line;
- 	prev = NULL;
+ 	/* fall back on the last line if prev isn't otherwise set */
- 	while (line) {
+ 	if (!line->next && !prev) prev = line;
- 	    if (line->numElements) prev = line;
- 	    line = line->next;
- 	}
- 	if (!prev) {
- 	    /* just use the last line */
- 	    prev = entry->lines;
- 	    while (prev->next) prev = prev->next;
- 	}
- 	line = prev->next;
- 	prev->next = malloc(sizeof(*line));
- 	prev->next->next = line;
- 	line = prev->next;
- 	if (prev == entry->lines)
- 	    line->indent = strdup(defaultIndent);
- 	else
- 	    line->indent = strdup(prev->indent);
-     } else {
- 	line = malloc(sizeof(*line));
- 	line->indent = strdup(defaultIndent);
- 	line->next = NULL;
      }
-     if (type != LT_TITLE || !cfi->titleBracketed) {
+     struct singleLine *menuEntry;
-         line->type = type;
+     menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
-         line->numElements = val ? 2 : 1;
+     if (tmpl.type == LT_ENTRY_END) {
-         line->elements = malloc(sizeof(*line->elements) * line->numElements);
+ 	if (menuEntry)
-         line->elements[0].item = strdup(cfi->keywords[i].key);
+ 	    tmpl.indent = menuEntry->indent;
-         line->elements[0].indent = malloc(2);
+ 	else
-         line->elements[0].indent[0] = cfi->keywords[i].nextChar;
+ 	    tmpl.indent = defaultIndent ?: "";
-         line->elements[0].indent[1] = '\0';
+     } else if (tmpl.type != LT_MENUENTRY) {
+ 	if (menuEntry)
-         if (val) {
+ 	    tmpl.indent = "\t";
-             line->elements[1].item = val;
+ 	else if (prev == entry->lines)
-             line->elements[1].indent = strdup("");
+ 	    tmpl.indent = defaultIndent ?: "";
-         }
+ 	else
-     } else {
+ 	    tmpl.indent = prev->indent;
-         /* we're doing the title of a bracketed title (zipl) */
-         line->type = type;
-         line->numElements = 1;
-         line->elements = malloc(sizeof(*line->elements) * line->numElements);
-         line->elements[0].item = malloc(strlen(val) + 3);
-         sprintf(line->elements[0].item, "[%s]", val);
-         line->elements[0].indent = strdup("");
      }
-     return line;
+     return addLineTmpl(entry, &tmpl, prev, val, cfi);
  }
  void removeLine(struct singleEntry * entry, struct singleLine * line) {
-Line 1553 
 void removeLine(struct singleEntry * ent
+Line 2901 
 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)
+ {
+     struct keywordTypes * kw;
+     char indent[2] = "";
+     /* sanity check */
+     if (insertHere > line->numElements) {
+ 	dbgPrintf("insertElement() adjusting insertHere from %d to %d\n",
+ 		  insertHere, line->numElements);
+ 	insertHere = line->numElements;
+     }
+     line->elements = realloc(line->elements, (line->numElements + 1) *
+ 			     sizeof(*line->elements));
+     memmove(&line->elements[insertHere+1],
+ 	    &line->elements[insertHere],
+ 	    (line->numElements - insertHere) *
+ 	    sizeof(*line->elements));
+     line->elements[insertHere].item = strdup(item);
+     kw = getKeywordByType(line->type, cfi);
+     if (line->numElements == 0) {
+ 	indent[0] = '\0';
+     } else if (insertHere == 0) {
+ 	indent[0] = kw->nextChar;
+     } else if (kw->separatorChar != '\0') {
+ 	indent[0] = kw->separatorChar;
+     } else {
+ 	indent[0] = ' ';
+     }
+     if (insertHere > 0 && line->elements[insertHere-1].indent[0] == '\0') {
+ 	/* move the end-of-line forward */
+ 	line->elements[insertHere].indent =
+ 	    line->elements[insertHere-1].indent;
+ 	line->elements[insertHere-1].indent = strdup(indent);
+     } else {
+ 	line->elements[insertHere].indent = strdup(indent);
+     }
+     line->numElements++;
+     dbgPrintf("insertElement(%s, '%s%s', %d)\n",
+ 	      line->elements[0].item,
+ 	      line->elements[insertHere].item,
+ 	      line->elements[insertHere].indent,
+ 	      insertHere);
+ }
+ static void removeElement(struct singleLine * line, int removeHere) {
+     int i;
+     /* sanity check */
+     if (removeHere >= line->numElements) return;
+     dbgPrintf("removeElement(%s, %d:%s)\n", line->elements[0].item,
+ 	      removeHere, line->elements[removeHere].item);
+     free(line->elements[removeHere].item);
+     if (removeHere > 1) {
+ 	/* previous argument gets this argument's post-indentation */
+ 	free(line->elements[removeHere-1].indent);
+ 	line->elements[removeHere-1].indent =
+ 	    line->elements[removeHere].indent;
+     } else {
+ 	free(line->elements[removeHere].indent);
+     }
+     /* now collapse the array, but don't bother to realloc smaller */
+     for (i = removeHere; i < line->numElements - 1; i++)
+ 	line->elements[i] = line->elements[i + 1];
+     line->numElements--;
+ }
  int argMatch(const char * one, const char * two) {
      char * first, * second;
      char * chptr;
-Line 1575 
 int updateActualImage(struct grubConfig
+Line 3064 
 int updateActualImage(struct grubConfig
      struct singleEntry * entry;
      struct singleLine * line, * rootLine;
      int index = 0;
-     int i, j, k;
+     int i, k;
      const char ** newArgs, ** oldArgs;
      const char ** arg;
-     const char * chptr;
+     int useKernelArgs, useRoot;
-     int useKernelArgs = 0;
-     int useRoot = 0;
      int firstElement;
-     int *usedElements, *usedArgs;
+     int *usedElements;
+     int doreplace;
      if (!image) return 0;
-Line 1609 
 int updateActualImage(struct grubConfig
+Line 3097 
 int updateActualImage(struct grubConfig
  	}
      }
-     for (i = 0; cfg->cfi->keywords[i].key; i++)
- 	if (cfg->cfi->keywords[i].type == LT_KERNELARGS) break;
-     if (cfg->cfi->keywords[i].key)
+     useKernelArgs = (getKeywordByType(LT_KERNELARGS, cfg->cfi)
- 	useKernelArgs = 1;
+ 		     && (!multibootArgs || cfg->cfi->mbConcatArgs));
-     for (i = 0; cfg->cfi->keywords[i].key; i++)
+     useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
- 	if (cfg->cfi->keywords[i].type == LT_ROOT) break;
+ 	       && !multibootArgs);
-     if (cfg->cfi->keywords[i].key)
+     for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
- 	useRoot = 1;
-     k = 0;
+ 	if (multibootArgs && !entry->multiboot)
-     for (arg = newArgs; *arg; arg++)
+ 	    continue;
-         k++;
-     usedArgs = calloc(k, sizeof(int));
+ 	/* Determine where to put the args.  If this config supports
+ 	 * LT_KERNELARGS, use that.  Otherwise use
+ 	 * LT_HYPER/LT_KERNEL/LT_MBMODULE lines.
+ 	 */
+ 	if (useKernelArgs) {
+ 	    line = getLineByType(LT_KERNELARGS, entry->lines);
+ 	    if (!line) {
+ 		/* no LT_KERNELARGS, need to add it */
+ 		line = addLine(entry, cfg->cfi, LT_KERNELARGS,
+ 			       cfg->secondaryIndent, NULL);
+ 	    }
+ 	    firstElement = 1;
-     while ((entry = findEntryByPath(cfg, image, prefix, &index))) {
+ 	} else if (multibootArgs) {
- 	index++;
+ 	    line = getLineByType(LT_HYPER, entry->lines);
+ 	    if (!line) {
+ 		/* a multiboot entry without LT_HYPER? */
+ 		continue;
+ 	    }
+ 	    firstElement = 2;
- 	line = entry->lines;
+ 	} else {
- 	while (line && line->type != LT_KERNEL) line = line->next;
+ 	    line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
- 	if (!line) continue;
+ 	    if (!line) {
- 	firstElement = 2;
+ 		/* no LT_KERNEL or LT_MBMODULE in this entry? */
+ 		continue;
-         if (entry->multiboot && !multibootArgs) {
+ 	    }
-             /* first mb module line is the real kernel */
+ 	    firstElement = 2;
-             while (line && line->type != LT_MBMODULE) line = line->next;
-             firstElement = 2;
-         } else if (useKernelArgs) {
- 	    while (line && line->type != LT_KERNELARGS) line = line->next;
- 	    firstElement = 1;
  	}
- 	if (!line && useKernelArgs) {
+ 	/* handle the elilo case which does:
- 	    /* no append in there, need to add it */
+ 	 *   append="hypervisor args -- kernel args"
- 	    line = addLine(entry, cfg->cfi, LT_KERNELARGS, NULL, NULL);
+ 	 */
+ 	if (entry->multiboot && cfg->cfi->mbConcatArgs) {
+ 	    /* this is a multiboot entry, make sure there's
+ 	     * -- on the args line
+ 	     */
+ 	    for (i = firstElement; i < line->numElements; i++) {
+ 		if (!strcmp(line->elements[i].item, "--"))
+ 		    break;
+ 	    }
+ 	    if (i == line->numElements) {
+ 		/* assume all existing args are kernel args,
+ 		 * prepend -- to make it official
+ 		 */
+ 		insertElement(line, "--", firstElement, cfg->cfi);
+ 		i = firstElement;
+ 	    }
+ 	    if (!multibootArgs) {
+ 		/* kernel args start after the -- */
+ 		firstElement = i + 1;
+ 	    }
+ 	} else if (cfg->cfi->mbConcatArgs) {
+ 	    /* this is a non-multiboot entry, remove hyper args */
+ 	    for (i = firstElement; i < line->numElements; i++) {
+ 		if (!strcmp(line->elements[i].item, "--"))
+ 		    break;
+ 	    }
+ 	    if (i < line->numElements) {
+ 		/* remove args up to -- */
+ 		while (strcmp(line->elements[firstElement].item, "--"))
+ 		    removeElement(line, firstElement);
+ 		/* remove -- */
+ 		removeElement(line, firstElement);
+ 	    }
  	}
-         usedElements = calloc(line->numElements, sizeof(int));
+         usedElements = calloc(line->numElements, sizeof(*usedElements));
-         k = 0;
+ 	for (k = 0, arg = newArgs; *arg; arg++, k++) {
- 	for (arg = newArgs; *arg; arg++) {
-             if (usedArgs[k]) {
+ 	    doreplace = 1;
-                 k++;
-                 continue;
-             }
  	    for (i = firstElement; i < line->numElements; i++) {
+ 		if (multibootArgs && cfg->cfi->mbConcatArgs &&
+ 		    !strcmp(line->elements[i].item, "--"))
+ 		{
+ 		    /* reached the end of hyper args, insert here */
+ 		    doreplace = 0;
+ 		    break;
+ 		}
                  if (usedElements[i])
                      continue;
  		if (!argMatch(line->elements[i].item, *arg)) {
                      usedElements[i]=1;
-                     usedArgs[k]=1;
  		    break;
                  }
              }
- 	    chptr = strchr(*arg, '=');
- 	    if (i < line->numElements) {
+ 	    if (i < line->numElements && doreplace) {
- 		/* replace */
+ 		/* direct replacement */
  		free(line->elements[i].item);
  		line->elements[i].item = strdup(*arg);
- 	    } else if (useRoot && !strncmp(*arg, "root=/dev/", 10) && *chptr) {
- 		rootLine = entry->lines;
- 		while (rootLine && rootLine->type != LT_ROOT)
- 		    rootLine = rootLine->next;
- 		if (!rootLine) {
- 		    rootLine = addLine(entry, cfg->cfi, LT_ROOT, NULL, NULL);
- 		    rootLine->elements = realloc(rootLine->elements,
-* sizeof(*rootLine->elements));
- 		    rootLine->numElements++;
- 		    rootLine->elements[1].indent = strdup("");
- 		    rootLine->elements[1].item = strdup("");
- 		}
- 		free(rootLine->elements[1].item);
+ 	    } else if (useRoot && !strncmp(*arg, "root=/dev/", 10)) {
- 		rootLine->elements[1].item = strdup(chptr + 1);
+ 		/* root= replacement */
- 	    } else {
+ 		rootLine = getLineByType(LT_ROOT, entry->lines);
- 		/* append */
+ 		if (rootLine) {
- 		line->elements = realloc(line->elements,
+ 		    free(rootLine->elements[1].item);
- 			(line->numElements + 1) * sizeof(*line->elements));
+ 		    rootLine->elements[1].item = strdup(*arg + 5);
- 		line->elements[line->numElements].item = strdup(*arg);
- 		usedElements = realloc(usedElements,
- 			(line->numElements + 1) * sizeof(int));
- 		usedElements[line->numElements] = 1;
- 		if (line->numElements > 1) {
- 		    /* add to existing list of arguments */
- 		    line->elements[line->numElements].indent =
- 			line->elements[line->numElements - 1].indent;
- 		    line->elements[line->numElements - 1].indent = strdup(" ");
  		} else {
- 		    /* First thing on this line; treat a bit differently. Note
+ 		    rootLine = addLine(entry, cfg->cfi, LT_ROOT,
- 		       this is only possible if we've added a LT_KERNELARGS
+ 				       cfg->secondaryIndent, *arg + 5);
- 		       entry */
- 		    line->elements[line->numElements].indent = strdup("");
  		}
+ 	    }
- 		line->numElements++;
+ 	    else {
+ 		/* insert/append */
+ 		insertElement(line, *arg, i, cfg->cfi);
+ 		usedElements = realloc(usedElements, line->numElements *
+ 				       sizeof(*usedElements));
+ 		memmove(&usedElements[i + 1], &usedElements[i],
+ 			line->numElements - i - 1);
+ 		usedElements[i] = 1;
  		/* if we updated a root= here even though there is a
  		   LT_ROOT available we need to remove the LT_ROOT entry
  		   (this will happen if we switch from a device to a label) */
  		if (useRoot && !strncmp(*arg, "root=", 5)) {
- 		    rootLine = entry->lines;
+ 		    rootLine = getLineByType(LT_ROOT, entry->lines);
- 		    while (rootLine && rootLine->type != LT_ROOT)
+ 		    if (rootLine)
- 			rootLine = rootLine->next;
- 		    if (rootLine) {
  			removeLine(entry, rootLine);
- 		    }
  		}
  	    }
-             k++;
  	}
          free(usedElements);
- 	/* no arguments to remove (i.e. no append line) */
- 	if (!line) continue;
- 	/* this won't remove an LT_ROOT item properly (but then again,
- 	   who cares? */
  	for (arg = oldArgs; *arg; arg++) {
- 	    for (i = firstElement; i < line->numElements; i++)
+ 	    for (i = firstElement; i < line->numElements; i++) {
- 		if (!argMatch(line->elements[i].item, *arg))
+ 		if (multibootArgs && cfg->cfi->mbConcatArgs &&
+ 		    !strcmp(line->elements[i].item, "--"))
+ 		    /* reached the end of hyper args, stop here */
+ 		    break;
+ 		if (!argMatch(line->elements[i].item, *arg)) {
+ 		    removeElement(line, i);
  		    break;
- 	    if (i < line->numElements) {
- 		/* if this isn't the first argument the previous argument
- 		   gets this arguments post-indention */
- 		if (i > firstElement) {
- 		    free(line->elements[i - 1].indent);
- 		    line->elements[i - 1].indent = line->elements[i].indent;
  		}
+ 	    }
- 		free(line->elements[i].item);
+ 	    /* handle removing LT_ROOT line too */
+ 	    if (useRoot && !strncmp(*arg, "root=", 5)) {
- 		for (j = i + 1; j < line->numElements; j++)
+ 		rootLine = getLineByType(LT_ROOT, entry->lines);
- 		    line->elements[j - 1] = line->elements[j];
+ 		if (rootLine)
+ 		    removeLine(entry, rootLine);
- 		line->numElements--;
  	    }
  	}
-Line 1760 
 int updateActualImage(struct grubConfig
+Line 3262 
 int updateActualImage(struct grubConfig
  	}
      }
-     free(usedArgs);
      free(newArgs);
      free(oldArgs);
-Line 1786 
 int updateImage(struct grubConfig * cfg,
+Line 3287 
 int updateImage(struct grubConfig * cfg,
      return rc;
  }
+ int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
+ 		 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, newMBKernel, prefix, &index)); index++) {
+         kernelLine = getLineByType(LT_MBMODULE, entry->lines);
+         if (!kernelLine) continue;
+         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_MBMODULE,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 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|LT_KERNEL_16, entry->lines);
+         if (!kernelLine) continue;
+         line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, 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);
+ 	enum lineType_e lt;
+ 	switch(kernelLine->type) {
+ 	    case LT_KERNEL:
+ 	        lt = LT_INITRD;
+ 		break;
+ 	    case LT_KERNEL_EFI:
+ 	        lt = LT_INITRD_EFI;
+ 		break;
+ 	    case LT_KERNEL_16:
+ 	        lt = LT_INITRD_16;
+ 		break;
+ 	    default:
+ 	        lt = preferredLineType(LT_INITRD, cfg->cfi);
+ 	}
+         line = addLine(entry, cfg->cfi, lt, 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 1809 
 int checkDeviceBootloader(const char * d
+Line 3398 
 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 1956 
 int checkForLilo(struct grubConfig * con
+Line 3555 
 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 1976 
 int checkForGrub(struct grubConfig * con
+Line 3589 
 int checkForGrub(struct grubConfig * con
      if (read(fd, bootSect, 512) != 512) {
  	fprintf(stderr, _("grubby: unable to read %s: %s\n"),
  		"/boot/grub/stage1", strerror(errno));
+  	close(fd);
+ 	return 1;
+     }
+     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);
+ }
+ int checkForExtLinux(struct grubConfig * config) {
+     int fd;
+     unsigned char bootSect[512];
+     char * boot;
+     char executable[] = "/boot/extlinux/extlinux";
+     printf("entered: checkForExtLinux()\n");
+     if (parseSysconfigGrub(NULL, &boot))
+ 	return 0;
+     /* assume grub is not installed -- not an error condition */
+     if (!boot)
+ 	return 0;
+     fd = open(executable, O_RDONLY);
+     if (fd < 0)
+ 	/* this doesn't exist if grub hasn't been installed */
+ 	return 0;
+     if (read(fd, bootSect, 512) != 512) {
+ 	fprintf(stderr, _("grubby: unable to read %s: %s\n"),
+ 		executable, strerror(errno));
  	return 1;
      }
      close(fd);
-Line 1983 
 int checkForGrub(struct grubConfig * con
+Line 3633 
 int checkForGrub(struct grubConfig * con
      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 1994 
 static char * getRootSpecifier(char * st
+Line 3668 
 static char * getRootSpecifier(char * st
      return rootspec;
  }
+ static char * getInitrdVal(struct grubConfig * config,
+ 			   const char * prefix, struct singleLine *tmplLine,
+ 			   const char * newKernelInitrd,
+ 			   const char ** extraInitrds, int extraInitrdCount)
+ {
+     char *initrdVal, *end;
+     int i;
+     size_t totalSize;
+     size_t prefixLen;
+     char separatorChar;
+     prefixLen = strlen(prefix);
+     totalSize = strlen(newKernelInitrd) - prefixLen + 1 /* \0 */;
+     for (i = 0; i < extraInitrdCount; i++) {
+ 	totalSize += sizeof(separatorChar);
+ 	totalSize += strlen(extraInitrds[i]) - prefixLen;
+     }
+     initrdVal = end = malloc(totalSize);
+     end = stpcpy (end, newKernelInitrd + prefixLen);
+     separatorChar = getKeywordByType(LT_INITRD, config->cfi)->separatorChar;
+     for (i = 0; i < extraInitrdCount; i++) {
+ 	const char *extraInitrd;
+ 	int j;
+ 	extraInitrd = extraInitrds[i] + prefixLen;
+ 	/* Don't add entries that are already there */
+ 	if (tmplLine != NULL) {
+ 	    for (j = 2; j < tmplLine->numElements; j++)
+ 		if (strcmp(extraInitrd, tmplLine->elements[j].item) == 0)
+ 		    break;
+ 	    if (j != tmplLine->numElements)
+ 		continue;
+ 	}
+ 	*end++ = separatorChar;
+ 	end = stpcpy(end, extraInitrd);
+     }
+     return initrdVal;
+ }
  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 * newMBKernel, char * newMBKernelArgs) {
+ 		 const char ** extraInitrds, int extraInitrdCount,
+                  const char * newMBKernel, const char * newMBKernelArgs,
+ 		 const char * newDevTreePath) {
      struct singleEntry * new;
-     struct singleLine * newLine = NULL, * tmplLine = NULL, * lastLine = NULL;
+     struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
      int needs;
-     char * indent = NULL;
-     char * rootspec = NULL;
      char * chptr;
-     int i;
-     enum lineType_e type;
      if (!newKernelPath) return 0;
-Line 2036 
 int addNewKernel(struct grubConfig * con
+Line 3754 
 int addNewKernel(struct grubConfig * con
      config->entries = new;
      /* copy/update from the template */
-     needs = KERNEL_KERNEL | KERNEL_INITRD | KERNEL_TITLE;
+     needs = NEED_KERNEL | NEED_TITLE;
+     if (newKernelInitrd)
+ 	needs |= NEED_INITRD;
      if (newMBKernel) {
-         needs |= KERNEL_MB;
+         needs |= NEED_MB;
          new->multiboot = 1;
      }
+     if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
+ 	needs |= NEED_DEVTREE;
      if (template) {
- 	for (tmplLine = template->lines; tmplLine; tmplLine = tmplLine->next) {
+ 	for (masterLine = template->lines;
- 	    /* remember the indention level; we may need it for new lines */
+ 	     masterLine && (tmplLine = lineDup(masterLine));
- 	    if (tmplLine->numElements)
+ 	     lineFree(tmplLine), masterLine = masterLine->next)
- 		indent = tmplLine->indent;
+ 	{
+ 	    dbgPrintf("addNewKernel processing %d\n", tmplLine->type);
  	    /* skip comments */
  	    chptr = tmplLine->indent;
  	    while (*chptr && isspace(*chptr)) chptr++;
  	    if (*chptr == '#') continue;
- 	    /* we don't need an initrd here */
+ 	    if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
- 	    if (tmplLine->type == LT_INITRD && !newKernelInitrd) continue;
+ 		if (!template->multiboot && (needs & NEED_MB)) {
+ 		    /* it's not a multiboot template and this is the kernel
-             if (tmplLine->type == LT_KERNEL &&
+ 		     * line.  Try to be intelligent about inserting the
-                 !template->multiboot && (needs & KERNEL_MB)) {
+ 		     * hypervisor at the same time.
-                 struct singleLine *l;
+ 		     */
-                 needs &= ~ KERNEL_MB;
+ 		    if (config->cfi->mbHyperFirst) {
+ 			/* insert the hypervisor first */
-                 l = addLine(new, config->cfi, LT_KERNEL,
+ 			newLine = addLine(new, config->cfi, LT_HYPER,
-                                   config->secondaryIndent,
+ 					  tmplLine->indent,
-                                   newMBKernel + strlen(prefix));
+ 					  newMBKernel + strlen(prefix));
+ 			/* set up for adding the kernel line */
-                 tmplLine = lastLine;
+ 			free(tmplLine->indent);
-                 if (!new->lines) {
+ 			tmplLine->indent = strdup(config->secondaryIndent);
-                     new->lines = l;
+ 			needs &= ~NEED_MB;
-                 } else {
+ 		    }
-                     newLine->next = l;
+ 		    if (needs & NEED_KERNEL) {
-                     newLine = l;
+ 			/* use addLineTmpl to preserve line elements,
-                 }
+ 			 * otherwise we could just call addLine.  Unfortunately
-                 continue;
+ 			 * this means making some changes to the template
-             } else if (tmplLine->type == LT_KERNEL &&
+ 			 * such as the indent change above and the type
-                        template->multiboot && !new->multiboot) {
+ 			 * change below.
-                 continue; /* don't need multiboot kernel here */
+ 			 */
-             }
+ 			struct keywordTypes * mbm_kw =
+ 			    getKeywordByType(LT_MBMODULE, config->cfi);
- 	    if (!new->lines) {
+ 			if (mbm_kw) {
- 		newLine = malloc(sizeof(*newLine));
+ 			    tmplLine->type = LT_MBMODULE;
- 		new->lines = newLine;
+ 			    free(tmplLine->elements[0].item);
- 	    } else {
+ 			    tmplLine->elements[0].item = strdup(mbm_kw->key);
- 		newLine->next = malloc(sizeof(*newLine));
+ 			}
- 		newLine = newLine->next;
+ 			newLine = addLineTmpl(new, tmplLine, newLine,
- 	    }
+ 					      newKernelPath + strlen(prefix), config->cfi);
+ 			needs &= ~NEED_KERNEL;
+ 		    }
+ 		    if (needs & NEED_MB) { /* !mbHyperFirst */
+ 			newLine = addLine(new, config->cfi, LT_HYPER,
+ 					  config->secondaryIndent,
+ 					  newMBKernel + strlen(prefix));
+ 			needs &= ~NEED_MB;
+ 		    }
+ 		} else if (needs & NEED_KERNEL) {
+ 		    newLine = addLineTmpl(new, tmplLine, newLine,
+ 					  newKernelPath + strlen(prefix), config->cfi);
+ 		    needs &= ~NEED_KERNEL;
+ 		}
+ 	    } else if (tmplLine->type == LT_HYPER &&
+ 		       tmplLine->numElements >= 2) {
+ 		if (needs & NEED_MB) {
+ 		    newLine = addLineTmpl(new, tmplLine, newLine,
+ 					  newMBKernel + strlen(prefix), config->cfi);
+ 		    needs &= ~NEED_MB;
+ 		}
- 	    newLine->indent = strdup(tmplLine->indent);
+ 	    } else if (tmplLine->type == LT_MBMODULE &&
- 	    newLine->next = NULL;
+ 		       tmplLine->numElements >= 2) {
- 	    newLine->type = tmplLine->type;
+ 		if (new->multiboot) {
- 	    newLine->numElements = tmplLine->numElements;
+ 		    if (needs & NEED_KERNEL) {
- 	    newLine->elements = malloc(sizeof(*newLine->elements) *
+ 			newLine = addLineTmpl(new, tmplLine, newLine,
- 					    newLine->numElements);
+ 					      newKernelPath +
- 	    for (i = 0; i < newLine->numElements; i++) {
+ 					      strlen(prefix), config->cfi);
- 		newLine->elements[i].item = strdup(tmplLine->elements[i].item);
+ 			needs &= ~NEED_KERNEL;
- 		newLine->elements[i].indent =
+ 		    } else if (config->cfi->mbInitRdIsModule &&
- 				strdup(tmplLine->elements[i].indent);
+ 			       (needs & NEED_INITRD)) {
- 	    }
+ 			char *initrdVal;
+ 			initrdVal = getInitrdVal(config, prefix, tmplLine,
-             lastLine = tmplLine;
+ 						 newKernelInitrd, extraInitrds,
- 	    if (tmplLine->type == LT_KERNEL && tmplLine->numElements >= 2) {
+ 						 extraInitrdCount);
-                 char * repl;
+ 			newLine = addLineTmpl(new, tmplLine, newLine,
-                 if (!template->multiboot) {
+ 					      initrdVal, config->cfi);
-                     needs &= ~KERNEL_KERNEL;
+ 			free(initrdVal);
-                     repl = newKernelPath;
+ 			needs &= ~NEED_INITRD;
-                 } else {
+ 		    }
-                     needs &= ~KERNEL_MB;
+ 		} else if (needs & NEED_KERNEL) {
-                     repl = newMBKernel;
+ 		    /* template is multi but new is not,
-                 }
+ 		     * insert the kernel in the first module slot
-                 if (new->multiboot && !template->multiboot) {
+ 		     */
-                     free(newLine->elements[0].item);
+ 		    tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
-                     newLine->elements[0].item = strdup("module");
+ 		    free(tmplLine->elements[0].item);
-                     newLine->type = LT_MBMODULE;
+ 		    tmplLine->elements[0].item =
-                 }
+ 			strdup(getKeywordByType(tmplLine->type,
- 		free(newLine->elements[1].item);
+ 						config->cfi)->key);
-                 rootspec = getRootSpecifier(tmplLine->elements[1].item);
+ 		    newLine = addLineTmpl(new, tmplLine, newLine,
-                 if (rootspec != NULL) {
+ 					  newKernelPath + strlen(prefix),
-                     newLine->elements[1].item = sdupprintf("%s%s",
+ 					  config->cfi);
-                                                            rootspec,
+ 		    needs &= ~NEED_KERNEL;
-                                                            repl +
+ 		} else if (needs & NEED_INITRD) {
-                                                            strlen(prefix));
+ 		    char *initrdVal;
-                 } else {
+ 		    /* template is multi but new is not,
-                     newLine->elements[1].item = strdup(repl +
+ 		     * insert the initrd in the second module slot
-                                                        strlen(prefix));
+ 		     */
-                 }
+ 		    tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
-             } else if (tmplLine->type == LT_MBMODULE &&
+ 		    free(tmplLine->elements[0].item);
-                        tmplLine->numElements >= 2 && (needs & KERNEL_KERNEL)) {
+ 		    tmplLine->elements[0].item =
-                 needs &= ~KERNEL_KERNEL;
+ 			strdup(getKeywordByType(tmplLine->type,
-                 if (!new->multiboot && template->multiboot) {
+ 						config->cfi)->key);
-                     free(newLine->elements[0].item);
+ 		    initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
-                     newLine->elements[0].item = strdup("kernel");
+ 		    newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
-                     newLine->type = LT_KERNEL;
+ 		    free(initrdVal);
-                 }
+ 		    needs &= ~NEED_INITRD;
- 		free(newLine->elements[1].item);
+ 		}
-                 rootspec = getRootSpecifier(tmplLine->elements[1].item);
-                 if (rootspec != NULL) {
-                     newLine->elements[1].item = sdupprintf("%s%s",
-                                                            rootspec,
-                                                            newKernelPath +
-                                                            strlen(prefix));
-                 } else {
-                     newLine->elements[1].item = strdup(newKernelPath +
-                                                        strlen(prefix));
-                 }
- 	    } else if (tmplLine->type == LT_INITRD &&
- 			    tmplLine->numElements >= 2) {
- 		needs &= ~KERNEL_INITRD;
- 		free(newLine->elements[1].item);
-                 if (new->multiboot && !template->multiboot) {
-                     free(newLine->elements[0].item);
-                     newLine->elements[0].item = strdup("module");
-                     newLine->type = LT_MBMODULE;
-                 }
-                 rootspec = getRootSpecifier(tmplLine->elements[1].item);
-                 if (rootspec != NULL) {
-                     newLine->elements[1].item = sdupprintf("%s%s",
-                                                            rootspec,
-                                                            newKernelInitrd +
-                                                            strlen(prefix));
-                 } else {
-                     newLine->elements[1].item = strdup(newKernelInitrd +
-                                                        strlen(prefix));
-                 }
-             } else if (tmplLine->type == LT_MBMODULE &&
-                        tmplLine->numElements >= 2 && (needs & KERNEL_INITRD)) {
- 		needs &= ~KERNEL_INITRD;
-                 if (!new->multiboot && template->multiboot) {
-                     free(newLine->elements[0].item);
-                     newLine->elements[0].item = strdup("initrd");
-                     newLine->type = LT_INITRD;
-                 }
- 		free(newLine->elements[1].item);
-                 rootspec = getRootSpecifier(tmplLine->elements[1].item);
-                 if (rootspec != NULL) {
-                     newLine->elements[1].item = sdupprintf("%s%s",
-                                                            rootspec,
-                                                            newKernelInitrd +
-                                                            strlen(prefix));
-                 } else {
-                     newLine->elements[1].item = strdup(newKernelInitrd +
-                                                        strlen(prefix));
-                 }
- 	    } else if (tmplLine->type == LT_TITLE &&
- 			    tmplLine->numElements >= 2) {
- 		needs &= ~KERNEL_TITLE;
- 		for (i = 1; i < newLine->numElements; i++) {
+ 	    } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
- 		    free(newLine->elements[i].item);
+ 		if (needs & NEED_INITRD &&
- 		    free(newLine->elements[i].indent);
+ 		    new->multiboot && !template->multiboot &&
+ 		    config->cfi->mbInitRdIsModule) {
+ 		    /* make sure we don't insert the module initrd
+ 		     * before the module kernel... if we don't do it here,
+ 		     * it will be inserted following the template.
+ 		     */
+ 		    if (!needs & NEED_KERNEL) {
+ 			char *initrdVal;
+ 			initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
+ 			newLine = addLine(new, config->cfi, LT_MBMODULE,
+ 					  config->secondaryIndent,
+ 					  initrdVal);
+ 			free(initrdVal);
+ 			needs &= ~NEED_INITRD;
+ 		    }
+ 		} else if (needs & NEED_INITRD) {
+ 		    char *initrdVal;
+ 		    initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
+ 		    newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
+ 		    free(initrdVal);
+ 		    needs &= ~NEED_INITRD;
  		}
- 		newLine->elements[1].item = strdup(newKernelTitle);
+ 	    } else if (tmplLine->type == LT_MENUENTRY &&
- 		newLine->elements[1].indent = strdup("");
+ 		       (needs & NEED_TITLE)) {
- 		newLine->numElements = 2;
+ 		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 &&
-                        config->cfi->titleBracketed &&
+ 		       (needs & NEED_TITLE)) {
-                        tmplLine->numElements == 1) {
+ 		if (tmplLine->numElements >= 2) {
-                 needs &= ~KERNEL_TITLE;
+ 		    newLine = addLineTmpl(new, tmplLine, newLine,
-                 free(newLine->elements[0].item);
+ 					  newKernelTitle, config->cfi);
-                 free(newLine->elements[0].indent);
+ 		    needs &= ~NEED_TITLE;
-                 newLine->elements = malloc(sizeof(*newLine->elements) *
+ 		} else if (tmplLine->numElements == 1 &&
-                                            newLine->numElements);
+ 			   config->cfi->titleBracketed) {
+ 		    /* addLineTmpl doesn't handle titleBracketed */
-                 newLine->elements[0].item = malloc(strlen(newKernelTitle) + 3);
+ 		    newLine = addLine(new, config->cfi, LT_TITLE,
-                 sprintf(newLine->elements[0].item, "[%s]", newKernelTitle);
+ 				      tmplLine->indent, newKernelTitle);
-                 newLine->elements[0].indent = strdup("");
+ 		    needs &= ~NEED_TITLE;
-                 newLine->numElements = 1;
+ 		}
-             }
+ 	    } 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 if (tmplLine->type == LT_DEVTREE &&
+ 		       tmplLine->numElements == 2 && newDevTreePath) {
+ 	        newLine = addLineTmpl(new, tmplLine, newLine,
+ 				      newDevTreePath + strlen(prefix),
+ 				      config->cfi);
+ 		needs &= ~NEED_DEVTREE;
+ 	    } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
+ 		const char *ndtp = newDevTreePath;
+ 		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
+ 		    ndtp += strlen(prefix);
+ 		newLine = addLine(new, config->cfi, LT_DEVTREE,
+ 				  config->secondaryIndent,
+ 				  ndtp);
+ 		needs &= ~NEED_DEVTREE;
+ 		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
+ 	    } else {
+ 		/* pass through other lines from the template */
+ 		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
+ 	    }
  	}
      } else {
- 	for (i = 0; config->cfi->keywords[i].key; i++) {
+ 	/* don't have a template, so start the entry with the
- 	    if ((config->cfi->keywords[i].type == config->cfi->entrySeparator) || (config->cfi->keywords[i].type == LT_OTHER))
+ 	 * appropriate starting line
+ 	 */
+ 	switch (config->cfi->entryStart) {
+ 	    case LT_KERNEL:
+ 	    case LT_KERNEL_EFI:
+ 	    case LT_KERNEL_16:
+ 		if (new->multiboot && config->cfi->mbHyperFirst) {
+ 		    /* fall through to LT_HYPER */
+ 		} else {
+ 		    newLine = addLine(new, config->cfi,
+ 		    		      preferredLineType(LT_KERNEL, config->cfi),
+ 				      config->primaryIndent,
+ 				      newKernelPath + strlen(prefix));
+ 		    needs &= ~NEED_KERNEL;
+ 		    break;
+ 		}
+ 	    case LT_HYPER:
+ 		newLine = addLine(new, config->cfi, LT_HYPER,
+ 				  config->primaryIndent,
+ 				  newMBKernel + strlen(prefix));
+ 		needs &= ~NEED_MB;
  		break;
-         }
- 	switch (config->cfi->keywords[i].type) {
+ 	    case LT_MENUENTRY: {
- 	    case LT_KERNEL:  needs &= ~KERNEL_KERNEL,
+ 		char *nkt = malloc(strlen(newKernelTitle)+3);
- 			     chptr = newKernelPath + strlen(prefix);
+ 		strcpy(nkt, "'");
- 			     type = LT_KERNEL; break;
+ 		strcat(nkt, newKernelTitle);
- 	    case LT_TITLE:   needs &= ~KERNEL_TITLE, chptr = newKernelTitle;
+ 		strcat(nkt, "'");
- 			     type = LT_TITLE; break;
+ 	        newLine = addLine(new, config->cfi, LT_MENUENTRY,
- 	    default:
+ 				  config->primaryIndent, nkt);
-                 /* zipl strikes again */
+ 		free(nkt);
-                 if (config->cfi->titleBracketed) {
+ 		needs &= ~NEED_TITLE;
-                     needs &= ~KERNEL_TITLE;
+ 		needs |= NEED_END;
-                     chptr = newKernelTitle;
+ 		break;
-                     type = LT_TITLE;
+ 	    }
-                     break;
+ 	    case LT_TITLE:
-                 } else {
+ 		if( useextlinuxmenu != 0 ){	// We just need useextlinuxmenu to not be zero (set above)
-                     abort();
+ 			char * templabel;
-                 }
+ 			int x = 0, y = 0;
- 	}
+ 			templabel = strdup(newKernelTitle);
+ 			while( templabel[x]){
+ 				if( templabel[x] == ' ' ){
+ 					y = x;
+ 					while( templabel[y] ){
+ 						templabel[y] = templabel[y+1];
+ 						y++;
+ 					}
+ 				}
+ 				x++;
+ 			}
+ 			newLine = addLine(new, config->cfi, LT_TITLE,
+ 					  config->primaryIndent, templabel);
+ 			free(templabel);
+ 		}else{
+ 			newLine = addLine(new, config->cfi, LT_TITLE,
+ 					  config->primaryIndent, newKernelTitle);
+ 		}
+ 		needs &= ~NEED_TITLE;
+ 		break;
- 	newLine = addLine(new, config->cfi, type, config->primaryIndent, chptr);
+ 	    default:
- 	new->lines = newLine;
+ 		abort();
+ 	}
      }
-     if (new->multiboot) {
+     /* add the remainder of the lines, i.e. those that either
-         if (needs & KERNEL_MB)
+      * weren't present in the template, or in the case of no template,
-             newLine = addLine(new, config->cfi, LT_KERNEL,
+      * all the lines following the entryStart.
-                               config->secondaryIndent,
+      */
-                               newMBKernel + strlen(prefix));
+     if (needs & NEED_TITLE) {
-         if (needs & KERNEL_KERNEL)
+ 	newLine = addLine(new, config->cfi, LT_TITLE,
-             newLine = addLine(new, config->cfi, LT_MBMODULE,
+ 			  config->secondaryIndent,
-                               config->secondaryIndent,
+ 			  newKernelTitle);
-                               newKernelPath + strlen(prefix));
+ 	needs &= ~NEED_TITLE;
-         /* don't need to check for title as it's guaranteed to have been
+     }
-          * done as we only do multiboot with grub which uses title as
+     if ((needs & NEED_MB) && config->cfi->mbHyperFirst) {
-          * a separator */
+ 	newLine = addLine(new, config->cfi, LT_HYPER,
-         if (needs & KERNEL_INITRD && newKernelInitrd)
+ 			  config->secondaryIndent,
-             newLine = addLine(new, config->cfi, LT_MBMODULE,
+ 			  newMBKernel + strlen(prefix));
-                               config->secondaryIndent,
+ 	needs &= ~NEED_MB;
-                               newKernelInitrd + strlen(prefix));
+     }
-     } else {
+     if (needs & NEED_KERNEL) {
-         if (needs & KERNEL_KERNEL)
+ 	newLine = addLine(new, config->cfi,
-             newLine = addLine(new, config->cfi, LT_KERNEL,
+ 			  (new->multiboot && getKeywordByType(LT_MBMODULE,
-                               config->secondaryIndent,
+ 							      config->cfi))
-                               newKernelPath + strlen(prefix));
+ 			  	? LT_MBMODULE
-         if (needs & KERNEL_TITLE)
+ 				: preferredLineType(LT_KERNEL, config->cfi),
-             newLine = addLine(new, config->cfi, LT_TITLE,
+ 			  config->secondaryIndent,
-                               config->secondaryIndent,
+ 			  newKernelPath + strlen(prefix));
-                               newKernelTitle);
+ 	needs &= ~NEED_KERNEL;
-         if (needs & KERNEL_INITRD && newKernelInitrd)
+     }
-             newLine = addLine(new, config->cfi, LT_INITRD,
+     if (needs & NEED_MB) {
-                               config->secondaryIndent,
+ 	newLine = addLine(new, config->cfi, LT_HYPER,
-                               newKernelInitrd + strlen(prefix));
+ 			  config->secondaryIndent,
+ 			  newMBKernel + strlen(prefix));
+ 	needs &= ~NEED_MB;
+     }
+     if (needs & NEED_INITRD) {
+ 	char *initrdVal;
+ 	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
+ 	newLine = addLine(new, config->cfi,
+ 			  (new->multiboot && getKeywordByType(LT_MBMODULE,
+ 							      config->cfi))
+ 			   ? LT_MBMODULE
+ 			   : preferredLineType(LT_INITRD, config->cfi),
+ 			  config->secondaryIndent,
+ 			  initrdVal);
+ 	free(initrdVal);
+ 	needs &= ~NEED_INITRD;
+     }
+     if (needs & NEED_DEVTREE) {
+ 	newLine = addLine(new, config->cfi, LT_DEVTREE,
+ 			  config->secondaryIndent,
+ 			  newDevTreePath);
+ 	needs &= ~NEED_DEVTREE;
+     }
+     /* NEEDS_END must be last on bootloaders that need it... */
+     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);
+ 	abort();
      }
      if (updateImage(config, "0", prefix, newKernelArgs, NULL,
-Line 2274 
 int addNewKernel(struct grubConfig * con
+Line 4107 
 int addNewKernel(struct grubConfig * con
      return 0;
  }
+ static void traceback(int signum)
+ {
+     void *array[40];
+     size_t size;
+     signal(SIGSEGV, SIG_DFL);
+     memset(array, '\0', sizeof (array));
+     size = backtrace(array, 40);
+     fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
+             (unsigned long)size);
+     backtrace_symbols_fd(array, size, STDERR_FILENO);
+     exit(1);
+ }
  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;
      int bootloaderProbe = 0;
+     int extraInitrdCount = 0;
      char * updateKernelPath = NULL;
      char * newKernelPath = NULL;
      char * removeKernelPath = NULL;
      char * newKernelArgs = NULL;
      char * newKernelInitrd = NULL;
      char * newKernelTitle = NULL;
-     char * newKernelVersion = NULL;
+     char * newDevTreePath = NULL;
      char * newMBKernel = NULL;
      char * newMBKernelArgs = NULL;
      char * removeMBKernelArgs = NULL;
-Line 2299 
 int main(int argc, const char ** argv) {
+Line 4150 
 int main(int argc, const char ** argv) {
      char * defaultKernel = NULL;
      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 2322 
 int main(int argc, const char ** argv) {
+Line 4178 
 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 2335 
 int main(int argc, const char ** argv) {
+Line 4191 
 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") },
+ 	{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
+ 	    _("device tree file for new stanza"), _("dtb-path") },
  	{ "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',
+ 	    _("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 2365 
 int main(int argc, const char ** argv) {
+Line 4240 
 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 2382 
 int main(int argc, const char ** argv) {
+Line 4260 
 int main(int argc, const char ** argv) {
  	{ 0, 0, 0, 0, 0 }
      };
+     useextlinuxmenu=0;
+     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 2391 
 int main(int argc, const char ** argv) {
+Line 4287 
 int main(int argc, const char ** argv) {
  	    printf("grubby version %s\n", VERSION);
  	    exit(0);
  	    break;
+ 	  case 'i':
+ 	    if (extraInitrdCount < MAX_EXTRA_INITRDS) {
+ 	    	extraInitrds[extraInitrdCount++] = strdup(poptGetOptArg(optCon));
+ 	    } else {
+ 		fprintf(stderr, _("grubby: extra initrd maximum is %d\n"), extraInitrdCount);
+ 		return 1;
+ 	    }
+ 	    break;
  	}
      }
-Line 2406 
 int main(int argc, const char ** argv) {
+Line 4310 
 int main(int argc, const char ** argv) {
  	return 1;
      }
-     if ((configureLilo + configureGrub + configureELilo +
+     if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
- 		configureYaboot + configureSilo + configureZipl) > 1) {
+ 		configureYaboot + configureSilo + configureZipl +
+ 		configureExtLinux ) > 1) {
  	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));
  	return 1;
      } else if (bootloaderProbe && grubConfig) {
  	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 2426 
 int main(int argc, const char ** argv) {
+Line 4335 
 int main(int argc, const char ** argv) {
          cfi = &siloConfigType;
      } else if (configureZipl) {
          cfi = &ziplConfigType;
+     } else if (configureExtLinux) {
+ 	cfi = &extlinuxConfigType;
+ 	useextlinuxmenu=1;
      }
      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 ||
+     if (bootloaderProbe && (displayDefault || kernelInfo ||
- 			  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;
      }
-     if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||
+     if ((displayDefault || kernelInfo) && (newKernelPath ||
  			   removeKernelPath)) {
  	fprintf(stderr, _("grubby: --default-kernel and --info may not "
  			  "be used when adding or removing kernels\n"));
-Line 2465 
 int main(int argc, const char ** argv) {
+Line 4385 
 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)) {
+ 				  makeDefault || extraInitrdCount > 0)) {
  	fprintf(stderr, _("grubby: kernel path expected\n"));
  	return 1;
      }
-Line 2491 
 int main(int argc, const char ** argv) {
+Line 4411 
 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 2520 
 int main(int argc, const char ** argv) {
+Line 4446 
 int main(int argc, const char ** argv) {
  	bootPrefix = "";
      }
+     if (!cfi->mbAllowExtraInitRds &&
+ 	extraInitrdCount > 0) {
+ 	fprintf(stderr, _("grubby: %s doesn't allow multiple initrds\n"), cfi->defaultConfig);
+ 	return 1;
+     }
      if (bootloaderProbe) {
- 	int lrc = 0, grc = 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 2540 
 int main(int argc, const char ** argv) {
+Line 4482 
 int main(int argc, const char ** argv) {
  		lrc = checkForLilo(lconfig);
  	}
- 	if (lrc == 1 || grc == 1) return 1;
+ 	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)
+ 		extrc = 1;
+ 	    else
+ 		extrc = checkForExtLinux(lconfig);
+ 	}
+ 	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 (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 2557 
 int main(int argc, const char ** argv) {
+Line 4537 
 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 = entry->lines;
+ 	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
- 	while (line && line->type != LT_KERNEL) line = line->next;
  	if (!line) return 0;
          rootspec = getRootSpecifier(line->elements[1].item);
-Line 2570 
 int main(int argc, const char ** argv) {
+Line 4552 
 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 2581 
 int main(int argc, const char ** argv) {
+Line 4600 
 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 (newMBKernel) {
+ 		    if (addMBInitrd(config, newMBKernel, updateKernelPath,
+ 					bootPrefix, newKernelInitrd))
+ 			    return 1;
+ 	    } else {
+ 		    if (updateInitrd(config, updateKernelPath, bootPrefix,
+ 					newKernelInitrd))
+ 			return 1;
+ 	    }
+     }
      if (addNewKernel(config, template, bootPrefix, newKernelPath,
                       newKernelTitle, newKernelArgs, newKernelInitrd,
-                      newMBKernel, newMBKernelArgs)) return 1;
+                      (const char **)extraInitrds, extraInitrdCount,
+                      newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
      if (numEntries(config) == 0) {
-Line 2597 
 int main(int argc, const char ** argv) {
+Line 4628 
 int main(int argc, const char ** argv) {
      }
      if (!outputFile)
- 	outputFile = grubConfig;
+ 	outputFile = (char *)grubConfig;
      return writeConfig(config, outputFile, bootPrefix);
  }

 Legend:



Removed from v.532
 


changed lines


 
Added in v.2694
 Legend:



Removed from v.532
 


changed lines


 
Added in v.2694
-Removed from v.532
+Added in v.2694