Diff of /trunk/grubby/grubby.c

Parent Directory | Revision Log | Patch

	revision 1854 by niro, Mon Jul 2 13:12:32 2012 UTC	revision 2989 by niro, Thu Jun 30 10:32:12 2016 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		#if defined(__aarch64__)
64		#define isEfiOnly 1
65		#else
66		#define isEfiOnly 0
67		#endif
68
69		char *saved_command_line = NULL;
70
71	/* comments get lumped in with indention */	/* comments get lumped in with indention */
72	struct lineElement {	struct lineElement {
73	char * item;	char * item;
#	Line 82  enum lineType_e {	Line 94  enum lineType_e {
94	LT_MENUENTRY    = 1 << 17,	LT_MENUENTRY    = 1 << 17,
95	LT_ENTRY_END    = 1 << 18,	LT_ENTRY_END    = 1 << 18,
96	LT_SET_VARIABLE = 1 << 19,	LT_SET_VARIABLE = 1 << 19,
97	LT_UNKNOWN      = 1 << 20,	LT_KERNEL_EFI   = 1 << 20,
98		LT_INITRD_EFI   = 1 << 21,
99		LT_KERNEL_16    = 1 << 22,
100		LT_INITRD_16    = 1 << 23,
101		LT_DEVTREE      = 1 << 24,
102		LT_UNKNOWN      = 1 << 25,
103	};	};
104
105	struct singleLine {	struct singleLine {
#	Line 111  struct singleEntry {	Line 128  struct singleEntry {
128	#define NEED_ARGS    (1 << 3)	#define NEED_ARGS    (1 << 3)
129	#define NEED_MB      (1 << 4)	#define NEED_MB      (1 << 4)
130	#define NEED_END     (1 << 5)	#define NEED_END     (1 << 5)
131		#define NEED_DEVTREE (1 << 6)
132
133	#define MAIN_DEFAULT    (1 << 0)	#define MAIN_DEFAULT    (1 << 0)
134	#define DEFAULT_SAVED       -2	#define DEFAULT_SAVED       -2
#	Line 128  struct configFileInfo;	Line 146  struct configFileInfo;
146	typedef const char *(*findConfigFunc)(struct configFileInfo *);	typedef const char *(*findConfigFunc)(struct configFileInfo *);
147	typedef const int (*writeLineFunc)(struct configFileInfo *,	typedef const int (*writeLineFunc)(struct configFileInfo *,
148	struct singleLine *line);	struct singleLine *line);
149		typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
150		typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
151
152	struct configFileInfo {	struct configFileInfo {
153	char * defaultConfig;	char * defaultConfig;
154	findConfigFunc findConfig;	findConfigFunc findConfig;
155	writeLineFunc writeLine;	writeLineFunc writeLine;
156		getEnvFunc getEnv;
157		setEnvFunc setEnv;
158	struct keywordTypes * keywords;	struct keywordTypes * keywords;
159		int caseInsensitive;
160	int defaultIsIndex;	int defaultIsIndex;
161	int defaultIsVariable;	int defaultIsVariable;
162	int defaultSupportSaved;	int defaultSupportSaved;
163		int defaultIsSaved;
164		int defaultIsUnquoted;
165	enum lineType_e entryStart;	enum lineType_e entryStart;
166	enum lineType_e entryEnd;	enum lineType_e entryEnd;
167	int needsBootPrefix;	int needsBootPrefix;
#	Line 148  struct configFileInfo {	Line 173  struct configFileInfo {
173	int mbInitRdIsModule;	int mbInitRdIsModule;
174	int mbConcatArgs;	int mbConcatArgs;
175	int mbAllowExtraInitRds;	int mbAllowExtraInitRds;
176		char *envFile;
177	};	};
178
179	struct keywordTypes grubKeywords[] = {	struct keywordTypes grubKeywords[] = {
#	Line 167  const char *grubFindConfig(struct config	Line 193  const char *grubFindConfig(struct config
193	"/boot/grub/grub.conf",	"/boot/grub/grub.conf",
194	"/boot/grub/menu.lst",	"/boot/grub/menu.lst",
195	"/etc/grub.conf",	"/etc/grub.conf",
196		"/boot/grub2/grub.cfg",
197		"/boot/grub2-efi/grub.cfg",
198	NULL	NULL
199	};	};
200	static int i = -1;	static int i = -1;
#	Line 194  struct configFileInfo grubConfigType = {	Line 222  struct configFileInfo grubConfigType = {
222	.mbHyperFirst = 1,	.mbHyperFirst = 1,
223	.mbInitRdIsModule = 1,	.mbInitRdIsModule = 1,
224	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
225		.titlePosition = 1,
226	};	};
227
228	struct keywordTypes grub2Keywords[] = {	struct keywordTypes grub2Keywords[] = {
#	Line 205  struct keywordTypes grub2Keywords[] = {	Line 234  struct keywordTypes grub2Keywords[] = {
234	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
235	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
236	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
237		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
238		{ "linux16",    LT_KERNEL_16,   ' ' },
239	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
240		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
241		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
242	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
243	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
244		{ "devicetree", LT_DEVTREE,  ' ' },
245	{ NULL, 0, 0 },	{ NULL, 0, 0 },
246	};	};
247
#	Line 219  const char *grub2FindConfig(struct confi	Line 253  const char *grub2FindConfig(struct confi
253	};	};
254	static int i = -1;	static int i = -1;
255	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
256		int rc = -1;
257
258	if (i == -1) {	if (i == -1) {
259	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
260	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
261	if (!access(configFiles[i], R_OK)) {	if ((rc = access(configFiles[i], R_OK))) {
262		if (errno == EACCES) {
263		printf("Unable to access bootloader configuration file "
264		"\"%s\": %m\n", configFiles[i]);
265		exit(1);
266		}
267		continue;
268		} else {
269	dbgPrintf("found\n");	dbgPrintf("found\n");
270	return configFiles[i];	return configFiles[i];
271	}	}
#	Line 242  const char *grub2FindConfig(struct confi	Line 284  const char *grub2FindConfig(struct confi
284	return configFiles[i];	return configFiles[i];
285	}	}
286
287		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
288		static char *grub2GetEnv(struct configFileInfo *info, char *name)
289		{
290		static char buf[1025];
291		char *s = NULL;
292		char *ret = NULL;
293		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
294		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
295
296		if (rc < 0)
297		return NULL;
298
299		FILE *f = popen(s, "r");
300		if (!f)
301		goto out;
302
303		memset(buf, '\0', sizeof (buf));
304		ret = fgets(buf, 1024, f);
305		pclose(f);
306
307		if (ret) {
308		ret += strlen(name) + 1;
309		ret[strlen(ret) - 1] = '\0';
310		}
311		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
312		out:
313		free(s);
314		return ret;
315		}
316
317		static int sPopCount(const char *s, const char *c)
318		{
319		int ret = 0;
320		if (!s)
321		return -1;
322		for (int i = 0; s[i] != '\0'; i++)
323		for (int j = 0; c[j] != '\0'; j++)
324		if (s[i] == c[j])
325		ret++;
326		return ret;
327		}
328
329		static char *shellEscape(const char *s)
330		{
331		int l = strlen(s) + sPopCount(s, "'") * 2;
332
333		char *ret = calloc(l+1, sizeof (*ret));
334		if (!ret)
335		return NULL;
336		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
337		if (s[i] == '\'')
338		ret[j++] = '\\';
339		ret[j] = s[i];
340		}
341		return ret;
342		}
343
344		static void unquote(char *s)
345		{
346		int l = strlen(s);
347
348		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
349		memmove(s, s+1, l-2);
350		s[l-2] = '\0';
351		}
352		}
353
354		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
355		{
356		char *s = NULL;
357		int rc = 0;
358		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
359
360		unquote(value);
361		value = shellEscape(value);
362		if (!value)
363		return -1;
364
365		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
366		free(value);
367		if (rc <0)
368		return -1;
369
370		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
371		rc = system(s);
372		free(s);
373		return rc;
374		}
375
376		/* this is a gigantic hack to avoid clobbering grub2 variables... */
377		static int is_special_grub2_variable(const char *name)
378		{
379		if (!strcmp(name,"\"${next_entry}\""))
380		return 1;
381		if (!strcmp(name,"\"${prev_saved_entry}\""))
382		return 1;
383		return 0;
384		}
385
386	int sizeOfSingleLine(struct singleLine * line) {	int sizeOfSingleLine(struct singleLine * line) {
387	int count = 0;	int count = 0;
388
#	Line 271  static int isquote(char q)	Line 412  static int isquote(char q)
412	return 0;	return 0;
413	}	}
414
415		static int iskernel(enum lineType_e type) {
416		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
417		}
418
419		static int isinitrd(enum lineType_e type) {
420		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
421		}
422
423	char *grub2ExtractTitle(struct singleLine * line) {	char *grub2ExtractTitle(struct singleLine * line) {
424	char * current;	char * current;
425	char * current_indent;	char * current_indent;
#	Line 303  char *grub2ExtractTitle(struct singleLin	Line 452  char *grub2ExtractTitle(struct singleLin
452	* whose last character is also quote (assuming it's the closing one) */	* whose last character is also quote (assuming it's the closing one) */
453	int resultMaxSize;	int resultMaxSize;
454	char * result;	char * result;
455		/* need to ensure that ' does not match " as we search */
456		char quote_char = *current;
457
458	resultMaxSize = sizeOfSingleLine(line);	resultMaxSize = sizeOfSingleLine(line);
459	result = malloc(resultMaxSize);	result = malloc(resultMaxSize);
#	Line 316  char *grub2ExtractTitle(struct singleLin	Line 467  char *grub2ExtractTitle(struct singleLin
467	current_indent_len = strlen(current_indent);	current_indent_len = strlen(current_indent);
468
469	strncat(result, current_indent, current_indent_len);	strncat(result, current_indent, current_indent_len);
470	if (!isquote(current[current_len-1])) {	if (current[current_len-1] != quote_char) {
471	strncat(result, current, current_len);	strncat(result, current, current_len);
472	} else {	} else {
473	strncat(result, current, current_len - 1);	strncat(result, current, current_len - 1);
#	Line 328  char *grub2ExtractTitle(struct singleLin	Line 479  char *grub2ExtractTitle(struct singleLin
479
480	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
481	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
482		.getEnv = grub2GetEnv,
483		.setEnv = grub2SetEnv,
484	.keywords = grub2Keywords,	.keywords = grub2Keywords,
485	.defaultIsIndex = 1,	.defaultIsIndex = 1,
486	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 432  struct keywordTypes extlinuxKeywords[] =	Line 585  struct keywordTypes extlinuxKeywords[] =
585	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
586	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
587	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
588		{ "fdt",        LT_DEVTREE,     ' ' },
589		{ "fdtdir",     LT_DEVTREE,     ' ' },
590	{ NULL,    0, 0 },	{ NULL,    0, 0 },
591	};	};
592	int useextlinuxmenu;	int useextlinuxmenu;
#	Line 442  struct configFileInfo eliloConfigType =	Line 597  struct configFileInfo eliloConfigType =
597	.needsBootPrefix = 1,	.needsBootPrefix = 1,
598	.argsInQuotes = 1,	.argsInQuotes = 1,
599	.mbConcatArgs = 1,	.mbConcatArgs = 1,
600		.titlePosition = 1,
601	};	};
602
603	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
#	Line 450  struct configFileInfo liloConfigType = {	Line 606  struct configFileInfo liloConfigType = {
606	.entryStart = LT_KERNEL,	.entryStart = LT_KERNEL,
607	.argsInQuotes = 1,	.argsInQuotes = 1,
608	.maxTitleLength = 15,	.maxTitleLength = 15,
609		.titlePosition = 1,
610	};	};
611
612	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
#	Line 460  struct configFileInfo yabootConfigType =	Line 617  struct configFileInfo yabootConfigType =
617	.argsInQuotes = 1,	.argsInQuotes = 1,
618	.maxTitleLength = 15,	.maxTitleLength = 15,
619	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
620		.titlePosition = 1,
621	};	};
622
623	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
#	Line 469  struct configFileInfo siloConfigType = {	Line 627  struct configFileInfo siloConfigType = {
627	.needsBootPrefix = 1,	.needsBootPrefix = 1,
628	.argsInQuotes = 1,	.argsInQuotes = 1,
629	.maxTitleLength = 15,	.maxTitleLength = 15,
630		.titlePosition = 1,
631	};	};
632
633	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
#	Line 482  struct configFileInfo ziplConfigType = {	Line 641  struct configFileInfo ziplConfigType = {
641	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
642	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
643	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
644		.caseInsensitive = 1,
645	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
646	.needsBootPrefix = 1,	.needsBootPrefix = 1,
647	.maxTitleLength = 255,	.maxTitleLength = 255,
648	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
649		.defaultIsUnquoted = 1,
650		.titlePosition = 1,
651	};	};
652
653	struct grubConfig {	struct grubConfig {
#	Line 506  struct singleEntry * findEntryByIndex(st	Line 668  struct singleEntry * findEntryByIndex(st
668	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
669	const char * path, const char * prefix,	const char * path, const char * prefix,
670	int * index);	int * index);
671		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
672		int * index);
673	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
674	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
675	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 570  static char * sdupprintf(const char *for	Line 734  static char * sdupprintf(const char *for
734	return buf;	return buf;
735	}	}
736
737		static enum lineType_e preferredLineType(enum lineType_e type,
738		struct configFileInfo *cfi) {
739		if (isEfi && cfi == &grub2ConfigType) {
740		switch (type) {
741		case LT_KERNEL:
742		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
743		case LT_INITRD:
744		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
745		default:
746		return type;
747		}
748		#if defined(__i386__) || defined(__x86_64__)
749		} else if (cfi == &grub2ConfigType) {
750		switch (type) {
751		case LT_KERNEL:
752		return LT_KERNEL_16;
753		case LT_INITRD:
754		return LT_INITRD_16;
755		default:
756		return type;
757		}
758		#endif
759		}
760		return type;
761		}
762
763	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
764	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
765	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
#	Line 603  static char * getuuidbydev(char *device)	Line 793  static char * getuuidbydev(char *device)
793	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
794	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
795	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
796	if (!strcmp(keyword, kw->key))	if (cfi->caseInsensitive) {
797	return kw->type;	if (!strcasecmp(keyword, kw->key))
798		return kw->type;
799		} else {
800		if (!strcmp(keyword, kw->key))
801		return kw->type;
802		}
803	}	}
804	return LT_UNKNOWN;	return LT_UNKNOWN;
805	}	}
#	Line 641  static int isEntryStart(struct singleLin	Line 836  static int isEntryStart(struct singleLin
836	}	}
837
838	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
839	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
840	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it */
841	char * title;	char * title = NULL;
842	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
843	title++;	char *tmp = line->elements[cfg->cfi->titlePosition].item;
844	*(title + strlen(title) - 1) = '\0';	if (cfg->cfi->titleBracketed) {
845		tmp++;
846		title = strdup(tmp);
847		*(title + strlen(title) - 1) = '\0';
848		} else {
849		title = strdup(tmp);
850		}
851		} else if (line->type == LT_MENUENTRY)
852		title = strdup(line->elements[1].item);
853		else
854		return NULL;
855	return title;	return title;
856	}	}
857
#	Line 726  static int lineWrite(FILE * out, struct	Line 931  static int lineWrite(FILE * out, struct
931	/* Need to handle this, because we strip the quotes from	/* Need to handle this, because we strip the quotes from
932	* menuentry when read it. */	* menuentry when read it. */
933	if (line->type == LT_MENUENTRY && i == 1) {	if (line->type == LT_MENUENTRY && i == 1) {
934	if(!isquote(*line->elements[i].item))	if(!isquote(*line->elements[i].item)) {
935	fprintf(out, "\'%s\'", line->elements[i].item);	int substring = 0;
936	else	/* If the line contains nested quotes, we did not strip
937		* the "interna" quotes and we must use the right quotes
938		* again when writing the updated file. */
939		for (int j = i; j < line->numElements; j++) {
940		if (strchr(line->elements[i].item, '\'') != NULL) {
941		substring = 1;
942		fprintf(out, "\"%s\"", line->elements[i].item);
943		break;
944		}
945		}
946		if (!substring)
947		fprintf(out, "\'%s\'", line->elements[i].item);
948		} else {
949	fprintf(out, "%s", line->elements[i].item);	fprintf(out, "%s", line->elements[i].item);
950		}
951	fprintf(out, "%s", line->elements[i].indent);	fprintf(out, "%s", line->elements[i].indent);
952
953	continue;	continue;
#	Line 904  static int getNextLine(char ** bufPtr, s	Line 1122  static int getNextLine(char ** bufPtr, s
1122	return 0;	return 0;
1123	}	}
1124
1125		static int isnumber(const char *s)
1126		{
1127		int i;
1128		for (i = 0; s[i] != '\0'; i++)
1129		if (s[i] < '0' || s[i] > '9')
1130		return 0;
1131		return i;
1132		}
1133
1134	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1135	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1136	int in;	int in;
#	Line 918  static struct grubConfig * readConfig(co	Line 1145  static struct grubConfig * readConfig(co
1145	int len;	int len;
1146	char * buf;	char * buf;
1147
1148	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1149		printf("Could not find bootloader configuration\n");
1150		exit(1);
1151		} else if (!strcmp(inName, "-")) {
1152	in = 0;	in = 0;
1153	} else {	} else {
1154	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 985  static struct grubConfig * readConfig(co	Line 1215  static struct grubConfig * readConfig(co
1215	dbgPrintf("\n");	dbgPrintf("\n");
1216	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1217	if (kwType && line->numElements == 3 &&	if (kwType && line->numElements == 3 &&
1218	!strcmp(line->elements[1].item, kwType->key)) {	!strcmp(line->elements[1].item, kwType->key) &&
1219		!is_special_grub2_variable(line->elements[2].item)) {
1220	dbgPrintf("Line sets default config\n");	dbgPrintf("Line sets default config\n");
1221	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1222	defaultLine = line;	defaultLine = line;
1223	}	}
	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
1224
1225	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1226	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1227	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1228	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1229	*/	*/
1230	if (entry->multiboot)	if (entry && entry->multiboot)
1231	line->type = LT_HYPER;	line->type = LT_HYPER;
1232
1233	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 1011  static struct grubConfig * readConfig(co	Line 1239  static struct grubConfig * readConfig(co
1239	for (struct singleLine *l = entry->lines; l; l = l->next) {	for (struct singleLine *l = entry->lines; l; l = l->next) {
1240	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1241	break;	break;
1242	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1243	l->type = LT_HYPER;	l->type = LT_HYPER;
1244	break;	break;
1245	}	}
#	Line 1025  static struct grubConfig * readConfig(co	Line 1253  static struct grubConfig * readConfig(co
1253	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1254	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1255
1256	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1257	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1258		/* make the title/default a single argument (undoing our parsing) */
1259	len = 0;	len = 0;
1260	for (int i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1261	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
#	Line 1054  static struct grubConfig * readConfig(co	Line 1283  static struct grubConfig * readConfig(co
1283	len = 0;	len = 0;
1284	char *extras;	char *extras;
1285	char *title;	char *title;
1286		/* initially unseen value */
1287		char quote_char = '\0';
1288
1289	for (int i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1290	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
#	Line 1070  static struct grubConfig * readConfig(co	Line 1301  static struct grubConfig * readConfig(co
1301	for (int i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1302	if (!strcmp(line->elements[i].item, "menuentry"))	if (!strcmp(line->elements[i].item, "menuentry"))
1303	continue;	continue;
1304	if (isquote(*line->elements[i].item))	if (isquote(*line->elements[i].item) && quote_char == '\0') {
1305		/* ensure we properly pair off quotes */
1306		quote_char = *line->elements[i].item;
1307	title = line->elements[i].item + 1;	title = line->elements[i].item + 1;
1308	else	} else {
1309	title = line->elements[i].item;	title = line->elements[i].item;
1310		}
1311
1312	len = strlen(title);	len = strlen(title);
1313	if (isquote(title[len-1])) {	if (title[len-1] == quote_char) {
1314	strncat(buf, title,len-1);	strncat(buf, title,len-1);
1315	break;	break;
1316	} else {	} else {
#	Line 1087  static struct grubConfig * readConfig(co	Line 1321  static struct grubConfig * readConfig(co
1321
1322	/* get extras */	/* get extras */
1323	int count = 0;	int count = 0;
1324		quote_char = '\0';
1325	for (int i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1326	if (count >= 2) {	if (count >= 2) {
1327	strcat(extras, line->elements[i].item);	strcat(extras, line->elements[i].item);
#	Line 1097  static struct grubConfig * readConfig(co	Line 1332  static struct grubConfig * readConfig(co
1332	continue;	continue;
1333
1334	/* count ' or ", there should be two in menuentry line. */	/* count ' or ", there should be two in menuentry line. */
1335	if (isquote(*line->elements[i].item))	if (isquote(*line->elements[i].item) && quote_char == '\0') {
1336		/* ensure we properly pair off quotes */
1337		quote_char = *line->elements[i].item;
1338	count++;	count++;
1339		}
1340
1341	len = strlen(line->elements[i].item);	len = strlen(line->elements[i].item);
1342
1343	if (isquote(line->elements[i].item[len -1]))	if (line->elements[i].item[len -1] == quote_char)
1344	count++;	count++;
1345
1346	/* ok, we get the final ' or ", others are extras. */	/* ok, we get the final ' or ", others are extras. */
#	Line 1133  static struct grubConfig * readConfig(co	Line 1371  static struct grubConfig * readConfig(co
1371	}	}
1372	}	}
1373
1374		if (line->type == LT_DEFAULT && line->numElements == 2) {
1375		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1376		defaultLine = line;
1377		}
1378
1379	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1380	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1381	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 1190  static struct grubConfig * readConfig(co	Line 1433  static struct grubConfig * readConfig(co
1433	if (defaultLine->numElements > 2 &&	if (defaultLine->numElements > 2 &&
1434	cfi->defaultSupportSaved &&	cfi->defaultSupportSaved &&
1435	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1436	cfg->defaultImage = DEFAULT_SAVED_GRUB2;	cfg->cfi->defaultIsSaved = 1;
1437		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1438		if (cfg->cfi->getEnv) {
1439		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1440		if (defTitle) {
1441		int index = 0;
1442		if (isnumber(defTitle)) {
1443		index = atoi(defTitle);
1444		entry = findEntryByIndex(cfg, index);
1445		} else {
1446		entry = findEntryByTitle(cfg, defTitle, &index);
1447		}
1448		if (entry)
1449		cfg->defaultImage = index;
1450		}
1451		}
1452	} else if (cfi->defaultIsVariable) {	} else if (cfi->defaultIsVariable) {
1453	char *value = defaultLine->elements[2].item;	char *value = defaultLine->elements[2].item;
1454	while (*value && (*value == '"' || *value == '\'' ||	while (*value && (*value == '"' || *value == '\'' ||
#	Line 1219  static struct grubConfig * readConfig(co	Line 1477  static struct grubConfig * readConfig(co
1477	line->elements[1].item)) break;	line->elements[1].item)) break;
1478	} else if (line) {	} else if (line) {
1479	if (!strcmp(defaultLine->elements[1].item,	if (!strcmp(defaultLine->elements[1].item,
1480	extractTitle(line))) break;	extractTitle(cfg, line))) break;
1481	}	}
1482	i++;	i++;
1483	entry = NULL;	entry = NULL;
#	Line 1231  static struct grubConfig * readConfig(co	Line 1489  static struct grubConfig * readConfig(co
1489	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1490	}	}
1491	}	}
1492		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1493		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1494		if (defTitle) {
1495		int index = 0;
1496		if (isnumber(defTitle)) {
1497		index = atoi(defTitle);
1498		entry = findEntryByIndex(cfg, index);
1499		} else {
1500		entry = findEntryByTitle(cfg, defTitle, &index);
1501		}
1502		if (entry)
1503		cfg->defaultImage = index;
1504		}
1505	} else {	} else {
1506	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1507	}	}
#	Line 1248  static void writeDefault(FILE * out, cha	Line 1519  static void writeDefault(FILE * out, cha
1519
1520	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1521	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1522	else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)	else if (cfg->cfi->defaultIsSaved) {
1523	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1524	else if (cfg->defaultImage > -1) {	if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1525		char *title;
1526		entry = findEntryByIndex(cfg, cfg->defaultImage);
1527		line = getLineByType(LT_MENUENTRY, entry->lines);
1528		if (!line)
1529		line = getLineByType(LT_TITLE, entry->lines);
1530		if (line) {
1531		title = extractTitle(cfg, line);
1532		if (title)
1533		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1534		}
1535		}
1536		} else if (cfg->defaultImage > -1) {
1537	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1538	if (cfg->cfi->defaultIsVariable) {	if (cfg->cfi->defaultIsVariable) {
1539	fprintf(out, "%sset default=\"%d\"\n", indent,	fprintf(out, "%sset default=\"%d\"\n", indent,
#	Line 1283  static void writeDefault(FILE * out, cha	Line 1566  static void writeDefault(FILE * out, cha
1566	else if (line && (line->numElements == 1) &&	else if (line && (line->numElements == 1) &&
1567	cfg->cfi->titleBracketed) {	cfg->cfi->titleBracketed) {
1568	fprintf(out, "%sdefault%s%s\n", indent, separator,	fprintf(out, "%sdefault%s%s\n", indent, separator,
1569	extractTitle(line));	extractTitle(cfg, line));
1570	}	}
1571	}	}
1572	}	}
#	Line 1310  static int writeConfig(struct grubConfig	Line 1593  static int writeConfig(struct grubConfig
1593
1594	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1595	directory to the dir of the symlink */	directory to the dir of the symlink */
1596	rc = chdir(dirname(outName));	char *dir = strdupa(outName);
1597		rc = chdir(dirname(dir));
1598	do {	do {
1599	buf = alloca(len + 1);	buf = alloca(len + 1);
1600	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1352  static int writeConfig(struct grubConfig	Line 1636  static int writeConfig(struct grubConfig
1636	while (line) {	while (line) {
1637	if (line->type == LT_SET_VARIABLE && defaultKw &&	if (line->type == LT_SET_VARIABLE && defaultKw &&
1638	line->numElements == 3 &&	line->numElements == 3 &&
1639	!strcmp(line->elements[1].item, defaultKw->key)) {	!strcmp(line->elements[1].item, defaultKw->key) &&
1640		!is_special_grub2_variable(line->elements[2].item)) {
1641	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1642	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1643	} else if (line->type == LT_DEFAULT) {	} else if (line->type == LT_DEFAULT) {
#	Line 1497  static char *findDiskForRoot()	Line 1782  static char *findDiskForRoot()
1782	return NULL;	return NULL;
1783	}	}
1784
1785	void printEntry(struct singleEntry * entry) {	void printEntry(struct singleEntry * entry, FILE *f) {
1786	int i;	int i;
1787	struct singleLine * line;	struct singleLine * line;
1788
1789	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
1790	fprintf(stderr, "DBG: %s", line->indent);	log_message(f, "DBG: %s", line->indent);
1791	for (i = 0; i < line->numElements; i++) {	for (i = 0; i < line->numElements; i++) {
1792	/* Need to handle this, because we strip the quotes from	/* Need to handle this, because we strip the quotes from
1793	* menuentry when read it. */	* menuentry when read it. */
1794	if (line->type == LT_MENUENTRY && i == 1) {	if (line->type == LT_MENUENTRY && i == 1) {
1795	if(!isquote(*line->elements[i].item))	if(!isquote(*line->elements[i].item))
1796	fprintf(stderr, "\'%s\'", line->elements[i].item);	log_message(f, "\'%s\'", line->elements[i].item);
1797	else	else
1798	fprintf(stderr, "%s", line->elements[i].item);	log_message(f, "%s", line->elements[i].item);
1799	fprintf(stderr, "%s", line->elements[i].indent);	log_message(f, "%s", line->elements[i].indent);
1800
1801	continue;	continue;
1802	}	}
1803
1804	fprintf(stderr, "%s%s",	log_message(f, "%s%s",
1805	line->elements[i].item, line->elements[i].indent);	line->elements[i].item, line->elements[i].indent);
1806	}	}
1807	fprintf(stderr, "\n");	log_message(f, "\n");
1808	}	}
1809	}	}
1810
1811	void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)	void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1812	{	{
1813	va_list argp;	static int once;
1814		va_list argp, argq;
1815
1816	if (!debug)	va_start(argp, fmt);
1817
1818		va_copy(argq, argp);
1819		if (!once) {
1820		log_time(NULL);
1821		log_message(NULL, "command line: %s\n", saved_command_line);
1822		}
1823		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1824		log_vmessage(NULL, fmt, argq);
1825
1826		printEntry(entry, NULL);
1827		va_end(argq);
1828
1829		if (!debug) {
1830		once = 1;
1831		va_end(argp);
1832	return;	return;
1833		}
1834
1835	va_start(argp, fmt);	if (okay) {
1836		va_end(argp);
1837		return;
1838		}
1839
1840		if (!once)
1841		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1842		once = 1;
1843	fprintf(stderr, "DBG: Image entry failed: ");	fprintf(stderr, "DBG: Image entry failed: ");
1844	vfprintf(stderr, fmt, argp);	vfprintf(stderr, fmt, argp);
1845	printEntry(entry);	printEntry(entry, stderr);
1846	va_end(argp);	va_end(argp);
1847	}	}
1848
#	Line 1560  int suitableImage(struct singleEntry * e	Line 1869  int suitableImage(struct singleEntry * e
1869	char * rootdev;	char * rootdev;
1870
1871	if (skipRemoved && entry->skip) {	if (skipRemoved && entry->skip) {
1872	notSuitablePrintf(entry, "marked to skip\n");	notSuitablePrintf(entry, 0, "marked to skip\n");
1873	return 0;	return 0;
1874	}	}
1875
1876	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1877	if (!line) {	if (!line) {
1878	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1879	return 0;	return 0;
1880	}	}
1881	if (line->numElements < 2) {	if (line->numElements < 2) {
1882	notSuitablePrintf(entry, "line has only %d elements\n",	notSuitablePrintf(entry, 0, "line has only %d elements\n",
1883	line->numElements);	line->numElements);
1884	return 0;	return 0;
1885	}	}
1886
1887	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1888		notSuitablePrintf(entry, 1, "\n");
1889		return 1;
1890		}
1891
1892	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1893	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
#	Line 1586  int suitableImage(struct singleEntry * e	Line 1898  int suitableImage(struct singleEntry * e
1898	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1899	line->elements[1].item + rootspec_offset);	line->elements[1].item + rootspec_offset);
1900	if (access(fullName, R_OK)) {	if (access(fullName, R_OK)) {
1901	notSuitablePrintf(entry, "access to %s failed\n", fullName);	notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1902	return 0;	return 0;
1903	}	}
1904	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
#	Line 1607  int suitableImage(struct singleEntry * e	Line 1919  int suitableImage(struct singleEntry * e
1919
1920	/* failed to find one */	/* failed to find one */
1921	if (!line) {	if (!line) {
1922	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1923	return 0;	return 0;
1924	}	}
1925
#	Line 1616  int suitableImage(struct singleEntry * e	Line 1928  int suitableImage(struct singleEntry * e
1928	if (i < line->numElements)	if (i < line->numElements)
1929	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1930	else {	else {
1931	notSuitablePrintf(entry, "no root= entry found\n");	notSuitablePrintf(entry, 0, "no root= entry found\n");
1932	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1933	return 0;	return 0;
1934	}	}
#	Line 1625  int suitableImage(struct singleEntry * e	Line 1937  int suitableImage(struct singleEntry * e
1937
1938	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1939	if (!getpathbyspec(dev)) {	if (!getpathbyspec(dev)) {
1940	notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);	notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1941	return 0;	return 0;
1942	} else	} else
1943	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1944
1945	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1946	if (!rootdev) {	if (!rootdev) {
1947	notSuitablePrintf(entry, "can't find root device\n");	notSuitablePrintf(entry, 0, "can't find root device\n");
1948	return 0;	return 0;
1949	}	}
1950
1951	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1952	notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1953	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1954	free(rootdev);	free(rootdev);
1955	return 0;	return 0;
1956	}	}
1957
1958	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1959	notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1960	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1961	free(rootdev);	free(rootdev);
1962	return 0;	return 0;
1963	}	}
1964
1965	free(rootdev);	free(rootdev);
1966		notSuitablePrintf(entry, 1, "\n");
1967
1968	return 1;	return 1;
1969	}	}
#	Line 1684  struct singleEntry * findEntryByPath(str	Line 1997  struct singleEntry * findEntryByPath(str
1997	}	}
1998
1999	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
2000
2001	i = 0;	i = 0;
2002	if (index) {	if (index) {
2003	while (i < *index) i++;	while (i < *index) {
2004	if (indexVars[i] == -1) return NULL;	i++;
2005		if (indexVars[i] == -1) return NULL;
2006		}
2007	}	}
2008
2009	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
2010	if (!entry) return NULL;	if (!entry) return NULL;
2011
2012	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2013	if (!line) return NULL;	if (!line) return NULL;
2014
2015	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1743  struct singleEntry * findEntryByPath(str	Line 2058  struct singleEntry * findEntryByPath(str
2058
2059	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2060	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2061	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2062	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2063	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2064	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2065		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2066		line = getLineByType(ct, line);
2067		if (!line)
2068		break;  /* not found in this entry */
2069
2070	if (line && line->type != LT_MENUENTRY &&	if (line && line->type != LT_MENUENTRY &&
2071	line->numElements >= 2) {	line->numElements >= 2) {
#	Line 1765  struct singleEntry * findEntryByPath(str	Line 2084  struct singleEntry * findEntryByPath(str
2084	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2085	* unfortunate)	* unfortunate)
2086	*/	*/
2087	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2088	break; /* found 'im! */	break; /* found 'im! */
2089	}	}
2090
#	Line 1775  struct singleEntry * findEntryByPath(str	Line 2094  struct singleEntry * findEntryByPath(str
2094	return entry;	return entry;
2095	}	}
2096
2097		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2098		int * index) {
2099		struct singleEntry * entry;
2100		struct singleLine * line;
2101		int i;
2102		char * newtitle;
2103
2104		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2105		if (index && i < *index)
2106		continue;
2107		line = getLineByType(LT_TITLE, entry->lines);
2108		if (!line)
2109		line = getLineByType(LT_MENUENTRY, entry->lines);
2110		if (!line)
2111		continue;
2112		newtitle = grub2ExtractTitle(line);
2113		if (!newtitle)
2114		continue;
2115		if (!strcmp(title, newtitle))
2116		break;
2117		}
2118
2119		if (!entry)
2120		return NULL;
2121
2122		if (index)
2123		*index = i;
2124		return entry;
2125		}
2126
2127	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2128	struct singleEntry * entry;	struct singleEntry * entry;
2129
#	Line 1797  struct singleEntry * findTemplate(struct	Line 2146  struct singleEntry * findTemplate(struct
2146	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2147	int index;	int index;
2148
2149	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2150		if (cfg->cfi->getEnv) {
2151		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2152		if (defTitle) {
2153		int index = 0;
2154		if (isnumber(defTitle)) {
2155		index = atoi(defTitle);
2156		entry = findEntryByIndex(cfg, index);
2157		} else {
2158		entry = findEntryByTitle(cfg, defTitle, &index);
2159		}
2160		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2161		cfg->defaultImage = index;
2162		if (indexPtr)
2163		*indexPtr = index;
2164		return entry;
2165		}
2166		}
2167		}
2168		} else if (cfg->defaultImage > -1) {
2169	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2170	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2171	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1867  void markRemovedImage(struct grubConfig	Line 2235  void markRemovedImage(struct grubConfig
2235
2236	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2237	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2238	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2239	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2240	int i, j;	int i, j;
2241
2242	if (newIsDefault) {	if (newIsDefault) {
2243	config->defaultImage = 0;	config->defaultImage = 0;
2244	return;	return;
2245		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2246		if (findEntryByIndex(config, index))
2247		config->defaultImage = index;
2248		else
2249		config->defaultImage = -1;
2250		return;
2251	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2252	i = 0;	i = 0;
2253	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1945  void displayEntry(struct singleEntry * e	Line 2319  void displayEntry(struct singleEntry * e
2319	struct singleLine * line;	struct singleLine * line;
2320	char * root = NULL;	char * root = NULL;
2321	int i;	int i;
2322		int j;
2323
2324	printf("index=%d\n", index);	printf("index=%d\n", index);
2325
2326	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2327	if (!line) {	if (!line) {
2328	printf("non linux entry\n");	printf("non linux entry\n");
2329	return;	return;
#	Line 2013  void displayEntry(struct singleEntry * e	Line 2388  void displayEntry(struct singleEntry * e
2388	printf("root=%s\n", s);	printf("root=%s\n", s);
2389	}	}
2390
2391	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2392
2393	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2394	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
#	Line 2032  void displayEntry(struct singleEntry * e	Line 2407  void displayEntry(struct singleEntry * e
2407	} else {	} else {
2408	char * title;	char * title;
2409	line = getLineByType(LT_MENUENTRY, entry->lines);	line = getLineByType(LT_MENUENTRY, entry->lines);
2410	title = grub2ExtractTitle(line);	if (line) {
2411	if (title)	title = grub2ExtractTitle(line);
2412	printf("title=%s\n", title);	if (title)
2413		printf("title=%s\n", title);
2414		}
2415		}
2416
2417		for (j = 0, line = entry->lines; line; line = line->next) {
2418		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2419		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2420		printf("mbmodule%d=", j);
2421		else
2422		printf("mbmodule%d=%s", j, prefix);
2423
2424		for (i = 1; i < line->numElements; i++)
2425		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2426		printf("\n");
2427		j++;
2428		}
2429	}	}
2430	}	}
2431
#	Line 2414  struct singleLine * addLineTmpl(struct s	Line 2805  struct singleLine * addLineTmpl(struct s
2805	{	{
2806	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2807
2808		if (isEfi && cfi == &grub2ConfigType) {
2809		enum lineType_e old = newLine->type;
2810		newLine->type = preferredLineType(newLine->type, cfi);
2811		if (old != newLine->type)
2812		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2813		}
2814
2815	if (val) {	if (val) {
2816	/* override the inherited value with our own.	/* override the inherited value with our own.
2817	* 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 2423  struct singleLine * addLineTmpl(struct s	Line 2821  struct singleLine * addLineTmpl(struct s
2821	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2822
2823	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2824	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|LT_KERNEL_16|LT_INITRD_16)) {
2825	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2826	if (rootspec != NULL) {	if (rootspec != NULL) {
2827	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 2460  struct singleLine *  addLine(struct sing	Line 2858  struct singleLine *  addLine(struct sing
2858	/* 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
2859	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2860	*/	*/
2861	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2862	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2863	tmpl.type = type;	tmpl.type = type;
#	Line 2794  int updateActualImage(struct grubConfig	Line 3191  int updateActualImage(struct grubConfig
3191	firstElement = 2;	firstElement = 2;
3192
3193	} else {	} else {
3194	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3195	if (!line) {	if (!line) {
3196	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3197	continue;	continue;
#	Line 2950  int updateImage(struct grubConfig * cfg,	Line 3347  int updateImage(struct grubConfig * cfg,
3347	return rc;	return rc;
3348	}	}
3349
3350		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3351		const char * image, const char * prefix, const char * initrd,
3352		const char * title) {
3353		struct singleEntry * entry;
3354		struct singleLine * line, * kernelLine, *endLine = NULL;
3355		int index = 0;
3356
3357		if (!image) return 0;
3358
3359		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3360		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3361		if (!kernelLine) continue;
3362
3363		/* if title is supplied, the entry's title must match it. */
3364		if (title) {
3365		char *linetitle;
3366
3367		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3368		if (!line)
3369		continue;
3370
3371		linetitle = extractTitle(cfg, line);
3372		if (!linetitle)
3373		continue;
3374		if (strcmp(title, linetitle)) {
3375		free(linetitle);
3376		continue;
3377		}
3378		free(linetitle);
3379		}
3380
3381		if (prefix) {
3382		int prefixLen = strlen(prefix);
3383		if (!strncmp(initrd, prefix, prefixLen))
3384		initrd += prefixLen;
3385		}
3386		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3387		if (endLine)
3388		removeLine(entry, endLine);
3389		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3390		kernelLine->indent, initrd);
3391		if (!line)
3392		return 1;
3393		if (endLine) {
3394		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3395		if (!line)
3396		return 1;
3397		}
3398
3399		break;
3400		}
3401
3402		return 0;
3403		}
3404
3405	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3406	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd, const char * title) {
3407	struct singleEntry * entry;	struct singleEntry * entry;
3408	struct singleLine * line, * kernelLine, *endLine = NULL;	struct singleLine * line, * kernelLine, *endLine = NULL;
3409	int index = 0;	int index = 0;
#	Line 2959  int updateInitrd(struct grubConfig * cfg	Line 3411  int updateInitrd(struct grubConfig * cfg
3411	if (!image) return 0;	if (!image) return 0;
3412
3413	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3414	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3415	if (!kernelLine) continue;	if (!kernelLine) continue;
3416
3417	line = getLineByType(LT_INITRD, entry->lines);	/* if title is supplied, the entry's title must match it. */
3418		if (title) {
3419		char *linetitle;
3420
3421		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3422		if (!line)
3423		continue;
3424
3425		linetitle = extractTitle(cfg, line);
3426		if (!linetitle)
3427		continue;
3428		if (strcmp(title, linetitle)) {
3429		free(linetitle);
3430		continue;
3431		}
3432		free(linetitle);
3433		}
3434
3435		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3436	if (line)	if (line)
3437	removeLine(entry, line);	removeLine(entry, line);
3438	if (prefix) {	if (prefix) {
#	Line 2973  int updateInitrd(struct grubConfig * cfg	Line 3443  int updateInitrd(struct grubConfig * cfg
3443	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3444	if (endLine)	if (endLine)
3445	removeLine(entry, endLine);	removeLine(entry, endLine);
3446	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3447		switch(kernelLine->type) {
3448		case LT_KERNEL:
3449		lt = LT_INITRD;
3450		break;
3451		case LT_KERNEL_EFI:
3452		lt = LT_INITRD_EFI;
3453		break;
3454		case LT_KERNEL_16:
3455		lt = LT_INITRD_16;
3456		break;
3457		default:
3458		lt = preferredLineType(LT_INITRD, cfg->cfi);
3459		}
3460		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3461	if (!line)	if (!line)
3462	return 1;	return 1;
3463	if (endLine) {	if (endLine) {
#	Line 3332  int addNewKernel(struct grubConfig * con	Line 3816  int addNewKernel(struct grubConfig * con
3816	const char * newKernelPath, const char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3817	const char * newKernelArgs, const char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3818	const char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3819	const char * newMBKernel, const char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3820		const char * newDevTreePath) {
3821	struct singleEntry * new;	struct singleEntry * new;
3822	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3823	int needs;	int needs;
#	Line 3373  int addNewKernel(struct grubConfig * con	Line 3858  int addNewKernel(struct grubConfig * con
3858	needs |= NEED_MB;	needs |= NEED_MB;
3859	new->multiboot = 1;	new->multiboot = 1;
3860	}	}
3861		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3862		needs |= NEED_DEVTREE;
3863
3864	if (template) {	if (template) {
3865	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 3386  int addNewKernel(struct grubConfig * con	Line 3873  int addNewKernel(struct grubConfig * con
3873	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3874	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3875
3876	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3877	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3878	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3879	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 3464  int addNewKernel(struct grubConfig * con	Line 3950  int addNewKernel(struct grubConfig * con
3950	/* template is multi but new is not,	/* template is multi but new is not,
3951	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3952	*/	*/
3953	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3954	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3955	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3956	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3957		config->cfi)->key);
3958	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3959	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3960		config->cfi);
3961	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3962	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3963	char *initrdVal;	char *initrdVal;
3964	/* template is multi but new is not,	/* template is multi but new is not,
3965	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3966	*/	*/
3967	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3968	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3969	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3970	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3971		config->cfi)->key);
3972	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3973	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3974	free(initrdVal);	free(initrdVal);
3975	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3976	}	}
3977
3978	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3979	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3980	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3981	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 3541  int addNewKernel(struct grubConfig * con	Line 4029  int addNewKernel(struct grubConfig * con
4029	static const char *prefix = "'Loading ";	static const char *prefix = "'Loading ";
4030	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
4031	strstr(tmplLine->elements[1].item, prefix) &&	strstr(tmplLine->elements[1].item, prefix) &&
4032	masterLine->next && masterLine->next->type == LT_KERNEL) {	masterLine->next &&
4033		iskernel(masterLine->next->type)) {
4034	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
4035	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
4036
#	Line 3556  int addNewKernel(struct grubConfig * con	Line 4045  int addNewKernel(struct grubConfig * con
4045	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4046	config->cfi);	config->cfi);
4047	}	}
4048		} else if (tmplLine->type == LT_DEVTREE &&
4049		tmplLine->numElements == 2 && newDevTreePath) {
4050		newLine = addLineTmpl(new, tmplLine, newLine,
4051		newDevTreePath + strlen(prefix),
4052		config->cfi);
4053		needs &= ~NEED_DEVTREE;
4054		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4055		const char *ndtp = newDevTreePath;
4056		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4057		ndtp += strlen(prefix);
4058		newLine = addLine(new, config->cfi, LT_DEVTREE,
4059		config->secondaryIndent,
4060		ndtp);
4061		needs &= ~NEED_DEVTREE;
4062		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4063	} else {	} else {
4064	/* pass through other lines from the template */	/* pass through other lines from the template */
4065	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 3568  int addNewKernel(struct grubConfig * con	Line 4072  int addNewKernel(struct grubConfig * con
4072	*/	*/
4073	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
4074	case LT_KERNEL:	case LT_KERNEL:
4075		case LT_KERNEL_EFI:
4076		case LT_KERNEL_16:
4077	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4078	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4079	} else {	} else {
4080	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4081		preferredLineType(LT_KERNEL, config->cfi),
4082	config->primaryIndent,	config->primaryIndent,
4083	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4084	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3628  int addNewKernel(struct grubConfig * con	Line 4135  int addNewKernel(struct grubConfig * con
4135	}	}
4136	}	}
4137
4138		struct singleLine *endLine = NULL;
4139		endLine = getLineByType(LT_ENTRY_END, new->lines);
4140		if (endLine) {
4141		removeLine(new, endLine);
4142		needs |= NEED_END;
4143		}
4144
4145	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4146	* weren't present in the template, or in the case of no template,	* weren't present in the template, or in the case of no template,
4147	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3647  int addNewKernel(struct grubConfig * con	Line 4161  int addNewKernel(struct grubConfig * con
4161	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4162	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4163	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4164	config->cfi)) ?	config->cfi))
4165	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4166		: preferredLineType(LT_KERNEL, config->cfi),
4167	config->secondaryIndent,	config->secondaryIndent,
4168	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4169	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3664  int addNewKernel(struct grubConfig * con	Line 4179  int addNewKernel(struct grubConfig * con
4179	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4180	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4181	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4182	config->cfi)) ?	config->cfi))
4183	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4184		: preferredLineType(LT_INITRD, config->cfi),
4185	config->secondaryIndent,	config->secondaryIndent,
4186	initrdVal);	initrdVal);
4187	free(initrdVal);	free(initrdVal);
4188	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4189	}	}
4190		if (needs & NEED_DEVTREE) {
4191		newLine = addLine(new, config->cfi, LT_DEVTREE,
4192		config->secondaryIndent,
4193		newDevTreePath);
4194		needs &= ~NEED_DEVTREE;
4195		}
4196
4197		/* NEEDS_END must be last on bootloaders that need it... */
4198	if (needs & NEED_END) {	if (needs & NEED_END) {
4199	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4200	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3697  static void traceback(int signum)	Line 4221  static void traceback(int signum)
4221	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4222	size = backtrace(array, 40);	size = backtrace(array, 40);
4223
4224	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4225	(unsigned long)size);	(unsigned long)size);
4226	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4227	exit(1);	exit(1);
#	Line 3722  int main(int argc, const char ** argv) {	Line 4246  int main(int argc, const char ** argv) {
4246	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4247	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4248	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4249	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4250	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4251	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4252	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3732  int main(int argc, const char ** argv) {	Line 4256  int main(int argc, const char ** argv) {
4256	char * removeArgs = NULL;	char * removeArgs = NULL;
4257	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4258	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4259		char * envPath = NULL;
4260	const char * chptr = NULL;	const char * chptr = NULL;
4261	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4262	struct grubConfig * config;	struct grubConfig * config;
#	Line 3740  int main(int argc, const char ** argv) {	Line 4265  int main(int argc, const char ** argv) {
4265	int displayDefault = 0;	int displayDefault = 0;
4266	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4267	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4268		int defaultIndex = -1;
4269	struct poptOption options[] = {	struct poptOption options[] = {
4270	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4271	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3778  int main(int argc, const char ** argv) {	Line 4304  int main(int argc, const char ** argv) {
4304	_("display the index of the default kernel") },	_("display the index of the default kernel") },
4305	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{ "default-title", 0, 0, &displayDefaultTitle, 0,
4306	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4307		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4308		_("device tree file for new stanza"), _("dtb-path") },
4309		{ "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4310		_("device tree directory for new stanza"), _("dtb-path") },
4311	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4312	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4313		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4314		_("force grub2 stanzas to use efi") },
4315		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4316		_("path for environment data"),
4317		_("path") },
4318	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4319	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4320	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3792  int main(int argc, const char ** argv) {	Line 4327  int main(int argc, const char ** argv) {
4327	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4328	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4329	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4330	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4331	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4332	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4333	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3812  int main(int argc, const char ** argv) {	Line 4347  int main(int argc, const char ** argv) {
4347	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4348	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4349	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4350		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4351		_("make the given entry index the default entry"),
4352		_("entry-index") },
4353	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4354	_("configure silo bootloader") },	_("configure silo bootloader") },
4355	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3833  int main(int argc, const char ** argv) {	Line 4371  int main(int argc, const char ** argv) {
4371
4372	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4373
4374		int i = 0;
4375		for (int j = 1; j < argc; j++)
4376		i += strlen(argv[j]) + 1;
4377		saved_command_line = malloc(i);
4378		if (!saved_command_line) {
4379		fprintf(stderr, "grubby: %m\n");
4380		exit(1);
4381		}
4382		saved_command_line[0] = '\0';
4383		for (int j = 1; j < argc; j++) {
4384		strcat(saved_command_line, argv[j]);
4385		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4386		}
4387
4388	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4389	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4390
#	Line 3876  int main(int argc, const char ** argv) {	Line 4428  int main(int argc, const char ** argv) {
4428	return 1;	return 1;
4429	} else if (configureGrub2) {	} else if (configureGrub2) {
4430	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4431		if (envPath)
4432		cfi->envFile = envPath;
4433	} else if (configureLilo) {	} else if (configureLilo) {
4434	cfi = &liloConfigType;	cfi = &liloConfigType;
4435	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3894  int main(int argc, const char ** argv) {	Line 4448  int main(int argc, const char ** argv) {
4448	}	}
4449
4450	if (!cfi) {	if (!cfi) {
4451	if (grub2FindConfig(&grub2ConfigType))	if (grub2FindConfig(&grub2ConfigType)) {
4452	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4453	else	if (envPath)
4454		cfi->envFile = envPath;
4455		} else
4456	#ifdef __ia64__	#ifdef __ia64__
4457	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4458	#elif __powerpc__	#elif __powerpc__
#	Line 3919  int main(int argc, const char ** argv) {	Line 4475  int main(int argc, const char ** argv) {
4475	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4476	}	}
4477
4478	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4479	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4480	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4481		(defaultIndex >= 0))) {
4482	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4483	"specified option"));	"specified option"));
4484	return 1;	return 1;
4485	}	}
4486
4487	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4488	removeKernelPath)) {	removeKernelPath)) {
4489	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4490	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3937  int main(int argc, const char ** argv) {	Line 4494  int main(int argc, const char ** argv) {
4494	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4495	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4496	return 1;	return 1;
4497	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4498	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4499	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4500	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3963  int main(int argc, const char ** argv) {	Line 4520  int main(int argc, const char ** argv) {
4520	makeDefault = 1;	makeDefault = 1;
4521	defaultKernel = NULL;	defaultKernel = NULL;
4522	}	}
4523		else if (defaultKernel && (defaultIndex >= 0)) {
4524		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4525		"may not be used together\n"));
4526		return 1;
4527		}
4528
4529	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4530	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3971  int main(int argc, const char ** argv) {	Line 4533  int main(int argc, const char ** argv) {
4533	}	}
4534
4535	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4536	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4537	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4538		&& (defaultIndex == -1)) {
4539	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4540	return 1;	return 1;
4541	}	}
#	Line 4052  int main(int argc, const char ** argv) {	Line 4615  int main(int argc, const char ** argv) {
4615	if (!yconfig)	if (!yconfig)
4616	yrc = 1;	yrc = 1;
4617	else	else
4618	yrc = checkForYaboot(lconfig);	yrc = checkForYaboot(yconfig);
4619	}	}
4620
4621	if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||	if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4622	erc == 1)	erc == 1)
4623	return 1;	return 1;
4624
4625	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
#	Line 4069  int main(int argc, const char ** argv) {	Line 4632  int main(int argc, const char ** argv) {
4632	return 0;	return 0;
4633	}	}
4634
4635		if (grubConfig == NULL) {
4636		printf("Could not find bootloader configuration file.\n");
4637		exit(1);
4638		}
4639
4640	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4641	if (!config) return 1;	if (!config) return 1;
4642
#	Line 4078  int main(int argc, const char ** argv) {	Line 4646  int main(int argc, const char ** argv) {
4646	char * rootspec;	char * rootspec;
4647
4648	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4649		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4650		cfi->defaultIsSaved)
4651		config->defaultImage = 0;
4652	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4653	if (!entry) return 0;	if (!entry) return 0;
4654	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4655
4656	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4657	if (!line) return 0;	if (!line) return 0;
4658
4659	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 4096  int main(int argc, const char ** argv) {	Line 4667  int main(int argc, const char ** argv) {
4667	struct singleEntry * entry;	struct singleEntry * entry;
4668
4669	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4670		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4671		cfi->defaultIsSaved)
4672		config->defaultImage = 0;
4673	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4674	if (!entry) return 0;	if (!entry) return 0;
4675
#	Line 4118  int main(int argc, const char ** argv) {	Line 4692  int main(int argc, const char ** argv) {
4692
4693	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4694	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4695		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4696		cfi->defaultIsSaved)
4697		config->defaultImage = 0;
4698	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4699		return 0;
4700
4701	} else if (kernelInfo)	} else if (kernelInfo)
4702	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 4131  int main(int argc, const char ** argv) {	Line 4709  int main(int argc, const char ** argv) {
4709	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4710	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4711	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4712	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4713	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4714	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4715	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4716	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4717	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4718	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4719		bootPrefix, newKernelInitrd,
4720		newKernelTitle))
4721		return 1;
4722		} else {
4723		if (updateInitrd(config, updateKernelPath, bootPrefix,
4724		newKernelInitrd, newKernelTitle))
4725		return 1;
4726		}
4727	}	}
4728	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4729	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4730	(const char **)extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4731	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4732
4733
4734	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {

---

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

Legend: Removed from v.1854   changed lines   Added in v.2989