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

Parent Directory | Revision Log | Patch

	revision 1800 by niro, Mon Apr 16 17:46:40 2012 UTC	revision 2258 by niro, Mon Oct 21 14:02:25 2013 UTC
#	Line 36	Line 36
36	#include <signal.h>	#include <signal.h>
37	#include <blkid/blkid.h>	#include <blkid/blkid.h>
38
39		#include "log.h"
40
41	#ifndef DEBUG	#ifndef DEBUG
42	#define DEBUG 0	#define DEBUG 0
43	#endif	#endif
#	Line 56  int debug = 0; /* Currently just for tem	Line 58  int debug = 0; /* Currently just for tem
58	#define NOOP_OPCODE 0x90	#define NOOP_OPCODE 0x90
59	#define JMP_SHORT_OPCODE 0xeb	#define JMP_SHORT_OPCODE 0xeb
60
61		int isEfi = 0;
62
63		char *saved_command_line = NULL;
64
65	/* comments get lumped in with indention */	/* comments get lumped in with indention */
66	struct lineElement {	struct lineElement {
67	char * item;	char * item;
#	Line 82  enum lineType_e {	Line 88  enum lineType_e {
88	LT_MENUENTRY    = 1 << 17,	LT_MENUENTRY    = 1 << 17,
89	LT_ENTRY_END    = 1 << 18,	LT_ENTRY_END    = 1 << 18,
90	LT_SET_VARIABLE = 1 << 19,	LT_SET_VARIABLE = 1 << 19,
91	LT_UNKNOWN      = 1 << 20,	LT_KERNEL_EFI   = 1 << 20,
92		LT_INITRD_EFI   = 1 << 21,
93		LT_UNKNOWN      = 1 << 22,
94	};	};
95
96	struct singleLine {	struct singleLine {
#	Line 128  struct configFileInfo;	Line 136  struct configFileInfo;
136	typedef const char *(*findConfigFunc)(struct configFileInfo *);	typedef const char *(*findConfigFunc)(struct configFileInfo *);
137	typedef const int (*writeLineFunc)(struct configFileInfo *,	typedef const int (*writeLineFunc)(struct configFileInfo *,
138	struct singleLine *line);	struct singleLine *line);
139		typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
140		typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
141
142	struct configFileInfo {	struct configFileInfo {
143	char * defaultConfig;	char * defaultConfig;
144	findConfigFunc findConfig;	findConfigFunc findConfig;
145	writeLineFunc writeLine;	writeLineFunc writeLine;
146		getEnvFunc getEnv;
147		setEnvFunc setEnv;
148	struct keywordTypes * keywords;	struct keywordTypes * keywords;
149		int caseInsensitive;
150	int defaultIsIndex;	int defaultIsIndex;
151	int defaultIsVariable;	int defaultIsVariable;
152	int defaultSupportSaved;	int defaultSupportSaved;
153		int defaultIsSaved;
154	enum lineType_e entryStart;	enum lineType_e entryStart;
155	enum lineType_e entryEnd;	enum lineType_e entryEnd;
156	int needsBootPrefix;	int needsBootPrefix;
#	Line 148  struct configFileInfo {	Line 162  struct configFileInfo {
162	int mbInitRdIsModule;	int mbInitRdIsModule;
163	int mbConcatArgs;	int mbConcatArgs;
164	int mbAllowExtraInitRds;	int mbAllowExtraInitRds;
165		char *envFile;
166	};	};
167
168	struct keywordTypes grubKeywords[] = {	struct keywordTypes grubKeywords[] = {
#	Line 164  struct keywordTypes grubKeywords[] = {	Line 179  struct keywordTypes grubKeywords[] = {
179
180	const char *grubFindConfig(struct configFileInfo *cfi) {	const char *grubFindConfig(struct configFileInfo *cfi) {
181	static const char *configFiles[] = {	static const char *configFiles[] = {
	"/etc/grub.conf",
182	"/boot/grub/grub.conf",	"/boot/grub/grub.conf",
183	"/boot/grub/menu.lst",	"/boot/grub/menu.lst",
184		"/etc/grub.conf",
185	NULL	NULL
186	};	};
187	static int i = -1;	static int i = -1;
#	Line 205  struct keywordTypes grub2Keywords[] = {	Line 220  struct keywordTypes grub2Keywords[] = {
220	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
221	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
222	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
223		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
224	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
225		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
226	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
227	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
228	{ NULL, 0, 0 },	{ NULL, 0, 0 },
#	Line 219  const char *grub2FindConfig(struct confi	Line 236  const char *grub2FindConfig(struct confi
236	};	};
237	static int i = -1;	static int i = -1;
238	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
239		int rc = -1;
240
241	if (i == -1) {	if (i == -1) {
242	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
243	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
244	if (!access(configFiles[i], R_OK)) {	if ((rc = access(configFiles[i], R_OK))) {
245		if (errno == EACCES) {
246		printf("Unable to access bootloader configuration file "
247		"\"%s\": %m\n", configFiles[i]);
248		exit(1);
249		}
250		continue;
251		} else {
252	dbgPrintf("found\n");	dbgPrintf("found\n");
253	return configFiles[i];	return configFiles[i];
254	}	}
#	Line 242  const char *grub2FindConfig(struct confi	Line 267  const char *grub2FindConfig(struct confi
267	return configFiles[i];	return configFiles[i];
268	}	}
269
270		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
271		static char *grub2GetEnv(struct configFileInfo *info, char *name)
272		{
273		static char buf[1025];
274		char *s = NULL;
275		char *ret = NULL;
276		char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";
277		int rc = asprintf(&s, "grub2-editenv %s list | grep '^%s='", envFile, name);
278
279		if (rc < 0)
280		return NULL;
281
282		FILE *f = popen(s, "r");
283		if (!f)
284		goto out;
285
286		memset(buf, '\0', sizeof (buf));
287		ret = fgets(buf, 1024, f);
288		pclose(f);
289
290		if (ret) {
291		ret += strlen(name) + 1;
292		ret[strlen(ret) - 1] = '\0';
293		}
294		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
295		out:
296		free(s);
297		return ret;
298		}
299
300		static int sPopCount(const char *s, const char *c)
301		{
302		int ret = 0;
303		if (!s)
304		return -1;
305		for (int i = 0; s[i] != '\0'; i++)
306		for (int j = 0; c[j] != '\0'; j++)
307		if (s[i] == c[j])
308		ret++;
309		return ret;
310		}
311
312		static char *shellEscape(const char *s)
313		{
314		int l = strlen(s) + sPopCount(s, "'") * 2;
315
316		char *ret = calloc(l+1, sizeof (*ret));
317		if (!ret)
318		return NULL;
319		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
320		if (s[i] == '\'')
321		ret[j++] = '\\';
322		ret[j] = s[i];
323		}
324		return ret;
325		}
326
327		static void unquote(char *s)
328		{
329		int l = strlen(s);
330
331		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
332		memmove(s, s+1, l-2);
333		s[l-2] = '\0';
334		}
335		}
336
337		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
338		{
339		char *s = NULL;
340		int rc = 0;
341		char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";
342
343		unquote(value);
344		value = shellEscape(value);
345		if (!value)
346		return -1;
347
348		rc = asprintf(&s, "grub2-editenv %s set '%s=%s'", envFile, name, value);
349		free(value);
350		if (rc <0)
351		return -1;
352
353		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
354		rc = system(s);
355		free(s);
356		return rc;
357		}
358
359		/* this is a gigantic hack to avoid clobbering grub2 variables... */
360		static int is_special_grub2_variable(const char *name)
361		{
362		if (!strcmp(name,"\"${next_entry}\""))
363		return 1;
364		if (!strcmp(name,"\"${prev_saved_entry}\""))
365		return 1;
366		return 0;
367		}
368
369	int sizeOfSingleLine(struct singleLine * line) {	int sizeOfSingleLine(struct singleLine * line) {
	int i;
370	int count = 0;	int count = 0;
371
372	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
373	int indentSize = 0;	int indentSize = 0;
374
375	count = count + strlen(line->elements[i].item);	count = count + strlen(line->elements[i].item);
#	Line 272  static int isquote(char q)	Line 395  static int isquote(char q)
395	return 0;	return 0;
396	}	}
397
398		static int iskernel(enum lineType_e type) {
399		return (type == LT_KERNEL || type == LT_KERNEL_EFI);
400		}
401
402		static int isinitrd(enum lineType_e type) {
403		return (type == LT_INITRD || type == LT_INITRD_EFI);
404		}
405
406	char *grub2ExtractTitle(struct singleLine * line) {	char *grub2ExtractTitle(struct singleLine * line) {
407	char * current;	char * current;
408	char * current_indent;	char * current_indent;
#	Line 329  char *grub2ExtractTitle(struct singleLin	Line 460  char *grub2ExtractTitle(struct singleLin
460
461	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
462	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
463		.getEnv = grub2GetEnv,
464		.setEnv = grub2SetEnv,
465	.keywords = grub2Keywords,	.keywords = grub2Keywords,
466	.defaultIsIndex = 1,	.defaultIsIndex = 1,
467	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 483  struct configFileInfo ziplConfigType = {	Line 616  struct configFileInfo ziplConfigType = {
616	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
617	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
618	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
619		.caseInsensitive = 1,
620	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
621	.needsBootPrefix = 1,	.needsBootPrefix = 1,
622	.maxTitleLength = 255,	.maxTitleLength = 255,
#	Line 507  struct singleEntry * findEntryByIndex(st	Line 641  struct singleEntry * findEntryByIndex(st
641	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
642	const char * path, const char * prefix,	const char * path, const char * prefix,
643	int * index);	int * index);
644		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
645		int * index);
646	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
647	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
648	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 571  static char * sdupprintf(const char *for	Line 707  static char * sdupprintf(const char *for
707	return buf;	return buf;
708	}	}
709
710		static enum lineType_e preferredLineType(enum lineType_e type,
711		struct configFileInfo *cfi) {
712		if (isEfi && cfi == &grub2ConfigType) {
713		switch (type) {
714		case LT_KERNEL:
715		return LT_KERNEL_EFI;
716		case LT_INITRD:
717		return LT_INITRD_EFI;
718		default:
719		return type;
720		}
721		}
722		return type;
723		}
724
725	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
726	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
727	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
728	if (kw->type == type)	if (kw->type == type)
729	return kw;	return kw;
730	}	}
#	Line 604  static char * getuuidbydev(char *device)	Line 754  static char * getuuidbydev(char *device)
754
755	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
756	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
757	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
758	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
759	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
760	return kw->type;	return kw->type;
761		} else {
762		if (!strcmp(keyword, kw->key))
763		return kw->type;
764		}
765	}	}
766	return LT_UNKNOWN;	return LT_UNKNOWN;
767	}	}
#	Line 646  static int isEntryStart(struct singleLin	Line 800  static int isEntryStart(struct singleLin
800	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
801	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
802	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it (leaks a byte) */
803	char * title;	char * title = NULL;
804	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
805	title++;	title = strdup(line->elements[0].item);
806	*(title + strlen(title) - 1) = '\0';	title++;
807		*(title + strlen(title) - 1) = '\0';
808		} else if (line->type == LT_MENUENTRY)
809		title = strdup(line->elements[1].item);
810		else
811		return NULL;
812	return title;	return title;
813	}	}
814
#	Line 692  static void lineInit(struct singleLine *	Line 851  static void lineInit(struct singleLine *
851	}	}
852
853	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
854	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
855
856	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 702  struct singleLine * lineDup(struct singl	Line 860  struct singleLine * lineDup(struct singl
860	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
861	newLine->numElements);	newLine->numElements);
862
863	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
864	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
865	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
866	}	}
#	Line 711  struct singleLine * lineDup(struct singl	Line 869  struct singleLine * lineDup(struct singl
869	}	}
870
871	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
872	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
873
874	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
875	free(line->elements[i].item);	free(line->elements[i].item);
876	free(line->elements[i].indent);	free(line->elements[i].indent);
877	}	}
#	Line 726  static void lineFree(struct singleLine *	Line 882  static void lineFree(struct singleLine *
882
883	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
884	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
885	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
886
887	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
888		/* Need to handle this, because we strip the quotes from
889		* menuentry when read it. */
890		if (line->type == LT_MENUENTRY && i == 1) {
891		if(!isquote(*line->elements[i].item))
892		fprintf(out, "\'%s\'", line->elements[i].item);
893		else
894		fprintf(out, "%s", line->elements[i].item);
895		fprintf(out, "%s", line->elements[i].indent);
896
897		continue;
898		}
899
900	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
901	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
902
#	Line 824  static int getNextLine(char ** bufPtr, s	Line 990  static int getNextLine(char ** bufPtr, s
990	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
991	char * fullLine;	char * fullLine;
992	int len;	int len;
	int i;
993
994	len = strlen(line->indent);	len = strlen(line->indent);
995	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
996	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
997	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
998
#	Line 836  static int getNextLine(char ** bufPtr, s	Line 1001  static int getNextLine(char ** bufPtr, s
1001	free(line->indent);	free(line->indent);
1002	line->indent = fullLine;	line->indent = fullLine;
1003
1004	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1005	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1006	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1007	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 855  static int getNextLine(char ** bufPtr, s	Line 1020  static int getNextLine(char ** bufPtr, s
1020	* elements up more	* elements up more
1021	*/	*/
1022	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1023	char indent[2] = "";	char indent[2] = "";
1024	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1025	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1026	char *p;	char *p;
	int j;
1027	int numNewElements;	int numNewElements;
1028
1029	numNewElements = 0;	numNewElements = 0;
#	Line 876  static int getNextLine(char ** bufPtr, s	Line 1039  static int getNextLine(char ** bufPtr, s
1039	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1040	}	}
1041
1042	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1043	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1044	}	}
1045	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 889  static int getNextLine(char ** bufPtr, s	Line 1052  static int getNextLine(char ** bufPtr, s
1052	break;	break;
1053	}	}
1054
1055	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1056	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1057	*p++ = '\0';	*p++ = '\0';
1058	i++;	i++;
1059	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1060	}	}
1061	}	}
1062	}	}
#	Line 905  static int getNextLine(char ** bufPtr, s	Line 1066  static int getNextLine(char ** bufPtr, s
1066	return 0;	return 0;
1067	}	}
1068
1069		static int isnumber(const char *s)
1070		{
1071		int i;
1072		for (i = 0; s[i] != '\0'; i++)
1073		if (s[i] < '0' || s[i] > '9')
1074		return 0;
1075		return i;
1076		}
1077
1078	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1079	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1080	int in;	int in;
#	Line 916  static struct grubConfig * readConfig(co	Line 1086  static struct grubConfig * readConfig(co
1086	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1087	char * end;	char * end;
1088	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1089	int i, len;	int len;
1090	char * buf;	char * buf;
1091
1092	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1093		printf("Could not find bootloader configuration\n");
1094		exit(1);
1095		} else if (!strcmp(inName, "-")) {
1096	in = 0;	in = 0;
1097	} else {	} else {
1098	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 979  static struct grubConfig * readConfig(co	Line 1152  static struct grubConfig * readConfig(co
1152	}	}
1153
1154	if (line->type == LT_SET_VARIABLE) {	if (line->type == LT_SET_VARIABLE) {
	int i;
1155	dbgPrintf("found 'set' command (%d elements): ", line->numElements);	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1156	dbgPrintf("%s", line->indent);	dbgPrintf("%s", line->indent);
1157	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1158	dbgPrintf("%s\"%s\"", line->elements[i].indent, line->elements[i].item);	dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1159	dbgPrintf("\n");	dbgPrintf("\n");
1160	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1161	if (kwType && line->numElements == 3 &&	if (kwType && line->numElements == 3 &&
1162	!strcmp(line->elements[1].item, kwType->key)) {	!strcmp(line->elements[1].item, kwType->key) &&
1163		!is_special_grub2_variable(line->elements[2].item)) {
1164	dbgPrintf("Line sets default config\n");	dbgPrintf("Line sets default config\n");
1165	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1166	defaultLine = line;	defaultLine = line;
#	Line 996  static struct grubConfig * readConfig(co	Line 1169  static struct grubConfig * readConfig(co
1169	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1170	defaultLine = line;	defaultLine = line;
1171
1172	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1173	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1174	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1175	* instead of LT_KERNEL now	* instead of LT_KERNEL now
#	Line 1010  static struct grubConfig * readConfig(co	Line 1183  static struct grubConfig * readConfig(co
1183	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1184	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1185	*/	*/
1186	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1187	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1188	break;	break;
1189	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1190	l->type = LT_HYPER;	l->type = LT_HYPER;
1191	break;	break;
1192	}	}
#	Line 1031  static struct grubConfig * readConfig(co	Line 1203  static struct grubConfig * readConfig(co
1203	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if (line->type == LT_TITLE && line->numElements > 1) {
1204	/* make the title a single argument (undoing our parsing) */	/* make the title a single argument (undoing our parsing) */
1205	len = 0;	len = 0;
1206	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1207	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1208	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1209	}	}
1210	buf = malloc(len + 1);	buf = malloc(len + 1);
1211	*buf = '\0';	*buf = '\0';
1212
1213	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1214	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1215	free(line->elements[i].item);	free(line->elements[i].item);
1216
#	Line 1052  static struct grubConfig * readConfig(co	Line 1224  static struct grubConfig * readConfig(co
1224	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1225	line->elements[1].item = buf;	line->elements[1].item = buf;
1226	line->numElements = 2;	line->numElements = 2;
1227		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1228		/* let --remove-kernel="TITLE=what" work */
1229		len = 0;
1230		char *extras;
1231		char *title;
1232
1233		for (int i = 1; i < line->numElements; i++) {
1234		len += strlen(line->elements[i].item);
1235		len += strlen(line->elements[i].indent);
1236		}
1237		buf = malloc(len + 1);
1238		*buf = '\0';
1239
1240		/* allocate mem for extra flags. */
1241		extras = malloc(len + 1);
1242		*extras = '\0';
1243
1244		/* get title. */
1245		for (int i = 0; i < line->numElements; i++) {
1246		if (!strcmp(line->elements[i].item, "menuentry"))
1247		continue;
1248		if (isquote(*line->elements[i].item))
1249		title = line->elements[i].item + 1;
1250		else
1251		title = line->elements[i].item;
1252
1253		len = strlen(title);
1254		if (isquote(title[len-1])) {
1255		strncat(buf, title,len-1);
1256		break;
1257		} else {
1258		strcat(buf, title);
1259		strcat(buf, line->elements[i].indent);
1260		}
1261		}
1262
1263		/* get extras */
1264		int count = 0;
1265		for (int i = 0; i < line->numElements; i++) {
1266		if (count >= 2) {
1267		strcat(extras, line->elements[i].item);
1268		strcat(extras, line->elements[i].indent);
1269		}
1270
1271		if (!strcmp(line->elements[i].item, "menuentry"))
1272		continue;
1273
1274		/* count ' or ", there should be two in menuentry line. */
1275		if (isquote(*line->elements[i].item))
1276		count++;
1277
1278		len = strlen(line->elements[i].item);
1279
1280		if (isquote(line->elements[i].item[len -1]))
1281		count++;
1282
1283		/* ok, we get the final ' or ", others are extras. */
1284		}
1285		line->elements[1].indent =
1286		line->elements[line->numElements - 2].indent;
1287		line->elements[1].item = buf;
1288		line->elements[2].indent =
1289		line->elements[line->numElements - 2].indent;
1290		line->elements[2].item = extras;
1291		line->numElements = 3;
1292	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1293	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1294	on write. This is one of the few (the only?) places that grubby	on write. This is one of the few (the only?) places that grubby
#	Line 1061  static struct grubConfig * readConfig(co	Line 1297  static struct grubConfig * readConfig(co
1297	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1298	int last, len;	int last, len;
1299
1300	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1301	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1302	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1303
1304	last = line->numElements - 1;	last = line->numElements - 1;
1305	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1306	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1307	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1308	}	}
1309	}	}
#	Line 1129  static struct grubConfig * readConfig(co	Line 1365  static struct grubConfig * readConfig(co
1365	if (defaultLine->numElements > 2 &&	if (defaultLine->numElements > 2 &&
1366	cfi->defaultSupportSaved &&	cfi->defaultSupportSaved &&
1367	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1368	cfg->defaultImage = DEFAULT_SAVED_GRUB2;	cfg->cfi->defaultIsSaved = 1;
1369		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1370		if (cfg->cfi->getEnv) {
1371		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1372		if (defTitle) {
1373		int index = 0;
1374		if (isnumber(defTitle)) {
1375		index = atoi(defTitle);
1376		entry = findEntryByIndex(cfg, index);
1377		} else {
1378		entry = findEntryByTitle(cfg, defTitle, &index);
1379		}
1380		if (entry)
1381		cfg->defaultImage = index;
1382		}
1383		}
1384	} else if (cfi->defaultIsVariable) {	} else if (cfi->defaultIsVariable) {
1385	char *value = defaultLine->elements[2].item;	char *value = defaultLine->elements[2].item;
1386	while (*value && (*value == '"' || *value == '\'' ||	while (*value && (*value == '"' || *value == '\'' ||
#	Line 1147  static struct grubConfig * readConfig(co	Line 1398  static struct grubConfig * readConfig(co
1398	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1399	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1400	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1401	i = 0;	int i = 0;
1402	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1403	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1404	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 1170  static struct grubConfig * readConfig(co	Line 1421  static struct grubConfig * readConfig(co
1421	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1422	}	}
1423	}	}
1424		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1425		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1426		if (defTitle) {
1427		int index = 0;
1428		if (isnumber(defTitle)) {
1429		index = atoi(defTitle);
1430		entry = findEntryByIndex(cfg, index);
1431		} else {
1432		entry = findEntryByTitle(cfg, defTitle, &index);
1433		}
1434		if (entry)
1435		cfg->defaultImage = index;
1436		}
1437	} else {	} else {
1438	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1439	}	}
#	Line 1187  static void writeDefault(FILE * out, cha	Line 1451  static void writeDefault(FILE * out, cha
1451
1452	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1453	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1454	else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)	else if (cfg->cfi->defaultIsSaved) {
1455	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1456	else if (cfg->defaultImage > -1) {	if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1457		char *title;
1458		entry = findEntryByIndex(cfg, cfg->defaultImage);
1459		line = getLineByType(LT_MENUENTRY, entry->lines);
1460		if (!line)
1461		line = getLineByType(LT_TITLE, entry->lines);
1462		if (line) {
1463		title = extractTitle(line);
1464		if (title)
1465		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1466		}
1467		}
1468		} else if (cfg->defaultImage > -1) {
1469	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1470	if (cfg->cfi->defaultIsVariable) {	if (cfg->cfi->defaultIsVariable) {
1471	fprintf(out, "%sset default=\"%d\"\n", indent,	fprintf(out, "%sset default=\"%d\"\n", indent,
#	Line 1249  static int writeConfig(struct grubConfig	Line 1525  static int writeConfig(struct grubConfig
1525
1526	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1527	directory to the dir of the symlink */	directory to the dir of the symlink */
1528	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1529		rc = chdir(dirname(dir));
1530	do {	do {
1531	buf = alloca(len + 1);	buf = alloca(len + 1);
1532	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1291  static int writeConfig(struct grubConfig	Line 1568  static int writeConfig(struct grubConfig
1568	while (line) {	while (line) {
1569	if (line->type == LT_SET_VARIABLE && defaultKw &&	if (line->type == LT_SET_VARIABLE && defaultKw &&
1570	line->numElements == 3 &&	line->numElements == 3 &&
1571	!strcmp(line->elements[1].item, defaultKw->key)) {	!strcmp(line->elements[1].item, defaultKw->key) &&
1572		!is_special_grub2_variable(line->elements[2].item)) {
1573	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1574	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1575	} else if (line->type == LT_DEFAULT) {	} else if (line->type == LT_DEFAULT) {
#	Line 1387  static char *findDiskForRoot()	Line 1665  static char *findDiskForRoot()
1665	buf[rc] = '\0';	buf[rc] = '\0';
1666	chptr = buf;	chptr = buf;
1667
1668		char *foundanswer = NULL;
1669
1670	while (chptr && chptr != buf+rc) {	while (chptr && chptr != buf+rc) {
1671	devname = chptr;	devname = chptr;
1672
#	Line 1414  static char *findDiskForRoot()	Line 1694  static char *findDiskForRoot()
1694	* for '/' obviously.	* for '/' obviously.
1695	*/	*/
1696	if (*(++chptr) == '/' && *(++chptr) == ' ') {	if (*(++chptr) == '/' && *(++chptr) == ' ') {
1697	/*	/* remember the last / entry in mtab */
1698	* Move back 2, which is the first space after the device name, set	foundanswer = devname;
	* it to \0 so strdup will just get the devicename.
	*/
	chptr -= 2;
	*chptr = '\0';
	return strdup(devname);
1699	}	}
1700
1701	/* Next line */	/* Next line */
#	Line 1429  static char *findDiskForRoot()	Line 1704  static char *findDiskForRoot()
1704	chptr++;	chptr++;
1705	}	}
1706
1707		/* Return the last / entry found */
1708		if (foundanswer) {
1709		chptr = strchr(foundanswer, ' ');
1710		*chptr = '\0';
1711		return strdup(foundanswer);
1712		}
1713
1714	return NULL;	return NULL;
1715	}	}
1716
1717	void printEntry(struct singleEntry * entry) {	void printEntry(struct singleEntry * entry, FILE *f) {
1718	int i;	int i;
1719	struct singleLine * line;	struct singleLine * line;
1720
1721	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
1722	fprintf(stderr, "DBG: %s", line->indent);	log_message(f, "DBG: %s", line->indent);
1723	for (i = 0; i < line->numElements; i++) {	for (i = 0; i < line->numElements; i++) {
1724	fprintf(stderr, "%s%s",	/* Need to handle this, because we strip the quotes from
1725		* menuentry when read it. */
1726		if (line->type == LT_MENUENTRY && i == 1) {
1727		if(!isquote(*line->elements[i].item))
1728		log_message(f, "\'%s\'", line->elements[i].item);
1729		else
1730		log_message(f, "%s", line->elements[i].item);
1731		log_message(f, "%s", line->elements[i].indent);
1732
1733		continue;
1734		}
1735
1736		log_message(f, "%s%s",
1737	line->elements[i].item, line->elements[i].indent);	line->elements[i].item, line->elements[i].indent);
1738	}	}
1739	fprintf(stderr, "\n");	log_message(f, "\n");
1740	}	}
1741	}	}
1742
1743	void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)	void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1744	{	{
1745	va_list argp;	static int once;
1746		va_list argp, argq;
1747
1748	if (!debug)	va_start(argp, fmt);
1749
1750		va_copy(argq, argp);
1751		if (!once) {
1752		log_time(NULL);
1753		log_message(NULL, "command line: %s\n", saved_command_line);
1754		}
1755		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1756		log_vmessage(NULL, fmt, argq);
1757
1758		printEntry(entry, NULL);
1759		va_end(argq);
1760
1761		if (!debug) {
1762		once = 1;
1763		va_end(argp);
1764		return;
1765		}
1766
1767		if (okay) {
1768		va_end(argp);
1769	return;	return;
1770		}
1771
1772	va_start(argp, fmt);	if (!once)
1773		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1774		once = 1;
1775	fprintf(stderr, "DBG: Image entry failed: ");	fprintf(stderr, "DBG: Image entry failed: ");
1776	vfprintf(stderr, fmt, argp);	vfprintf(stderr, fmt, argp);
1777	printEntry(entry);	printEntry(entry, stderr);
1778	va_end(argp);	va_end(argp);
1779	}	}
1780
#	Line 1483  int suitableImage(struct singleEntry * e	Line 1801  int suitableImage(struct singleEntry * e
1801	char * rootdev;	char * rootdev;
1802
1803	if (skipRemoved && entry->skip) {	if (skipRemoved && entry->skip) {
1804	notSuitablePrintf(entry, "marked to skip\n");	notSuitablePrintf(entry, 0, "marked to skip\n");
1805	return 0;	return 0;
1806	}	}
1807
1808	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
1809	if (!line) {	if (!line) {
1810	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1811	return 0;	return 0;
1812	}	}
1813	if (line->numElements < 2) {	if (line->numElements < 2) {
1814	notSuitablePrintf(entry, "line has only %d elements\n",	notSuitablePrintf(entry, 0, "line has only %d elements\n",
1815	line->numElements);	line->numElements);
1816	return 0;	return 0;
1817	}	}
1818
1819	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1820		notSuitablePrintf(entry, 1, "\n");
1821		return 1;
1822		}
1823
1824	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1825	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
#	Line 1509  int suitableImage(struct singleEntry * e	Line 1830  int suitableImage(struct singleEntry * e
1830	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1831	line->elements[1].item + rootspec_offset);	line->elements[1].item + rootspec_offset);
1832	if (access(fullName, R_OK)) {	if (access(fullName, R_OK)) {
1833	notSuitablePrintf(entry, "access to %s failed\n", fullName);	notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1834	return 0;	return 0;
1835	}	}
1836	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
#	Line 1530  int suitableImage(struct singleEntry * e	Line 1851  int suitableImage(struct singleEntry * e
1851
1852	/* failed to find one */	/* failed to find one */
1853	if (!line) {	if (!line) {
1854	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1855	return 0;	return 0;
1856	}	}
1857
#	Line 1539  int suitableImage(struct singleEntry * e	Line 1860  int suitableImage(struct singleEntry * e
1860	if (i < line->numElements)	if (i < line->numElements)
1861	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1862	else {	else {
1863	notSuitablePrintf(entry, "no root= entry found\n");	notSuitablePrintf(entry, 0, "no root= entry found\n");
1864	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1865	return 0;	return 0;
1866	}	}
#	Line 1548  int suitableImage(struct singleEntry * e	Line 1869  int suitableImage(struct singleEntry * e
1869
1870	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1871	if (!getpathbyspec(dev)) {	if (!getpathbyspec(dev)) {
1872	notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);	notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1873	return 0;	return 0;
1874	} else	} else
1875	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1876
1877	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1878	if (!rootdev) {	if (!rootdev) {
1879	notSuitablePrintf(entry, "can't find root device\n");	notSuitablePrintf(entry, 0, "can't find root device\n");
1880	return 0;	return 0;
1881	}	}
1882
1883	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1884	notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1885	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1886	free(rootdev);	free(rootdev);
1887	return 0;	return 0;
1888	}	}
1889
1890	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1891	notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1892	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1893	free(rootdev);	free(rootdev);
1894	return 0;	return 0;
1895	}	}
1896
1897	free(rootdev);	free(rootdev);
1898		notSuitablePrintf(entry, 1, "\n");
1899
1900	return 1;	return 1;
1901	}	}
#	Line 1617  struct singleEntry * findEntryByPath(str	Line 1939  struct singleEntry * findEntryByPath(str
1939	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1940	if (!entry) return NULL;	if (!entry) return NULL;
1941
1942	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
1943	if (!line) return NULL;	if (!line) return NULL;
1944
1945	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1655  struct singleEntry * findEntryByPath(str	Line 1977  struct singleEntry * findEntryByPath(str
1977
1978	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
1979	prefix = "";	prefix = "";
1980	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
1981	kernel += 6;	kernel += 6;
1982	}	}
1983
#	Line 1666  struct singleEntry * findEntryByPath(str	Line 1988  struct singleEntry * findEntryByPath(str
1988
1989	/* check all the lines matching checkType */	/* check all the lines matching checkType */
1990	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
1991	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
1992	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
1993	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;
1994	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
1995		ct = checkType | LT_KERNEL_EFI;
1996		line = getLineByType(ct, line);
1997		if (!line)
1998		break;  /* not found in this entry */
1999
2000	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2001		line->numElements >= 2) {
2002	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2003	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2004	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2005	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2006	break;	break;
2007	}	}
2008		if(line->type == LT_MENUENTRY &&
2009		!strcmp(line->elements[1].item, kernel))
2010		break;
2011	}	}
2012
2013	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2014	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2015	* unfortunate)	* unfortunate)
2016	*/	*/
2017	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))
2018	break; /* found 'im! */	break; /* found 'im! */
2019	}	}
2020
#	Line 1694  struct singleEntry * findEntryByPath(str	Line 2024  struct singleEntry * findEntryByPath(str
2024	return entry;	return entry;
2025	}	}
2026
2027		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2028		int * index) {
2029		struct singleEntry * entry;
2030		struct singleLine * line;
2031		int i;
2032		char * newtitle;
2033
2034		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2035		if (index && i < *index)
2036		continue;
2037		line = getLineByType(LT_TITLE, entry->lines);
2038		if (!line)
2039		line = getLineByType(LT_MENUENTRY, entry->lines);
2040		if (!line)
2041		continue;
2042		newtitle = grub2ExtractTitle(line);
2043		if (!newtitle)
2044		continue;
2045		if (!strcmp(title, newtitle))
2046		break;
2047		}
2048
2049		if (!entry)
2050		return NULL;
2051
2052		if (index)
2053		*index = i;
2054		return entry;
2055		}
2056
2057	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2058	struct singleEntry * entry;	struct singleEntry * entry;
2059
#	Line 1716  struct singleEntry * findTemplate(struct	Line 2076  struct singleEntry * findTemplate(struct
2076	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2077	int index;	int index;
2078
2079	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2080		if (cfg->cfi->getEnv) {
2081		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2082		if (defTitle) {
2083		int index = 0;
2084		if (isnumber(defTitle)) {
2085		index = atoi(defTitle);
2086		entry = findEntryByIndex(cfg, index);
2087		} else {
2088		entry = findEntryByTitle(cfg, defTitle, &index);
2089		}
2090		if (entry)
2091		cfg->defaultImage = index;
2092		}
2093		}
2094		} else if (cfg->defaultImage > -1) {
2095	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2096	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2097	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1769  void markRemovedImage(struct grubConfig	Line 2144  void markRemovedImage(struct grubConfig
2144	const char * prefix) {	const char * prefix) {
2145	struct singleEntry * entry;	struct singleEntry * entry;
2146
2147	if (!image) return;	if (!image)
2148		return;
2149
2150		/* check and see if we're removing the default image */
2151		if (isdigit(*image)) {
2152		entry = findEntryByPath(cfg, image, prefix, NULL);
2153		if(entry)
2154		entry->skip = 1;
2155		return;
2156		}
2157
2158	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2159	entry->skip = 1;	entry->skip = 1;
#	Line 1777  void markRemovedImage(struct grubConfig	Line 2161  void markRemovedImage(struct grubConfig
2161
2162	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2163	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2164	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2165	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2166	int i, j;	int i, j;
2167
2168	if (newIsDefault) {	if (newIsDefault) {
2169	config->defaultImage = 0;	config->defaultImage = 0;
2170	return;	return;
2171		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2172		if (findEntryByIndex(config, index))
2173		config->defaultImage = index;
2174		else
2175		config->defaultImage = -1;
2176		return;
2177	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2178	i = 0;	i = 0;
2179	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1858  void displayEntry(struct singleEntry * e	Line 2248  void displayEntry(struct singleEntry * e
2248
2249	printf("index=%d\n", index);	printf("index=%d\n", index);
2250
2251	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
2252	if (!line) {	if (!line) {
2253	printf("non linux entry\n");	printf("non linux entry\n");
2254	return;	return;
2255	}	}
2256
2257	printf("kernel=%s%s\n", prefix, line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2258		printf("kernel=%s\n", line->elements[1].item);
2259		else
2260		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2261
2262	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2263	printf("args=\"");	printf("args=\"");
#	Line 1920  void displayEntry(struct singleEntry * e	Line 2313  void displayEntry(struct singleEntry * e
2313	printf("root=%s\n", s);	printf("root=%s\n", s);
2314	}	}
2315
2316	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
2317
2318	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2319	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2320		printf("initrd=");
2321		else
2322		printf("initrd=%s", prefix);
2323
2324	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2325	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2326	printf("\n");	printf("\n");
#	Line 1941  void displayEntry(struct singleEntry * e	Line 2338  void displayEntry(struct singleEntry * e
2338	}	}
2339	}	}
2340
2341		int isSuseSystem(void) {
2342		const char * path;
2343		const static char default_path[] = "/etc/SuSE-release";
2344
2345		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2346		path = default_path;
2347
2348		if (!access(path, R_OK))
2349		return 1;
2350		return 0;
2351		}
2352
2353		int isSuseGrubConf(const char * path) {
2354		FILE * grubConf;
2355		char * line = NULL;
2356		size_t len = 0, res = 0;
2357
2358		grubConf = fopen(path, "r");
2359		if (!grubConf) {
2360		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2361		return 0;
2362		}
2363
2364		while ((res = getline(&line, &len, grubConf)) != -1) {
2365		if (!strncmp(line, "setup", 5)) {
2366		fclose(grubConf);
2367		free(line);
2368		return 1;
2369		}
2370		}
2371
2372		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2373		path);
2374
2375		fclose(grubConf);
2376		free(line);
2377		return 0;
2378		}
2379
2380		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2381		FILE * grubConf;
2382		char * line = NULL;
2383		size_t res = 0, len = 0;
2384
2385		if (!path) return 1;
2386		if (!lbaPtr) return 1;
2387
2388		grubConf = fopen(path, "r");
2389		if (!grubConf) return 1;
2390
2391		while ((res = getline(&line, &len, grubConf)) != -1) {
2392		if (line[res - 1] == '\n')
2393		line[res - 1] = '\0';
2394		else if (len > res)
2395		line[res] = '\0';
2396		else {
2397		line = realloc(line, res + 1);
2398		line[res] = '\0';
2399		}
2400
2401		if (!strncmp(line, "setup", 5)) {
2402		if (strstr(line, "--force-lba")) {
2403		*lbaPtr = 1;
2404		} else {
2405		*lbaPtr = 0;
2406		}
2407		dbgPrintf("lba: %i\n", *lbaPtr);
2408		break;
2409		}
2410		}
2411
2412		free(line);
2413		fclose(grubConf);
2414		return 0;
2415		}
2416
2417		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2418		FILE * grubConf;
2419		char * line = NULL;
2420		size_t res = 0, len = 0;
2421		char * lastParamPtr = NULL;
2422		char * secLastParamPtr = NULL;
2423		char installDeviceNumber = '\0';
2424		char * bounds = NULL;
2425
2426		if (!path) return 1;
2427		if (!devicePtr) return 1;
2428
2429		grubConf = fopen(path, "r");
2430		if (!grubConf) return 1;
2431
2432		while ((res = getline(&line, &len, grubConf)) != -1) {
2433		if (strncmp(line, "setup", 5))
2434		continue;
2435
2436		if (line[res - 1] == '\n')
2437		line[res - 1] = '\0';
2438		else if (len > res)
2439		line[res] = '\0';
2440		else {
2441		line = realloc(line, res + 1);
2442		line[res] = '\0';
2443		}
2444
2445		lastParamPtr = bounds = line + res;
2446
2447		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2448		while (!isspace(*lastParamPtr))
2449		lastParamPtr--;
2450		lastParamPtr++;
2451
2452		secLastParamPtr = lastParamPtr - 2;
2453		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2454
2455		if (lastParamPtr + 3 > bounds) {
2456		dbgPrintf("lastParamPtr going over boundary");
2457		fclose(grubConf);
2458		free(line);
2459		return 1;
2460		}
2461		if (!strncmp(lastParamPtr, "(hd", 3))
2462		lastParamPtr += 3;
2463		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2464
2465		/*
2466		* Second last parameter will decide wether last parameter is
2467		* an IMAGE_DEVICE or INSTALL_DEVICE
2468		*/
2469		while (!isspace(*secLastParamPtr))
2470		secLastParamPtr--;
2471		secLastParamPtr++;
2472
2473		if (secLastParamPtr + 3 > bounds) {
2474		dbgPrintf("secLastParamPtr going over boundary");
2475		fclose(grubConf);
2476		free(line);
2477		return 1;
2478		}
2479		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2480		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2481		secLastParamPtr += 3;
2482		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2483		installDeviceNumber = *secLastParamPtr;
2484		} else {
2485		installDeviceNumber = *lastParamPtr;
2486		}
2487
2488		*devicePtr = malloc(6);
2489		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2490		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2491		fclose(grubConf);
2492		free(line);
2493		return 0;
2494		}
2495
2496		free(line);
2497		fclose(grubConf);
2498		return 1;
2499		}
2500
2501		int grubGetBootFromDeviceMap(const char * device,
2502		char ** bootPtr) {
2503		FILE * deviceMap;
2504		char * line = NULL;
2505		size_t res = 0, len = 0;
2506		char * devicePtr;
2507		char * bounds = NULL;
2508		const char * path;
2509		const static char default_path[] = "/boot/grub/device.map";
2510
2511		if (!device) return 1;
2512		if (!bootPtr) return 1;
2513
2514		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2515		path = default_path;
2516
2517		dbgPrintf("opening grub device.map file from: %s\n", path);
2518		deviceMap = fopen(path, "r");
2519		if (!deviceMap)
2520		return 1;
2521
2522		while ((res = getline(&line, &len, deviceMap)) != -1) {
2523		if (!strncmp(line, "#", 1))
2524		continue;
2525
2526		if (line[res - 1] == '\n')
2527		line[res - 1] = '\0';
2528		else if (len > res)
2529		line[res] = '\0';
2530		else {
2531		line = realloc(line, res + 1);
2532		line[res] = '\0';
2533		}
2534
2535		devicePtr = line;
2536		bounds = line + res;
2537
2538		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2539		devicePtr++;
2540		dbgPrintf("device: %s\n", devicePtr);
2541
2542		if (!strncmp(devicePtr, device, strlen(device))) {
2543		devicePtr += strlen(device);
2544		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2545		devicePtr++;
2546
2547		*bootPtr = strdup(devicePtr);
2548		break;
2549		}
2550		}
2551
2552		free(line);
2553		fclose(deviceMap);
2554		return 0;
2555		}
2556
2557		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2558		char * grubDevice;
2559
2560		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2561		dbgPrintf("error looking for grub installation device\n");
2562		else
2563		dbgPrintf("grubby installation device: %s\n", grubDevice);
2564
2565		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2566		dbgPrintf("error looking for grub boot device\n");
2567		else
2568		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2569
2570		free(grubDevice);
2571		return 0;
2572		}
2573
2574		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2575		/*
2576		* This SuSE grub configuration file at this location is not your average
2577		* grub configuration file, but instead the grub commands used to setup
2578		* grub on that system.
2579		*/
2580		const char * path;
2581		const static char default_path[] = "/etc/grub.conf";
2582
2583		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2584		path = default_path;
2585
2586		if (!isSuseGrubConf(path)) return 1;
2587
2588		if (lbaPtr) {
2589		*lbaPtr = 0;
2590		if (suseGrubConfGetLba(path, lbaPtr))
2591		return 1;
2592		}
2593
2594		if (bootPtr) {
2595		*bootPtr = NULL;
2596		suseGrubConfGetBoot(path, bootPtr);
2597		}
2598
2599		return 0;
2600		}
2601
2602	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
2603	FILE * in;	FILE * in;
2604	char buf[1024];	char buf[1024];
#	Line 1989  int parseSysconfigGrub(int * lbaPtr, cha	Line 2647  int parseSysconfigGrub(int * lbaPtr, cha
2647	}	}
2648
2649	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2650	char * boot;	char * boot = NULL;
2651	int lba;	int lba;
2652
2653	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2654	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2655	if (boot) printf("boot=%s\n", boot);	free(boot);
2656		return;
2657		}
2658		} else {
2659		if (parseSysconfigGrub(&lba, &boot)) {
2660		free(boot);
2661		return;
2662		}
2663		}
2664
2665		if (lba) printf("lba\n");
2666		if (boot) {
2667		printf("boot=%s\n", boot);
2668		free(boot);
2669	}	}
2670	}	}
2671
#	Line 2043  struct singleLine * addLineTmpl(struct s	Line 2714  struct singleLine * addLineTmpl(struct s
2714	{	{
2715	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2716
2717		if (isEfi && cfi == &grub2ConfigType) {
2718		enum lineType_e old = newLine->type;
2719		newLine->type = preferredLineType(newLine->type, cfi);
2720		if (old != newLine->type)
2721		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2722		}
2723
2724	if (val) {	if (val) {
2725	/* override the inherited value with our own.	/* override the inherited value with our own.
2726	* This is a little weak because it only applies to elements[1]	* This is a little weak because it only applies to elements[1]
#	Line 2052  struct singleLine * addLineTmpl(struct s	Line 2730  struct singleLine * addLineTmpl(struct s
2730	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2731
2732	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2733	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI)) {
2734	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2735	if (rootspec != NULL) {	if (rootspec != NULL) {
2736	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 2089  struct singleLine *  addLine(struct sing	Line 2767  struct singleLine *  addLine(struct sing
2767	/* NB: This function shouldn't allocate items on the heap, rather on the	/* NB: This function shouldn't allocate items on the heap, rather on the
2768	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2769	*/	*/
2770	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2771	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2772	tmpl.type = type;	tmpl.type = type;
#	Line 2423  int updateActualImage(struct grubConfig	Line 3100  int updateActualImage(struct grubConfig
3100	firstElement = 2;	firstElement = 2;
3101
3102	} else {	} else {
3103	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);
3104	if (!line) {	if (!line) {
3105	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3106	continue;	continue;
#	Line 2588  int updateInitrd(struct grubConfig * cfg	Line 3265  int updateInitrd(struct grubConfig * cfg
3265	if (!image) return 0;	if (!image) return 0;
3266
3267	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3268	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);
3269	if (!kernelLine) continue;	if (!kernelLine) continue;
3270
3271	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
3272	if (line)	if (line)
3273	removeLine(entry, line);	removeLine(entry, line);
3274	if (prefix) {	if (prefix) {
#	Line 2602  int updateInitrd(struct grubConfig * cfg	Line 3279  int updateInitrd(struct grubConfig * cfg
3279	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3280	if (endLine)	if (endLine)
3281	removeLine(entry, endLine);	removeLine(entry, endLine);
3282	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),
3283		kernelLine->indent, initrd);
3284	if (!line)	if (!line)
3285	return 1;	return 1;
3286	if (endLine) {	if (endLine) {
#	Line 2808  int checkForGrub(struct grubConfig * con	Line 3486  int checkForGrub(struct grubConfig * con
3486	int fd;	int fd;
3487	unsigned char bootSect[512];	unsigned char bootSect[512];
3488	char * boot;	char * boot;
3489		int onSuse = isSuseSystem();
3490
3491	if (parseSysconfigGrub(NULL, &boot))
3492	return 0;	if (onSuse) {
3493		if (parseSuseGrubConf(NULL, &boot))
3494		return 0;
3495		} else {
3496		if (parseSysconfigGrub(NULL, &boot))
3497		return 0;
3498		}
3499
3500	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3501	if (!boot)	if (!boot)
#	Line 2829  int checkForGrub(struct grubConfig * con	Line 3514  int checkForGrub(struct grubConfig * con
3514	}	}
3515	close(fd);	close(fd);
3516
3517		/* The more elaborate checks do not work on SuSE. The checks done
3518		* seem to be reasonble (at least for now), so just return success
3519		*/
3520		if (onSuse)
3521		return 2;
3522
3523	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3524	}	}
3525
#	Line 2862  int checkForExtLinux(struct grubConfig *	Line 3553  int checkForExtLinux(struct grubConfig *
3553	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3554	}	}
3555
3556		int checkForYaboot(struct grubConfig * config) {
3557		/*
3558		* This is a simplistic check that we consider good enough for own puporses
3559		*
3560		* If we were to properly check if yaboot is *installed* we'd need to:
3561		* 1) get the system boot device (LT_BOOT)
3562		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3563		*    the content on the boot device
3564		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3565		* 4) check again if binary and boot device contents match
3566		*/
3567		if (!access("/etc/yaboot.conf", R_OK))
3568		return 2;
3569
3570		return 1;
3571		}
3572
3573		int checkForElilo(struct grubConfig * config) {
3574		if (!access("/etc/elilo.conf", R_OK))
3575		return 2;
3576
3577		return 1;
3578		}
3579
3580	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3581	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3582
#	Line 2876  static char * getRootSpecifier(char * st	Line 3591  static char * getRootSpecifier(char * st
3591	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3592	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3593	const char * newKernelInitrd,	const char * newKernelInitrd,
3594	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3595	{	{
3596	char *initrdVal, *end;	char *initrdVal, *end;
3597	int i;	int i;
#	Line 2921  static char * getInitrdVal(struct grubCo	Line 3636  static char * getInitrdVal(struct grubCo
3636
3637	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3638	const char * prefix,	const char * prefix,
3639	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3640	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3641	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3642	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs) {
3643	struct singleEntry * new;	struct singleEntry * new;
3644	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3645	int needs;	int needs;
#	Line 2978  int addNewKernel(struct grubConfig * con	Line 3693  int addNewKernel(struct grubConfig * con
3693	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3694	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3695
3696	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3697	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3698	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3699	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 3056  int addNewKernel(struct grubConfig * con	Line 3770  int addNewKernel(struct grubConfig * con
3770	/* template is multi but new is not,	/* template is multi but new is not,
3771	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3772	*/	*/
3773	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3774	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3775	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3776	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3777		config->cfi)->key);
3778	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3779	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3780		config->cfi);
3781	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3782	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3783	char *initrdVal;	char *initrdVal;
3784	/* template is multi but new is not,	/* template is multi but new is not,
3785	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3786	*/	*/
3787	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3788	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3789	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3790	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3791		config->cfi)->key);
3792	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3793	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3794	free(initrdVal);	free(initrdVal);
3795	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3796	}	}
3797
3798	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3799	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3800	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3801	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 3133  int addNewKernel(struct grubConfig * con	Line 3849  int addNewKernel(struct grubConfig * con
3849	static const char *prefix = "'Loading ";	static const char *prefix = "'Loading ";
3850	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
3851	strstr(tmplLine->elements[1].item, prefix) &&	strstr(tmplLine->elements[1].item, prefix) &&
3852	masterLine->next && masterLine->next->type == LT_KERNEL) {	masterLine->next &&
3853		iskernel(masterLine->next->type)) {
3854	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
3855	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
3856
#	Line 3160  int addNewKernel(struct grubConfig * con	Line 3877  int addNewKernel(struct grubConfig * con
3877	*/	*/
3878	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
3879	case LT_KERNEL:	case LT_KERNEL:
3880		case LT_KERNEL_EFI:
3881	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
3882	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
3883	} else {	} else {
3884	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
3885		preferredLineType(LT_KERNEL, config->cfi),
3886	config->primaryIndent,	config->primaryIndent,
3887	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
3888	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3239  int addNewKernel(struct grubConfig * con	Line 3958  int addNewKernel(struct grubConfig * con
3958	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
3959	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
3960	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
3961	config->cfi)) ?	config->cfi))
3962	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
3963		: preferredLineType(LT_KERNEL, config->cfi),
3964	config->secondaryIndent,	config->secondaryIndent,
3965	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
3966	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3256  int addNewKernel(struct grubConfig * con	Line 3976  int addNewKernel(struct grubConfig * con
3976	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
3977	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
3978	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
3979	config->cfi)) ?	config->cfi))
3980	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
3981		: preferredLineType(LT_INITRD, config->cfi),
3982	config->secondaryIndent,	config->secondaryIndent,
3983	initrdVal);	initrdVal);
3984	free(initrdVal);	free(initrdVal);
#	Line 3289  static void traceback(int signum)	Line 4010  static void traceback(int signum)
4010	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4011	size = backtrace(array, 40);	size = backtrace(array, 40);
4012
4013	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4014	(unsigned long)size);	(unsigned long)size);
4015	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4016	exit(1);	exit(1);
#	Line 3324  int main(int argc, const char ** argv) {	Line 4045  int main(int argc, const char ** argv) {
4045	char * removeArgs = NULL;	char * removeArgs = NULL;
4046	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4047	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4048		char * envPath = NULL;
4049	const char * chptr = NULL;	const char * chptr = NULL;
4050	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4051	struct grubConfig * config;	struct grubConfig * config;
#	Line 3332  int main(int argc, const char ** argv) {	Line 4054  int main(int argc, const char ** argv) {
4054	int displayDefault = 0;	int displayDefault = 0;
4055	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4056	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4057		int defaultIndex = -1;
4058	struct poptOption options[] = {	struct poptOption options[] = {
4059	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4060	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3349  int main(int argc, const char ** argv) {	Line 4072  int main(int argc, const char ** argv) {
4072	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4073	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4074	_("bootfs") },	_("bootfs") },
4075	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4076	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4077	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4078	#endif	#endif
4079	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4080	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3372  int main(int argc, const char ** argv) {	Line 4095  int main(int argc, const char ** argv) {
4095	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4096	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4097	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4098		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4099		_("force grub2 stanzas to use efi") },
4100		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4101		_("path for environment data"),
4102		_("path") },
4103	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4104	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4105	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3384  int main(int argc, const char ** argv) {	Line 4112  int main(int argc, const char ** argv) {
4112	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4113	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4114	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4115	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4116	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4117	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4118	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3404  int main(int argc, const char ** argv) {	Line 4132  int main(int argc, const char ** argv) {
4132	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4133	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4134	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4135		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4136		_("make the given entry index the default entry"),
4137		_("entry-index") },
4138	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4139	_("configure silo bootloader") },	_("configure silo bootloader") },
4140	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3425  int main(int argc, const char ** argv) {	Line 4156  int main(int argc, const char ** argv) {
4156
4157	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4158
4159		int i = 0;
4160		for (int j = 1; j < argc; j++)
4161		i += strlen(argv[j]) + 1;
4162		saved_command_line = malloc(i);
4163		if (!saved_command_line) {
4164		fprintf(stderr, "grubby: %m\n");
4165		exit(1);
4166		}
4167		saved_command_line[0] = '\0';
4168		for (int j = 1; j < argc; j++) {
4169		strcat(saved_command_line, argv[j]);
4170		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4171		}
4172
4173	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4174	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4175
#	Line 3468  int main(int argc, const char ** argv) {	Line 4213  int main(int argc, const char ** argv) {
4213	return 1;	return 1;
4214	} else if (configureGrub2) {	} else if (configureGrub2) {
4215	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4216		if (envPath)
4217		cfi->envFile = envPath;
4218	} else if (configureLilo) {	} else if (configureLilo) {
4219	cfi = &liloConfigType;	cfi = &liloConfigType;
4220	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3486  int main(int argc, const char ** argv) {	Line 4233  int main(int argc, const char ** argv) {
4233	}	}
4234
4235	if (!cfi) {	if (!cfi) {
4236		if (grub2FindConfig(&grub2ConfigType))
4237		cfi = &grub2ConfigType;
4238		else
4239	#ifdef __ia64__	#ifdef __ia64__
4240	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4241	#elif __powerpc__	#elif __powerpc__
4242	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4243	#elif __sparc__	#elif __sparc__
4244	cfi = &siloConfigType;	cfi = &siloConfigType;
4245	#elif __s390__	#elif __s390__
4246	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4247	#elif __s390x__	#elif __s390x__
4248	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4249	#else	#else
	if (grub2FindConfig(&grub2ConfigType))
	cfi = &grub2ConfigType;
	else
4250	cfi = &grubConfigType;	cfi = &grubConfigType;
4251	#endif	#endif
4252	}	}
#	Line 3512  int main(int argc, const char ** argv) {	Line 4259  int main(int argc, const char ** argv) {
4259	}	}
4260
4261	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||
4262	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4263	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4264		(defaultIndex >= 0))) {
4265	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4266	"specified option"));	"specified option"));
4267	return 1;	return 1;
#	Line 3555  int main(int argc, const char ** argv) {	Line 4303  int main(int argc, const char ** argv) {
4303	makeDefault = 1;	makeDefault = 1;
4304	defaultKernel = NULL;	defaultKernel = NULL;
4305	}	}
4306		else if (defaultKernel && (defaultIndex >= 0)) {
4307		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4308		"may not be used together\n"));
4309		return 1;
4310		}
4311
4312	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4313	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3563  int main(int argc, const char ** argv) {	Line 4316  int main(int argc, const char ** argv) {
4316	}	}
4317
4318	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4319	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4320	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4321		&& (defaultIndex == -1)) {
4322	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4323	return 1;	return 1;
4324	}	}
#	Line 3591  int main(int argc, const char ** argv) {	Line 4345  int main(int argc, const char ** argv) {
4345	}	}
4346
4347	if (bootloaderProbe) {	if (bootloaderProbe) {
4348	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4349	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4350
4351	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4352	if (grub2config) {	if (grub2config) {
#	Line 3620  int main(int argc, const char ** argv) {	Line 4374  int main(int argc, const char ** argv) {
4374	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4375	}	}
4376
4377		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4378		econfig = readConfig(eliloConfigType.defaultConfig,
4379		&eliloConfigType);
4380		if (!econfig)
4381		erc = 1;
4382		else
4383		erc = checkForElilo(econfig);
4384		}
4385
4386	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4387	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4388	if (!lconfig)	if (!lconfig)
4389	erc = 1;	extrc = 1;
4390	else	else
4391	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4392	}	}
4393
4394	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4395		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4396		yconfig = readConfig(yabootConfigType.defaultConfig,
4397		&yabootConfigType);
4398		if (!yconfig)
4399		yrc = 1;
4400		else
4401		yrc = checkForYaboot(yconfig);
4402		}
4403
4404		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4405		erc == 1)
4406		return 1;
4407
4408	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4409	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4410	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4411	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4412		if (yrc == 2) printf("yaboot\n");
4413		if (erc == 2) printf("elilo\n");
4414
4415	return 0;	return 0;
4416	}	}
4417
4418		if (grubConfig == NULL) {
4419		printf("Could not find bootloader configuration file.\n");
4420		exit(1);
4421		}
4422
4423	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4424	if (!config) return 1;	if (!config) return 1;
4425
#	Line 3647  int main(int argc, const char ** argv) {	Line 4429  int main(int argc, const char ** argv) {
4429	char * rootspec;	char * rootspec;
4430
4431	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4432		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4433		cfi->defaultIsSaved)
4434		config->defaultImage = 0;
4435	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4436	if (!entry) return 0;	if (!entry) return 0;
4437	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4438
4439	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
4440	if (!line) return 0;	if (!line) return 0;
4441
4442	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3665  int main(int argc, const char ** argv) {	Line 4450  int main(int argc, const char ** argv) {
4450	struct singleEntry * entry;	struct singleEntry * entry;
4451
4452	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4453		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4454		cfi->defaultIsSaved)
4455		config->defaultImage = 0;
4456	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4457	if (!entry) return 0;	if (!entry) return 0;
4458
#	Line 3687  int main(int argc, const char ** argv) {	Line 4475  int main(int argc, const char ** argv) {
4475
4476	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4477	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4478		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4479		cfi->defaultIsSaved)
4480		config->defaultImage = 0;
4481	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4482		return 0;
4483
4484	} else if (kernelInfo)	} else if (kernelInfo)
4485	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 3700  int main(int argc, const char ** argv) {	Line 4492  int main(int argc, const char ** argv) {
4492	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4493	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4494	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4495	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4496	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4497	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4498	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
#	Line 3710  int main(int argc, const char ** argv) {	Line 4502  int main(int argc, const char ** argv) {
4502	}	}
4503	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4504	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4505	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4506	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs)) return 1;
4507
4508

---

Colored Diff Long Colored Diff Full Colored Diff Unidiff Context Diff Side by Side

Legend: Removed from v.1800   changed lines   Added in v.2258