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

Parent Directory | Revision Log | Patch

	revision 1714 by niro, Sat Feb 18 00:32:14 2012 UTC	revision 2977 by niro, Thu Jun 30 10:24:27 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 46	Line 48
48	#define dbgPrintf(format, args...)	#define dbgPrintf(format, args...)
49	#endif	#endif
50
51		int debug = 0; /* Currently just for template debugging */
52
53	#define _(A) (A)	#define _(A) (A)
54
55	#define MAX_EXTRA_INITRDS  16 /* code segment checked by --bootloader-probe */	#define MAX_EXTRA_INITRDS  16 /* code segment checked by --bootloader-probe */
56	#define CODE_SEG_SIZE  128 /* code segment checked by --bootloader-probe */	#define CODE_SEG_SIZE  128 /* code segment checked by --bootloader-probe */
57
58		#define NOOP_OPCODE 0x90
59		#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 77  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 106  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
135		#define DEFAULT_SAVED_GRUB2 -3
136
137	struct keywordTypes {	struct keywordTypes {
138	char * key;	char * key;
#	Line 122  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 142  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 156  struct keywordTypes grubKeywords[] = {	Line 188  struct keywordTypes grubKeywords[] = {
188	{ NULL,    0, 0 },	{ NULL,    0, 0 },
189	};	};
190
191		const char *grubFindConfig(struct configFileInfo *cfi) {
192		static const char *configFiles[] = {
193		"/boot/grub/grub.conf",
194		"/boot/grub/menu.lst",
195		"/etc/grub.conf",
196		"/boot/grub2/grub.cfg",
197		"/boot/grub2-efi/grub.cfg",
198		NULL
199		};
200		static int i = -1;
201
202		if (i == -1) {
203		for (i = 0; configFiles[i] != NULL; i++) {
204		dbgPrintf("Checking \"%s\": ", configFiles[i]);
205		if (!access(configFiles[i], R_OK)) {
206		dbgPrintf("found\n");
207		return configFiles[i];
208		}
209		dbgPrintf("not found\n");
210		}
211		}
212		return configFiles[i];
213		}
214
215	struct configFileInfo grubConfigType = {	struct configFileInfo grubConfigType = {
216	.defaultConfig = "/boot/grub/grub.conf",	.findConfig = grubFindConfig,
217	.keywords = grubKeywords,	.keywords = grubKeywords,
218	.defaultIsIndex = 1,	.defaultIsIndex = 1,
219	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 177  struct keywordTypes grub2Keywords[] = {	Line 233  struct keywordTypes grub2Keywords[] = {
233	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
234	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
235	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
236		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
237		{ "linux16",    LT_KERNEL_16,   ' ' },
238	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
239		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
241	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
242	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
243		{ "devicetree", LT_DEVTREE,  ' ' },
244	{ NULL, 0, 0 },	{ NULL, 0, 0 },
245	};	};
246
#	Line 191  const char *grub2FindConfig(struct confi	Line 252  const char *grub2FindConfig(struct confi
252	};	};
253	static int i = -1;	static int i = -1;
254	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
255		int rc = -1;
256
257	if (i == -1) {	if (i == -1) {
258	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
259	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
260	if (!access(configFiles[i], R_OK)) {	if ((rc = access(configFiles[i], R_OK))) {
261		if (errno == EACCES) {
262		printf("Unable to access bootloader configuration file "
263		"\"%s\": %m\n", configFiles[i]);
264		exit(1);
265		}
266		continue;
267		} else {
268	dbgPrintf("found\n");	dbgPrintf("found\n");
269	return configFiles[i];	return configFiles[i];
270	}	}
#	Line 214  const char *grub2FindConfig(struct confi	Line 283  const char *grub2FindConfig(struct confi
283	return configFiles[i];	return configFiles[i];
284	}	}
285
286		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
287		static char *grub2GetEnv(struct configFileInfo *info, char *name)
288		{
289		static char buf[1025];
290		char *s = NULL;
291		char *ret = NULL;
292		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
293		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
294
295		if (rc < 0)
296		return NULL;
297
298		FILE *f = popen(s, "r");
299		if (!f)
300		goto out;
301
302		memset(buf, '\0', sizeof (buf));
303		ret = fgets(buf, 1024, f);
304		pclose(f);
305
306		if (ret) {
307		ret += strlen(name) + 1;
308		ret[strlen(ret) - 1] = '\0';
309		}
310		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
311		out:
312		free(s);
313		return ret;
314		}
315
316		static int sPopCount(const char *s, const char *c)
317		{
318		int ret = 0;
319		if (!s)
320		return -1;
321		for (int i = 0; s[i] != '\0'; i++)
322		for (int j = 0; c[j] != '\0'; j++)
323		if (s[i] == c[j])
324		ret++;
325		return ret;
326		}
327
328		static char *shellEscape(const char *s)
329		{
330		int l = strlen(s) + sPopCount(s, "'") * 2;
331
332		char *ret = calloc(l+1, sizeof (*ret));
333		if (!ret)
334		return NULL;
335		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
336		if (s[i] == '\'')
337		ret[j++] = '\\';
338		ret[j] = s[i];
339		}
340		return ret;
341		}
342
343		static void unquote(char *s)
344		{
345		int l = strlen(s);
346
347		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
348		memmove(s, s+1, l-2);
349		s[l-2] = '\0';
350		}
351		}
352
353		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
354		{
355		char *s = NULL;
356		int rc = 0;
357		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
358
359		unquote(value);
360		value = shellEscape(value);
361		if (!value)
362		return -1;
363
364		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
365		free(value);
366		if (rc <0)
367		return -1;
368
369		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
370		rc = system(s);
371		free(s);
372		return rc;
373		}
374
375		/* this is a gigantic hack to avoid clobbering grub2 variables... */
376		static int is_special_grub2_variable(const char *name)
377		{
378		if (!strcmp(name,"\"${next_entry}\""))
379		return 1;
380		if (!strcmp(name,"\"${prev_saved_entry}\""))
381		return 1;
382		return 0;
383		}
384
385		int sizeOfSingleLine(struct singleLine * line) {
386		int count = 0;
387
388		for (int i = 0; i < line->numElements; i++) {
389		int indentSize = 0;
390
391		count = count + strlen(line->elements[i].item);
392
393		indentSize = strlen(line->elements[i].indent);
394		if (indentSize > 0)
395		count = count + indentSize;
396		else
397		/* be extra safe and add room for whitespaces */
398		count = count + 1;
399		}
400
401		/* room for trailing terminator */
402		count = count + 1;
403
404		return count;
405		}
406
407		static int isquote(char q)
408		{
409		if (q == '\'' || q == '\"')
410		return 1;
411		return 0;
412		}
413
414		static int iskernel(enum lineType_e type) {
415		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
416		}
417
418		static int isinitrd(enum lineType_e type) {
419		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
420		}
421
422		char *grub2ExtractTitle(struct singleLine * line) {
423		char * current;
424		char * current_indent;
425		int current_len;
426		int current_indent_len;
427		int i;
428
429		/* bail out if line does not start with menuentry */
430		if (strcmp(line->elements[0].item, "menuentry"))
431		return NULL;
432
433		i = 1;
434		current = line->elements[i].item;
435		current_len = strlen(current);
436
437		/* if second word is quoted, strip the quotes and return single word */
438		if (isquote(*current) && isquote(current[current_len - 1])) {
439		char *tmp;
440
441		tmp = strdup(current);
442		*(tmp + current_len - 1) = '\0';
443		return ++tmp;
444		}
445
446		/* if no quotes, return second word verbatim */
447		if (!isquote(*current))
448		return current;
449
450		/* second element start with a quote, so we have to find the element
451		* whose last character is also quote (assuming it's the closing one) */
452		int resultMaxSize;
453		char * result;
454
455		resultMaxSize = sizeOfSingleLine(line);
456		result = malloc(resultMaxSize);
457		snprintf(result, resultMaxSize, "%s", ++current);
458
459		i++;
460		for (; i < line->numElements; ++i) {
461		current = line->elements[i].item;
462		current_len = strlen(current);
463		current_indent = line->elements[i].indent;
464		current_indent_len = strlen(current_indent);
465
466		strncat(result, current_indent, current_indent_len);
467		if (!isquote(current[current_len-1])) {
468		strncat(result, current, current_len);
469		} else {
470		strncat(result, current, current_len - 1);
471		break;
472		}
473		}
474		return result;
475		}
476
477	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
478	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
479		.getEnv = grub2GetEnv,
480		.setEnv = grub2SetEnv,
481	.keywords = grub2Keywords,	.keywords = grub2Keywords,
482	.defaultIsIndex = 1,	.defaultIsIndex = 1,
483	.defaultSupportSaved = 0,	.defaultSupportSaved = 1,
484	.defaultIsVariable = 1,	.defaultIsVariable = 1,
485	.entryStart = LT_MENUENTRY,	.entryStart = LT_MENUENTRY,
486	.entryEnd = LT_ENTRY_END,	.entryEnd = LT_ENTRY_END,
#	Line 320  struct keywordTypes extlinuxKeywords[] =	Line 582  struct keywordTypes extlinuxKeywords[] =
582	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
583	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
584	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
585		{ "fdt",        LT_DEVTREE,     ' ' },
586		{ "fdtdir",     LT_DEVTREE,     ' ' },
587	{ NULL,    0, 0 },	{ NULL,    0, 0 },
588	};	};
589	int useextlinuxmenu;	int useextlinuxmenu;
#	Line 370  struct configFileInfo ziplConfigType = {	Line 634  struct configFileInfo ziplConfigType = {
634	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
635	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
636	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
637		.caseInsensitive = 1,
638	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
639	.needsBootPrefix = 1,	.needsBootPrefix = 1,
640	.maxTitleLength = 255,	.maxTitleLength = 255,
641	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
642		.defaultIsUnquoted = 1,
643	};	};
644
645	struct grubConfig {	struct grubConfig {
#	Line 394  struct singleEntry * findEntryByIndex(st	Line 660  struct singleEntry * findEntryByIndex(st
660	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
661	const char * path, const char * prefix,	const char * path, const char * prefix,
662	int * index);	int * index);
663		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
664		int * index);
665	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
666	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
667	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 458  static char * sdupprintf(const char *for	Line 726  static char * sdupprintf(const char *for
726	return buf;	return buf;
727	}	}
728
729		static enum lineType_e preferredLineType(enum lineType_e type,
730		struct configFileInfo *cfi) {
731		if (isEfi && cfi == &grub2ConfigType) {
732		switch (type) {
733		case LT_KERNEL:
734		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
735		case LT_INITRD:
736		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
737		default:
738		return type;
739		}
740		#if defined(__i386__) || defined(__x86_64__)
741		} else if (cfi == &grub2ConfigType) {
742		switch (type) {
743		case LT_KERNEL:
744		return LT_KERNEL_16;
745		case LT_INITRD:
746		return LT_INITRD_16;
747		default:
748		return type;
749		}
750		#endif
751		}
752		return type;
753		}
754
755	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
756	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
757	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
758	if (kw->type == type)	if (kw->type == type)
759	return kw;	return kw;
760	}	}
#	Line 491  static char * getuuidbydev(char *device)	Line 784  static char * getuuidbydev(char *device)
784
785	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
786	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
787	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
788	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
789	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
790	return kw->type;	return kw->type;
791		} else {
792		if (!strcmp(keyword, kw->key))
793		return kw->type;
794		}
795	}	}
796	return LT_UNKNOWN;	return LT_UNKNOWN;
797	}	}
#	Line 532  static int isEntryStart(struct singleLin	Line 829  static int isEntryStart(struct singleLin
829
830	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
831	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
832	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it */
833	char * title;	char * title = NULL;
834	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
835	title++;	title = strdup(line->elements[0].item + 1);
836	*(title + strlen(title) - 1) = '\0';	*(title + strlen(title) - 1) = '\0';
837		} else if (line->type == LT_MENUENTRY)
838		title = strdup(line->elements[1].item);
839		else
840		return NULL;
841	return title;	return title;
842	}	}
843
#	Line 579  static void lineInit(struct singleLine *	Line 880  static void lineInit(struct singleLine *
880	}	}
881
882	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
883	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
884
885	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 589  struct singleLine * lineDup(struct singl	Line 889  struct singleLine * lineDup(struct singl
889	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
890	newLine->numElements);	newLine->numElements);
891
892	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
893	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
894	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
895	}	}
#	Line 598  struct singleLine * lineDup(struct singl	Line 898  struct singleLine * lineDup(struct singl
898	}	}
899
900	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
901	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
902
903	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
904	free(line->elements[i].item);	free(line->elements[i].item);
905	free(line->elements[i].indent);	free(line->elements[i].indent);
906	}	}
#	Line 613  static void lineFree(struct singleLine *	Line 911  static void lineFree(struct singleLine *
911
912	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
913	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
914	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
915
916	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
917		/* Need to handle this, because we strip the quotes from
918		* menuentry when read it. */
919		if (line->type == LT_MENUENTRY && i == 1) {
920		if(!isquote(*line->elements[i].item))
921		fprintf(out, "\'%s\'", line->elements[i].item);
922		else
923		fprintf(out, "%s", line->elements[i].item);
924		fprintf(out, "%s", line->elements[i].indent);
925
926		continue;
927		}
928
929	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
930	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
931
#	Line 711  static int getNextLine(char ** bufPtr, s	Line 1019  static int getNextLine(char ** bufPtr, s
1019	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1020	char * fullLine;	char * fullLine;
1021	int len;	int len;
	int i;
1022
1023	len = strlen(line->indent);	len = strlen(line->indent);
1024	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1025	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1026	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1027
#	Line 723  static int getNextLine(char ** bufPtr, s	Line 1030  static int getNextLine(char ** bufPtr, s
1030	free(line->indent);	free(line->indent);
1031	line->indent = fullLine;	line->indent = fullLine;
1032
1033	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1034	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1035	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1036	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 742  static int getNextLine(char ** bufPtr, s	Line 1049  static int getNextLine(char ** bufPtr, s
1049	* elements up more	* elements up more
1050	*/	*/
1051	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1052	char indent[2] = "";	char indent[2] = "";
1053	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1054	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1055	char *p;	char *p;
	int j;
1056	int numNewElements;	int numNewElements;
1057
1058	numNewElements = 0;	numNewElements = 0;
#	Line 763  static int getNextLine(char ** bufPtr, s	Line 1068  static int getNextLine(char ** bufPtr, s
1068	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1069	}	}
1070
1071	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1072	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1073	}	}
1074	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 776  static int getNextLine(char ** bufPtr, s	Line 1081  static int getNextLine(char ** bufPtr, s
1081	break;	break;
1082	}	}
1083
1084	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1085	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1086	*p++ = '\0';	*p++ = '\0';
1087	i++;	i++;
1088	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1089	}	}
1090	}	}
1091	}	}
#	Line 792  static int getNextLine(char ** bufPtr, s	Line 1095  static int getNextLine(char ** bufPtr, s
1095	return 0;	return 0;
1096	}	}
1097
1098		static int isnumber(const char *s)
1099		{
1100		int i;
1101		for (i = 0; s[i] != '\0'; i++)
1102		if (s[i] < '0' || s[i] > '9')
1103		return 0;
1104		return i;
1105		}
1106
1107	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1108	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1109	int in;	int in;
#	Line 803  static struct grubConfig * readConfig(co	Line 1115  static struct grubConfig * readConfig(co
1115	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1116	char * end;	char * end;
1117	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1118	int i, len;	int len;
1119	char * buf;	char * buf;
1120
1121	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1122		printf("Could not find bootloader configuration\n");
1123		exit(1);
1124		} else if (!strcmp(inName, "-")) {
1125	in = 0;	in = 0;
1126	} else {	} else {
1127	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 849  static struct grubConfig * readConfig(co	Line 1164  static struct grubConfig * readConfig(co
1164	cfg->secondaryIndent = strdup(line->indent);	cfg->secondaryIndent = strdup(line->indent);
1165	}	}
1166
1167	if (isEntryStart(line, cfi)) {	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1168	sawEntry = 1;	sawEntry = 1;
1169	if (!entry) {	if (!entry) {
1170	cfg->entries = malloc(sizeof(*entry));	cfg->entries = malloc(sizeof(*entry));
#	Line 866  static struct grubConfig * readConfig(co	Line 1181  static struct grubConfig * readConfig(co
1181	}	}
1182
1183	if (line->type == LT_SET_VARIABLE) {	if (line->type == LT_SET_VARIABLE) {
	int i;
1184	dbgPrintf("found 'set' command (%d elements): ", line->numElements);	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1185	dbgPrintf("%s", line->indent);	dbgPrintf("%s", line->indent);
1186	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1187	dbgPrintf("%s\"%s\"", line->elements[i].indent, line->elements[i].item);	dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1188	dbgPrintf("\n");	dbgPrintf("\n");
1189	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1190	if (kwType && line->numElements == 3 &&	if (kwType && line->numElements == 3 &&
1191	!strcmp(line->elements[1].item, kwType->key)) {	!strcmp(line->elements[1].item, kwType->key) &&
1192		!is_special_grub2_variable(line->elements[2].item)) {
1193	dbgPrintf("Line sets default config\n");	dbgPrintf("Line sets default config\n");
1194	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1195	defaultLine = line;	defaultLine = line;
1196	}	}
	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
1197
1198	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1199	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1200	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1201	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1202	*/	*/
1203	if (entry->multiboot)	if (entry && entry->multiboot)
1204	line->type = LT_HYPER;	line->type = LT_HYPER;
1205
1206	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 897  static struct grubConfig * readConfig(co	Line 1209  static struct grubConfig * readConfig(co
1209	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1210	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1211	*/	*/
1212	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1213	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1214	break;	break;
1215	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1216	l->type = LT_HYPER;	l->type = LT_HYPER;
1217	break;	break;
1218	}	}
#	Line 915  static struct grubConfig * readConfig(co	Line 1226  static struct grubConfig * readConfig(co
1226	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1227	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1228
1229	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1230	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1231		/* make the title/default a single argument (undoing our parsing) */
1232	len = 0;	len = 0;
1233	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1234	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1235	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1236	}	}
1237	buf = malloc(len + 1);	buf = malloc(len + 1);
1238	*buf = '\0';	*buf = '\0';
1239
1240	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1241	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1242	free(line->elements[i].item);	free(line->elements[i].item);
1243
#	Line 939  static struct grubConfig * readConfig(co	Line 1251  static struct grubConfig * readConfig(co
1251	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1252	line->elements[1].item = buf;	line->elements[1].item = buf;
1253	line->numElements = 2;	line->numElements = 2;
1254		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1255		/* let --remove-kernel="TITLE=what" work */
1256		len = 0;
1257		char *extras;
1258		char *title;
1259
1260		for (int i = 1; i < line->numElements; i++) {
1261		len += strlen(line->elements[i].item);
1262		len += strlen(line->elements[i].indent);
1263		}
1264		buf = malloc(len + 1);
1265		*buf = '\0';
1266
1267		/* allocate mem for extra flags. */
1268		extras = malloc(len + 1);
1269		*extras = '\0';
1270
1271		/* get title. */
1272		for (int i = 0; i < line->numElements; i++) {
1273		if (!strcmp(line->elements[i].item, "menuentry"))
1274		continue;
1275		if (isquote(*line->elements[i].item))
1276		title = line->elements[i].item + 1;
1277		else
1278		title = line->elements[i].item;
1279
1280		len = strlen(title);
1281		if (isquote(title[len-1])) {
1282		strncat(buf, title,len-1);
1283		break;
1284		} else {
1285		strcat(buf, title);
1286		strcat(buf, line->elements[i].indent);
1287		}
1288		}
1289
1290		/* get extras */
1291		int count = 0;
1292		for (int i = 0; i < line->numElements; i++) {
1293		if (count >= 2) {
1294		strcat(extras, line->elements[i].item);
1295		strcat(extras, line->elements[i].indent);
1296		}
1297
1298		if (!strcmp(line->elements[i].item, "menuentry"))
1299		continue;
1300
1301		/* count ' or ", there should be two in menuentry line. */
1302		if (isquote(*line->elements[i].item))
1303		count++;
1304
1305		len = strlen(line->elements[i].item);
1306
1307		if (isquote(line->elements[i].item[len -1]))
1308		count++;
1309
1310		/* ok, we get the final ' or ", others are extras. */
1311		}
1312		line->elements[1].indent =
1313		line->elements[line->numElements - 2].indent;
1314		line->elements[1].item = buf;
1315		line->elements[2].indent =
1316		line->elements[line->numElements - 2].indent;
1317		line->elements[2].item = extras;
1318		line->numElements = 3;
1319	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1320	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1321	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 948  static struct grubConfig * readConfig(co	Line 1324  static struct grubConfig * readConfig(co
1324	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1325	int last, len;	int last, len;
1326
1327	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1328	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1329	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1330
1331	last = line->numElements - 1;	last = line->numElements - 1;
1332	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1333	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1334	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1335	}	}
1336	}	}
1337
1338		if (line->type == LT_DEFAULT && line->numElements == 2) {
1339		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1340		defaultLine = line;
1341		}
1342
1343	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1344	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1345	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 1013  static struct grubConfig * readConfig(co	Line 1394  static struct grubConfig * readConfig(co
1394
1395	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1396	if (defaultLine) {	if (defaultLine) {
1397	if (cfi->defaultIsVariable) {	if (defaultLine->numElements > 2 &&
1398		cfi->defaultSupportSaved &&
1399		!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1400		cfg->cfi->defaultIsSaved = 1;
1401		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1402		if (cfg->cfi->getEnv) {
1403		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1404		if (defTitle) {
1405		int index = 0;
1406		if (isnumber(defTitle)) {
1407		index = atoi(defTitle);
1408		entry = findEntryByIndex(cfg, index);
1409		} else {
1410		entry = findEntryByTitle(cfg, defTitle, &index);
1411		}
1412		if (entry)
1413		cfg->defaultImage = index;
1414		}
1415		}
1416		} else if (cfi->defaultIsVariable) {
1417	char *value = defaultLine->elements[2].item;	char *value = defaultLine->elements[2].item;
1418	while (*value && (*value == '"' || *value == '\'' ||	while (*value && (*value == '"' || *value == '\'' ||
1419	*value == ' ' || *value == '\t'))	*value == ' ' || *value == '\t'))
#	Line 1030  static struct grubConfig * readConfig(co	Line 1430  static struct grubConfig * readConfig(co
1430	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1431	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1432	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1433	i = 0;	int i = 0;
1434	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1435	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1436	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 1053  static struct grubConfig * readConfig(co	Line 1453  static struct grubConfig * readConfig(co
1453	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1454	}	}
1455	}	}
1456		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1457		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1458		if (defTitle) {
1459		int index = 0;
1460		if (isnumber(defTitle)) {
1461		index = atoi(defTitle);
1462		entry = findEntryByIndex(cfg, index);
1463		} else {
1464		entry = findEntryByTitle(cfg, defTitle, &index);
1465		}
1466		if (entry)
1467		cfg->defaultImage = index;
1468		}
1469	} else {	} else {
1470	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1471	}	}
#	Line 1070  static void writeDefault(FILE * out, cha	Line 1483  static void writeDefault(FILE * out, cha
1483
1484	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1485	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1486	else if (cfg->defaultImage > -1) {	else if (cfg->cfi->defaultIsSaved) {
1487		fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1488		if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1489		char *title;
1490		entry = findEntryByIndex(cfg, cfg->defaultImage);
1491		line = getLineByType(LT_MENUENTRY, entry->lines);
1492		if (!line)
1493		line = getLineByType(LT_TITLE, entry->lines);
1494		if (line) {
1495		title = extractTitle(line);
1496		if (title)
1497		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1498		}
1499		}
1500		} else if (cfg->defaultImage > -1) {
1501	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1502	if (cfg->cfi->defaultIsVariable) {	if (cfg->cfi->defaultIsVariable) {
1503	fprintf(out, "%sset default=\"%d\"\n", indent,	fprintf(out, "%sset default=\"%d\"\n", indent,
#	Line 1130  static int writeConfig(struct grubConfig	Line 1557  static int writeConfig(struct grubConfig
1557
1558	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1559	directory to the dir of the symlink */	directory to the dir of the symlink */
1560	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1561		rc = chdir(dirname(dir));
1562	do {	do {
1563	buf = alloca(len + 1);	buf = alloca(len + 1);
1564	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1172  static int writeConfig(struct grubConfig	Line 1600  static int writeConfig(struct grubConfig
1600	while (line) {	while (line) {
1601	if (line->type == LT_SET_VARIABLE && defaultKw &&	if (line->type == LT_SET_VARIABLE && defaultKw &&
1602	line->numElements == 3 &&	line->numElements == 3 &&
1603	!strcmp(line->elements[1].item, defaultKw->key)) {	!strcmp(line->elements[1].item, defaultKw->key) &&
1604		!is_special_grub2_variable(line->elements[2].item)) {
1605	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1606	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1607	} else if (line->type == LT_DEFAULT) {	} else if (line->type == LT_DEFAULT) {
#	Line 1268  static char *findDiskForRoot()	Line 1697  static char *findDiskForRoot()
1697	buf[rc] = '\0';	buf[rc] = '\0';
1698	chptr = buf;	chptr = buf;
1699
1700		char *foundanswer = NULL;
1701
1702	while (chptr && chptr != buf+rc) {	while (chptr && chptr != buf+rc) {
1703	devname = chptr;	devname = chptr;
1704
#	Line 1295  static char *findDiskForRoot()	Line 1726  static char *findDiskForRoot()
1726	* for '/' obviously.	* for '/' obviously.
1727	*/	*/
1728	if (*(++chptr) == '/' && *(++chptr) == ' ') {	if (*(++chptr) == '/' && *(++chptr) == ' ') {
1729	/*	/* remember the last / entry in mtab */
1730	* 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);
1731	}	}
1732
1733	/* Next line */	/* Next line */
#	Line 1310  static char *findDiskForRoot()	Line 1736  static char *findDiskForRoot()
1736	chptr++;	chptr++;
1737	}	}
1738
1739		/* Return the last / entry found */
1740		if (foundanswer) {
1741		chptr = strchr(foundanswer, ' ');
1742		*chptr = '\0';
1743		return strdup(foundanswer);
1744		}
1745
1746	return NULL;	return NULL;
1747	}	}
1748
1749		void printEntry(struct singleEntry * entry, FILE *f) {
1750		int i;
1751		struct singleLine * line;
1752
1753		for (line = entry->lines; line; line = line->next) {
1754		log_message(f, "DBG: %s", line->indent);
1755		for (i = 0; i < line->numElements; i++) {
1756		/* Need to handle this, because we strip the quotes from
1757		* menuentry when read it. */
1758		if (line->type == LT_MENUENTRY && i == 1) {
1759		if(!isquote(*line->elements[i].item))
1760		log_message(f, "\'%s\'", line->elements[i].item);
1761		else
1762		log_message(f, "%s", line->elements[i].item);
1763		log_message(f, "%s", line->elements[i].indent);
1764
1765		continue;
1766		}
1767
1768		log_message(f, "%s%s",
1769		line->elements[i].item, line->elements[i].indent);
1770		}
1771		log_message(f, "\n");
1772		}
1773		}
1774
1775		void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1776		{
1777		static int once;
1778		va_list argp, argq;
1779
1780		va_start(argp, fmt);
1781
1782		va_copy(argq, argp);
1783		if (!once) {
1784		log_time(NULL);
1785		log_message(NULL, "command line: %s\n", saved_command_line);
1786		}
1787		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1788		log_vmessage(NULL, fmt, argq);
1789
1790		printEntry(entry, NULL);
1791		va_end(argq);
1792
1793		if (!debug) {
1794		once = 1;
1795		va_end(argp);
1796		return;
1797		}
1798
1799		if (okay) {
1800		va_end(argp);
1801		return;
1802		}
1803
1804		if (!once)
1805		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1806		once = 1;
1807		fprintf(stderr, "DBG: Image entry failed: ");
1808		vfprintf(stderr, fmt, argp);
1809		printEntry(entry, stderr);
1810		va_end(argp);
1811		}
1812
1813		#define beginswith(s, c) ((s) && (s)[0] == (c))
1814
1815		static int endswith(const char *s, char c)
1816		{
1817		int slen;
1818
1819		if (!s || !s[0])
1820		return 0;
1821		slen = strlen(s) - 1;
1822
1823		return s[slen] == c;
1824		}
1825
1826	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1827	int skipRemoved, int flags) {	int skipRemoved, int flags) {
1828	struct singleLine * line;	struct singleLine * line;
#	Line 1322  int suitableImage(struct singleEntry * e	Line 1832  int suitableImage(struct singleEntry * e
1832	char * rootspec;	char * rootspec;
1833	char * rootdev;	char * rootdev;
1834
1835	if (skipRemoved && entry->skip) return 0;	if (skipRemoved && entry->skip) {
1836		notSuitablePrintf(entry, 0, "marked to skip\n");
1837		return 0;
1838		}
1839
1840	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1841	if (!line || line->numElements < 2) return 0;	if (!line) {
1842		notSuitablePrintf(entry, 0, "no line found\n");
1843		return 0;
1844		}
1845		if (line->numElements < 2) {
1846		notSuitablePrintf(entry, 0, "line has only %d elements\n",
1847		line->numElements);
1848		return 0;
1849		}
1850
1851	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1852		notSuitablePrintf(entry, 1, "\n");
1853		return 1;
1854		}
1855
1856	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1857	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
1858	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
1859	sprintf(fullName, "%s%s", bootPrefix,	int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1860	line->elements[1].item + (rootspec ? strlen(rootspec) : 0));	int hasslash = endswith(bootPrefix, '/') ||
1861	if (access(fullName, R_OK)) return 0;	beginswith(line->elements[1].item + rootspec_offset, '/');
1862		sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1863		line->elements[1].item + rootspec_offset);
1864		if (access(fullName, R_OK)) {
1865		notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1866		return 0;
1867		}
1868	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
1869	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1870	if (i < line->numElements) {	if (i < line->numElements) {
#	Line 1353  int suitableImage(struct singleEntry * e	Line 1882  int suitableImage(struct singleEntry * e
1882	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
1883
1884	/* failed to find one */	/* failed to find one */
1885	if (!line) return 0;	if (!line) {
1886		notSuitablePrintf(entry, 0, "no line found\n");
1887		return 0;
1888		}
1889
1890	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
1891	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1892	if (i < line->numElements)	if (i < line->numElements)
1893	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1894	else {	else {
1895		notSuitablePrintf(entry, 0, "no root= entry found\n");
1896	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1897	return 0;	return 0;
1898	}	}
#	Line 1367  int suitableImage(struct singleEntry * e	Line 1900  int suitableImage(struct singleEntry * e
1900	}	}
1901
1902	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1903	if (!dev)	if (!getpathbyspec(dev)) {
1904		notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1905	return 0;	return 0;
1906		} else
1907		dev = getpathbyspec(dev);
1908
1909	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1910	if (!rootdev)	if (!rootdev) {
1911		notSuitablePrintf(entry, 0, "can't find root device\n");
1912	return 0;	return 0;
1913		}
1914
1915	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1916		notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1917		getuuidbydev(rootdev), getuuidbydev(dev));
1918	free(rootdev);	free(rootdev);
1919	return 0;	return 0;
1920	}	}
1921
1922	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1923		notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1924		getuuidbydev(rootdev), getuuidbydev(dev));
1925	free(rootdev);	free(rootdev);
1926	return 0;	return 0;
1927	}	}
1928
1929	free(rootdev);	free(rootdev);
1930		notSuitablePrintf(entry, 1, "\n");
1931
1932	return 1;	return 1;
1933	}	}
#	Line 1418  struct singleEntry * findEntryByPath(str	Line 1961  struct singleEntry * findEntryByPath(str
1961	}	}
1962
1963	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
1964
1965	i = 0;	i = 0;
1966	if (index) {	if (index) {
1967	while (i < *index) i++;	while (i < *index) {
1968	if (indexVars[i] == -1) return NULL;	i++;
1969		if (indexVars[i] == -1) return NULL;
1970		}
1971	}	}
1972
1973	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1974	if (!entry) return NULL;	if (!entry) return NULL;
1975
1976	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1977	if (!line) return NULL;	if (!line) return NULL;
1978
1979	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1466  struct singleEntry * findEntryByPath(str	Line 2011  struct singleEntry * findEntryByPath(str
2011
2012	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2013	prefix = "";	prefix = "";
2014	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2015	kernel += 6;	kernel += 6;
2016	}	}
2017
#	Line 1477  struct singleEntry * findEntryByPath(str	Line 2022  struct singleEntry * findEntryByPath(str
2022
2023	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2024	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2025	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2026	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2027	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2028	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2029		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2030		line = getLineByType(ct, line);
2031		if (!line)
2032		break;  /* not found in this entry */
2033
2034	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2035		line->numElements >= 2) {
2036	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2037	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2038	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2039	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2040	break;	break;
2041	}	}
2042		if(line->type == LT_MENUENTRY &&
2043		!strcmp(line->elements[1].item, kernel))
2044		break;
2045	}	}
2046
2047	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2048	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2049	* unfortunate)	* unfortunate)
2050	*/	*/
2051	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2052	break; /* found 'im! */	break; /* found 'im! */
2053	}	}
2054
#	Line 1505  struct singleEntry * findEntryByPath(str	Line 2058  struct singleEntry * findEntryByPath(str
2058	return entry;	return entry;
2059	}	}
2060
2061		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2062		int * index) {
2063		struct singleEntry * entry;
2064		struct singleLine * line;
2065		int i;
2066		char * newtitle;
2067
2068		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2069		if (index && i < *index)
2070		continue;
2071		line = getLineByType(LT_TITLE, entry->lines);
2072		if (!line)
2073		line = getLineByType(LT_MENUENTRY, entry->lines);
2074		if (!line)
2075		continue;
2076		newtitle = grub2ExtractTitle(line);
2077		if (!newtitle)
2078		continue;
2079		if (!strcmp(title, newtitle))
2080		break;
2081		}
2082
2083		if (!entry)
2084		return NULL;
2085
2086		if (index)
2087		*index = i;
2088		return entry;
2089		}
2090
2091	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2092	struct singleEntry * entry;	struct singleEntry * entry;
2093
#	Line 1527  struct singleEntry * findTemplate(struct	Line 2110  struct singleEntry * findTemplate(struct
2110	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2111	int index;	int index;
2112
2113	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2114		if (cfg->cfi->getEnv) {
2115		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2116		if (defTitle) {
2117		int index = 0;
2118		if (isnumber(defTitle)) {
2119		index = atoi(defTitle);
2120		entry = findEntryByIndex(cfg, index);
2121		} else {
2122		entry = findEntryByTitle(cfg, defTitle, &index);
2123		}
2124		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2125		cfg->defaultImage = index;
2126		if (indexPtr)
2127		*indexPtr = index;
2128		return entry;
2129		}
2130		}
2131		}
2132		} else if (cfg->defaultImage > -1) {
2133	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2134	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2135	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1580  void markRemovedImage(struct grubConfig	Line 2182  void markRemovedImage(struct grubConfig
2182	const char * prefix) {	const char * prefix) {
2183	struct singleEntry * entry;	struct singleEntry * entry;
2184
2185	if (!image) return;	if (!image)
2186		return;
2187
2188		/* check and see if we're removing the default image */
2189		if (isdigit(*image)) {
2190		entry = findEntryByPath(cfg, image, prefix, NULL);
2191		if(entry)
2192		entry->skip = 1;
2193		return;
2194		}
2195
2196	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2197	entry->skip = 1;	entry->skip = 1;
#	Line 1588  void markRemovedImage(struct grubConfig	Line 2199  void markRemovedImage(struct grubConfig
2199
2200	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2201	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2202	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2203	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2204	int i, j;	int i, j;
2205
2206	if (newIsDefault) {	if (newIsDefault) {
2207	config->defaultImage = 0;	config->defaultImage = 0;
2208	return;	return;
2209		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2210		if (findEntryByIndex(config, index))
2211		config->defaultImage = index;
2212		else
2213		config->defaultImage = -1;
2214		return;
2215	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2216	i = 0;	i = 0;
2217	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1607  void setDefaultImage(struct grubConfig *	Line 2224  void setDefaultImage(struct grubConfig *
2224
2225	/* defaultImage now points to what we'd like to use, but before any order	/* defaultImage now points to what we'd like to use, but before any order
2226	changes */	changes */
2227	if (config->defaultImage == DEFAULT_SAVED)	if ((config->defaultImage == DEFAULT_SAVED) ||
2228		(config->defaultImage == DEFAULT_SAVED_GRUB2))
2229	/* default is set to saved, we don't want to change it */	/* default is set to saved, we don't want to change it */
2230	return;	return;
2231
#	Line 1665  void displayEntry(struct singleEntry * e	Line 2283  void displayEntry(struct singleEntry * e
2283	struct singleLine * line;	struct singleLine * line;
2284	char * root = NULL;	char * root = NULL;
2285	int i;	int i;
2286		int j;
2287
2288	printf("index=%d\n", index);	printf("index=%d\n", index);
2289
2290	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2291	if (!line) {	if (!line) {
2292	printf("non linux entry\n");	printf("non linux entry\n");
2293	return;	return;
2294	}	}
2295
2296	printf("kernel=%s\n", line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2297		printf("kernel=%s\n", line->elements[1].item);
2298		else
2299		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2300
2301	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2302	printf("args=\"");	printf("args=\"");
#	Line 1730  void displayEntry(struct singleEntry * e	Line 2352  void displayEntry(struct singleEntry * e
2352	printf("root=%s\n", s);	printf("root=%s\n", s);
2353	}	}
2354
2355	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2356
2357	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2358	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2359		printf("initrd=");
2360		else
2361		printf("initrd=%s", prefix);
2362
2363	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2364	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2365	printf("\n");	printf("\n");
2366	}	}
2367
2368		line = getLineByType(LT_TITLE, entry->lines);
2369		if (line) {
2370		printf("title=%s\n", line->elements[1].item);
2371		} else {
2372		char * title;
2373		line = getLineByType(LT_MENUENTRY, entry->lines);
2374		if (line) {
2375		title = grub2ExtractTitle(line);
2376		if (title)
2377		printf("title=%s\n", title);
2378		}
2379		}
2380
2381		for (j = 0, line = entry->lines; line; line = line->next) {
2382		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2383		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2384		printf("mbmodule%d=", j);
2385		else
2386		printf("mbmodule%d=%s", j, prefix);
2387
2388		for (i = 1; i < line->numElements; i++)
2389		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2390		printf("\n");
2391		j++;
2392		}
2393		}
2394		}
2395
2396		int isSuseSystem(void) {
2397		const char * path;
2398		const static char default_path[] = "/etc/SuSE-release";
2399
2400		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2401		path = default_path;
2402
2403		if (!access(path, R_OK))
2404		return 1;
2405		return 0;
2406		}
2407
2408		int isSuseGrubConf(const char * path) {
2409		FILE * grubConf;
2410		char * line = NULL;
2411		size_t len = 0, res = 0;
2412
2413		grubConf = fopen(path, "r");
2414		if (!grubConf) {
2415		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2416		return 0;
2417		}
2418
2419		while ((res = getline(&line, &len, grubConf)) != -1) {
2420		if (!strncmp(line, "setup", 5)) {
2421		fclose(grubConf);
2422		free(line);
2423		return 1;
2424		}
2425		}
2426
2427		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2428		path);
2429
2430		fclose(grubConf);
2431		free(line);
2432		return 0;
2433		}
2434
2435		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2436		FILE * grubConf;
2437		char * line = NULL;
2438		size_t res = 0, len = 0;
2439
2440		if (!path) return 1;
2441		if (!lbaPtr) return 1;
2442
2443		grubConf = fopen(path, "r");
2444		if (!grubConf) return 1;
2445
2446		while ((res = getline(&line, &len, grubConf)) != -1) {
2447		if (line[res - 1] == '\n')
2448		line[res - 1] = '\0';
2449		else if (len > res)
2450		line[res] = '\0';
2451		else {
2452		line = realloc(line, res + 1);
2453		line[res] = '\0';
2454		}
2455
2456		if (!strncmp(line, "setup", 5)) {
2457		if (strstr(line, "--force-lba")) {
2458		*lbaPtr = 1;
2459		} else {
2460		*lbaPtr = 0;
2461		}
2462		dbgPrintf("lba: %i\n", *lbaPtr);
2463		break;
2464		}
2465		}
2466
2467		free(line);
2468		fclose(grubConf);
2469		return 0;
2470		}
2471
2472		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2473		FILE * grubConf;
2474		char * line = NULL;
2475		size_t res = 0, len = 0;
2476		char * lastParamPtr = NULL;
2477		char * secLastParamPtr = NULL;
2478		char installDeviceNumber = '\0';
2479		char * bounds = NULL;
2480
2481		if (!path) return 1;
2482		if (!devicePtr) return 1;
2483
2484		grubConf = fopen(path, "r");
2485		if (!grubConf) return 1;
2486
2487		while ((res = getline(&line, &len, grubConf)) != -1) {
2488		if (strncmp(line, "setup", 5))
2489		continue;
2490
2491		if (line[res - 1] == '\n')
2492		line[res - 1] = '\0';
2493		else if (len > res)
2494		line[res] = '\0';
2495		else {
2496		line = realloc(line, res + 1);
2497		line[res] = '\0';
2498		}
2499
2500		lastParamPtr = bounds = line + res;
2501
2502		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2503		while (!isspace(*lastParamPtr))
2504		lastParamPtr--;
2505		lastParamPtr++;
2506
2507		secLastParamPtr = lastParamPtr - 2;
2508		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2509
2510		if (lastParamPtr + 3 > bounds) {
2511		dbgPrintf("lastParamPtr going over boundary");
2512		fclose(grubConf);
2513		free(line);
2514		return 1;
2515		}
2516		if (!strncmp(lastParamPtr, "(hd", 3))
2517		lastParamPtr += 3;
2518		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2519
2520		/*
2521		* Second last parameter will decide wether last parameter is
2522		* an IMAGE_DEVICE or INSTALL_DEVICE
2523		*/
2524		while (!isspace(*secLastParamPtr))
2525		secLastParamPtr--;
2526		secLastParamPtr++;
2527
2528		if (secLastParamPtr + 3 > bounds) {
2529		dbgPrintf("secLastParamPtr going over boundary");
2530		fclose(grubConf);
2531		free(line);
2532		return 1;
2533		}
2534		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2535		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2536		secLastParamPtr += 3;
2537		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2538		installDeviceNumber = *secLastParamPtr;
2539		} else {
2540		installDeviceNumber = *lastParamPtr;
2541		}
2542
2543		*devicePtr = malloc(6);
2544		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2545		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2546		fclose(grubConf);
2547		free(line);
2548		return 0;
2549		}
2550
2551		free(line);
2552		fclose(grubConf);
2553		return 1;
2554		}
2555
2556		int grubGetBootFromDeviceMap(const char * device,
2557		char ** bootPtr) {
2558		FILE * deviceMap;
2559		char * line = NULL;
2560		size_t res = 0, len = 0;
2561		char * devicePtr;
2562		char * bounds = NULL;
2563		const char * path;
2564		const static char default_path[] = "/boot/grub/device.map";
2565
2566		if (!device) return 1;
2567		if (!bootPtr) return 1;
2568
2569		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2570		path = default_path;
2571
2572		dbgPrintf("opening grub device.map file from: %s\n", path);
2573		deviceMap = fopen(path, "r");
2574		if (!deviceMap)
2575		return 1;
2576
2577		while ((res = getline(&line, &len, deviceMap)) != -1) {
2578		if (!strncmp(line, "#", 1))
2579		continue;
2580
2581		if (line[res - 1] == '\n')
2582		line[res - 1] = '\0';
2583		else if (len > res)
2584		line[res] = '\0';
2585		else {
2586		line = realloc(line, res + 1);
2587		line[res] = '\0';
2588		}
2589
2590		devicePtr = line;
2591		bounds = line + res;
2592
2593		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2594		devicePtr++;
2595		dbgPrintf("device: %s\n", devicePtr);
2596
2597		if (!strncmp(devicePtr, device, strlen(device))) {
2598		devicePtr += strlen(device);
2599		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2600		devicePtr++;
2601
2602		*bootPtr = strdup(devicePtr);
2603		break;
2604		}
2605		}
2606
2607		free(line);
2608		fclose(deviceMap);
2609		return 0;
2610		}
2611
2612		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2613		char * grubDevice;
2614
2615		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2616		dbgPrintf("error looking for grub installation device\n");
2617		else
2618		dbgPrintf("grubby installation device: %s\n", grubDevice);
2619
2620		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2621		dbgPrintf("error looking for grub boot device\n");
2622		else
2623		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2624
2625		free(grubDevice);
2626		return 0;
2627		}
2628
2629		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2630		/*
2631		* This SuSE grub configuration file at this location is not your average
2632		* grub configuration file, but instead the grub commands used to setup
2633		* grub on that system.
2634		*/
2635		const char * path;
2636		const static char default_path[] = "/etc/grub.conf";
2637
2638		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2639		path = default_path;
2640
2641		if (!isSuseGrubConf(path)) return 1;
2642
2643		if (lbaPtr) {
2644		*lbaPtr = 0;
2645		if (suseGrubConfGetLba(path, lbaPtr))
2646		return 1;
2647		}
2648
2649		if (bootPtr) {
2650		*bootPtr = NULL;
2651		suseGrubConfGetBoot(path, bootPtr);
2652		}
2653
2654		return 0;
2655	}	}
2656
2657	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1788  int parseSysconfigGrub(int * lbaPtr, cha	Line 2702  int parseSysconfigGrub(int * lbaPtr, cha
2702	}	}
2703
2704	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2705	char * boot;	char * boot = NULL;
2706	int lba;	int lba;
2707
2708	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2709	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2710	if (boot) printf("boot=%s\n", boot);	free(boot);
2711		return;
2712		}
2713		} else {
2714		if (parseSysconfigGrub(&lba, &boot)) {
2715		free(boot);
2716		return;
2717		}
2718		}
2719
2720		if (lba) printf("lba\n");
2721		if (boot) {
2722		printf("boot=%s\n", boot);
2723		free(boot);
2724	}	}
2725	}	}
2726
#	Line 1842  struct singleLine * addLineTmpl(struct s	Line 2769  struct singleLine * addLineTmpl(struct s
2769	{	{
2770	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2771
2772		if (isEfi && cfi == &grub2ConfigType) {
2773		enum lineType_e old = newLine->type;
2774		newLine->type = preferredLineType(newLine->type, cfi);
2775		if (old != newLine->type)
2776		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2777		}
2778
2779	if (val) {	if (val) {
2780	/* override the inherited value with our own.	/* override the inherited value with our own.
2781	* 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 1851  struct singleLine * addLineTmpl(struct s	Line 2785  struct singleLine * addLineTmpl(struct s
2785	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2786
2787	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2788	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)) {
2789	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2790	if (rootspec != NULL) {	if (rootspec != NULL) {
2791	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 1888  struct singleLine *  addLine(struct sing	Line 2822  struct singleLine *  addLine(struct sing
2822	/* 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
2823	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2824	*/	*/
2825	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2826	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2827	tmpl.type = type;	tmpl.type = type;
#	Line 1992  void removeLine(struct singleEntry * ent	Line 2925  void removeLine(struct singleEntry * ent
2925	free(line);	free(line);
2926	}	}
2927
	static int isquote(char q)
	{
	if (q == '\'' || q == '\"')
	return 1;
	return 0;
	}
2928	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2929	{	{
2930	struct singleLine newLine = {	struct singleLine newLine = {
#	Line 2229  int updateActualImage(struct grubConfig	Line 3155  int updateActualImage(struct grubConfig
3155	firstElement = 2;	firstElement = 2;
3156
3157	} else {	} else {
3158	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3159	if (!line) {	if (!line) {
3160	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3161	continue;	continue;
#	Line 2385  int updateImage(struct grubConfig * cfg,	Line 3311  int updateImage(struct grubConfig * cfg,
3311	return rc;	return rc;
3312	}	}
3313
3314		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3315		const char * image, const char * prefix, const char * initrd,
3316		const char * title) {
3317		struct singleEntry * entry;
3318		struct singleLine * line, * kernelLine, *endLine = NULL;
3319		int index = 0;
3320
3321		if (!image) return 0;
3322
3323		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3324		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3325		if (!kernelLine) continue;
3326
3327		/* if title is supplied, the entry's title must match it. */
3328		if (title) {
3329		char *linetitle;
3330
3331		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3332		if (!line)
3333		continue;
3334
3335		linetitle = extractTitle(line);
3336		if (!linetitle)
3337		continue;
3338		if (strcmp(title, linetitle)) {
3339		free(linetitle);
3340		continue;
3341		}
3342		free(linetitle);
3343		}
3344
3345		if (prefix) {
3346		int prefixLen = strlen(prefix);
3347		if (!strncmp(initrd, prefix, prefixLen))
3348		initrd += prefixLen;
3349		}
3350		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3351		if (endLine)
3352		removeLine(entry, endLine);
3353		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3354		kernelLine->indent, initrd);
3355		if (!line)
3356		return 1;
3357		if (endLine) {
3358		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3359		if (!line)
3360		return 1;
3361		}
3362
3363		break;
3364		}
3365
3366		return 0;
3367		}
3368
3369	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3370	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd, const char * title) {
3371	struct singleEntry * entry;	struct singleEntry * entry;
3372	struct singleLine * line, * kernelLine, *endLine = NULL;	struct singleLine * line, * kernelLine, *endLine = NULL;
3373	int index = 0;	int index = 0;
#	Line 2394  int updateInitrd(struct grubConfig * cfg	Line 3375  int updateInitrd(struct grubConfig * cfg
3375	if (!image) return 0;	if (!image) return 0;
3376
3377	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3378	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3379	if (!kernelLine) continue;	if (!kernelLine) continue;
3380
3381	line = getLineByType(LT_INITRD, entry->lines);	/* if title is supplied, the entry's title must match it. */
3382		if (title) {
3383		char *linetitle;
3384
3385		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3386		if (!line)
3387		continue;
3388
3389		linetitle = extractTitle(line);
3390		if (!linetitle)
3391		continue;
3392		if (strcmp(title, linetitle)) {
3393		free(linetitle);
3394		continue;
3395		}
3396		free(linetitle);
3397		}
3398
3399		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3400	if (line)	if (line)
3401	removeLine(entry, line);	removeLine(entry, line);
3402	if (prefix) {	if (prefix) {
#	Line 2408  int updateInitrd(struct grubConfig * cfg	Line 3407  int updateInitrd(struct grubConfig * cfg
3407	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3408	if (endLine)	if (endLine)
3409	removeLine(entry, endLine);	removeLine(entry, endLine);
3410	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3411		switch(kernelLine->type) {
3412		case LT_KERNEL:
3413		lt = LT_INITRD;
3414		break;
3415		case LT_KERNEL_EFI:
3416		lt = LT_INITRD_EFI;
3417		break;
3418		case LT_KERNEL_16:
3419		lt = LT_INITRD_16;
3420		break;
3421		default:
3422		lt = preferredLineType(LT_INITRD, cfg->cfi);
3423		}
3424		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3425	if (!line)	if (!line)
3426	return 1;	return 1;
3427	if (endLine) {	if (endLine) {
#	Line 2446  int checkDeviceBootloader(const char * d	Line 3459  int checkDeviceBootloader(const char * d
3459	if (memcmp(boot, bootSect, 3))	if (memcmp(boot, bootSect, 3))
3460	return 0;	return 0;
3461
3462	if (boot[1] == 0xeb) {	if (boot[1] == JMP_SHORT_OPCODE) {
3463	offset = boot[2] + 2;	offset = boot[2] + 2;
3464	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3465	offset = (boot[3] << 8) + boot[2] + 2;	offset = (boot[3] << 8) + boot[2] + 2;
3466	} else if (boot[0] == 0xeb) {	} else if (boot[0] == JMP_SHORT_OPCODE) {
3467	offset = boot[1] + 2;	offset = boot[1] + 2;
3468		/*
3469		* it looks like grub, when copying stage1 into the mbr, patches stage1
3470		* right after the JMP location, replacing other instructions such as
3471		* JMPs for NOOPs. So, relax the check a little bit by skipping those
3472		* different bytes.
3473		*/
3474		if ((bootSect[offset + 1] == NOOP_OPCODE)
3475		&& (bootSect[offset + 2] == NOOP_OPCODE)) {
3476		offset = offset + 3;
3477		}
3478	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
3479	offset = (boot[2] << 8) + boot[1] + 2;	offset = (boot[2] << 8) + boot[1] + 2;
3480	} else {	} else {
#	Line 2604  int checkForGrub(struct grubConfig * con	Line 3627  int checkForGrub(struct grubConfig * con
3627	int fd;	int fd;
3628	unsigned char bootSect[512];	unsigned char bootSect[512];
3629	char * boot;	char * boot;
3630		int onSuse = isSuseSystem();
3631
3632	if (parseSysconfigGrub(NULL, &boot))
3633	return 0;	if (onSuse) {
3634		if (parseSuseGrubConf(NULL, &boot))
3635		return 0;
3636		} else {
3637		if (parseSysconfigGrub(NULL, &boot))
3638		return 0;
3639		}
3640
3641	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3642	if (!boot)	if (!boot)
#	Line 2625  int checkForGrub(struct grubConfig * con	Line 3655  int checkForGrub(struct grubConfig * con
3655	}	}
3656	close(fd);	close(fd);
3657
3658		/* The more elaborate checks do not work on SuSE. The checks done
3659		* seem to be reasonble (at least for now), so just return success
3660		*/
3661		if (onSuse)
3662		return 2;
3663
3664	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3665	}	}
3666
#	Line 2658  int checkForExtLinux(struct grubConfig *	Line 3694  int checkForExtLinux(struct grubConfig *
3694	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3695	}	}
3696
3697		int checkForYaboot(struct grubConfig * config) {
3698		/*
3699		* This is a simplistic check that we consider good enough for own puporses
3700		*
3701		* If we were to properly check if yaboot is *installed* we'd need to:
3702		* 1) get the system boot device (LT_BOOT)
3703		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3704		*    the content on the boot device
3705		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3706		* 4) check again if binary and boot device contents match
3707		*/
3708		if (!access("/etc/yaboot.conf", R_OK))
3709		return 2;
3710
3711		return 1;
3712		}
3713
3714		int checkForElilo(struct grubConfig * config) {
3715		if (!access("/etc/elilo.conf", R_OK))
3716		return 2;
3717
3718		return 1;
3719		}
3720
3721	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3722	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3723
#	Line 2672  static char * getRootSpecifier(char * st	Line 3732  static char * getRootSpecifier(char * st
3732	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3733	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3734	const char * newKernelInitrd,	const char * newKernelInitrd,
3735	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3736	{	{
3737	char *initrdVal, *end;	char *initrdVal, *end;
3738	int i;	int i;
#	Line 2717  static char * getInitrdVal(struct grubCo	Line 3777  static char * getInitrdVal(struct grubCo
3777
3778	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3779	const char * prefix,	const char * prefix,
3780	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3781	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3782	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3783	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3784		const char * newDevTreePath) {
3785	struct singleEntry * new;	struct singleEntry * new;
3786	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3787	int needs;	int needs;
#	Line 2761  int addNewKernel(struct grubConfig * con	Line 3822  int addNewKernel(struct grubConfig * con
3822	needs |= NEED_MB;	needs |= NEED_MB;
3823	new->multiboot = 1;	new->multiboot = 1;
3824	}	}
3825		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3826		needs |= NEED_DEVTREE;
3827
3828	if (template) {	if (template) {
3829	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2774  int addNewKernel(struct grubConfig * con	Line 3837  int addNewKernel(struct grubConfig * con
3837	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3838	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3839
3840	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3841	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3842	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3843	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 2852  int addNewKernel(struct grubConfig * con	Line 3914  int addNewKernel(struct grubConfig * con
3914	/* template is multi but new is not,	/* template is multi but new is not,
3915	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3916	*/	*/
3917	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3918	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3919	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3920	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3921		config->cfi)->key);
3922	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3923	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3924		config->cfi);
3925	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3926	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3927	char *initrdVal;	char *initrdVal;
3928	/* template is multi but new is not,	/* template is multi but new is not,
3929	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3930	*/	*/
3931	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3932	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3933	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3934	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3935		config->cfi)->key);
3936	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3937	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3938	free(initrdVal);	free(initrdVal);
3939	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3940	}	}
3941
3942	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3943	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3944	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3945	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 2926  int addNewKernel(struct grubConfig * con	Line 3990  int addNewKernel(struct grubConfig * con
3990	}	}
3991	} else if (tmplLine->type == LT_ECHO) {	} else if (tmplLine->type == LT_ECHO) {
3992	requote(tmplLine, config->cfi);	requote(tmplLine, config->cfi);
3993		static const char *prefix = "'Loading ";
3994	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
3995	strstr(tmplLine->elements[1].item, "'Loading Linux ")) {	strstr(tmplLine->elements[1].item, prefix) &&
3996	char *prefix = "'Loading ";	masterLine->next &&
3997		iskernel(masterLine->next->type)) {
3998	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
3999	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
4000
#	Line 2943  int addNewKernel(struct grubConfig * con	Line 4009  int addNewKernel(struct grubConfig * con
4009	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4010	config->cfi);	config->cfi);
4011	}	}
4012		} else if (tmplLine->type == LT_DEVTREE &&
4013		tmplLine->numElements == 2 && newDevTreePath) {
4014		newLine = addLineTmpl(new, tmplLine, newLine,
4015		newDevTreePath + strlen(prefix),
4016		config->cfi);
4017		needs &= ~NEED_DEVTREE;
4018		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4019		const char *ndtp = newDevTreePath;
4020		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4021		ndtp += strlen(prefix);
4022		newLine = addLine(new, config->cfi, LT_DEVTREE,
4023		config->secondaryIndent,
4024		ndtp);
4025		needs &= ~NEED_DEVTREE;
4026		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4027	} else {	} else {
4028	/* pass through other lines from the template */	/* pass through other lines from the template */
4029	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 2955  int addNewKernel(struct grubConfig * con	Line 4036  int addNewKernel(struct grubConfig * con
4036	*/	*/
4037	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
4038	case LT_KERNEL:	case LT_KERNEL:
4039		case LT_KERNEL_EFI:
4040		case LT_KERNEL_16:
4041	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4042	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4043	} else {	} else {
4044	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4045		preferredLineType(LT_KERNEL, config->cfi),
4046	config->primaryIndent,	config->primaryIndent,
4047	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4048	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3015  int addNewKernel(struct grubConfig * con	Line 4099  int addNewKernel(struct grubConfig * con
4099	}	}
4100	}	}
4101
4102		struct singleLine *endLine = NULL;
4103		endLine = getLineByType(LT_ENTRY_END, new->lines);
4104		if (endLine) {
4105		removeLine(new, endLine);
4106		needs |= NEED_END;
4107		}
4108
4109	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4110	* 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,
4111	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3034  int addNewKernel(struct grubConfig * con	Line 4125  int addNewKernel(struct grubConfig * con
4125	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4126	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4127	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4128	config->cfi)) ?	config->cfi))
4129	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4130		: preferredLineType(LT_KERNEL, config->cfi),
4131	config->secondaryIndent,	config->secondaryIndent,
4132	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4133	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3051  int addNewKernel(struct grubConfig * con	Line 4143  int addNewKernel(struct grubConfig * con
4143	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4144	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4145	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4146	config->cfi)) ?	config->cfi))
4147	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4148		: preferredLineType(LT_INITRD, config->cfi),
4149	config->secondaryIndent,	config->secondaryIndent,
4150	initrdVal);	initrdVal);
4151	free(initrdVal);	free(initrdVal);
4152	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4153	}	}
4154		if (needs & NEED_DEVTREE) {
4155		newLine = addLine(new, config->cfi, LT_DEVTREE,
4156		config->secondaryIndent,
4157		newDevTreePath);
4158		needs &= ~NEED_DEVTREE;
4159		}
4160
4161		/* NEEDS_END must be last on bootloaders that need it... */
4162	if (needs & NEED_END) {	if (needs & NEED_END) {
4163	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4164	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3084  static void traceback(int signum)	Line 4185  static void traceback(int signum)
4185	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4186	size = backtrace(array, 40);	size = backtrace(array, 40);
4187
4188	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4189	(unsigned long)size);	(unsigned long)size);
4190	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4191	exit(1);	exit(1);
#	Line 3109  int main(int argc, const char ** argv) {	Line 4210  int main(int argc, const char ** argv) {
4210	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4211	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4212	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4213	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4214	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4215	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4216	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3119  int main(int argc, const char ** argv) {	Line 4220  int main(int argc, const char ** argv) {
4220	char * removeArgs = NULL;	char * removeArgs = NULL;
4221	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4222	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4223		char * envPath = NULL;
4224	const char * chptr = NULL;	const char * chptr = NULL;
4225	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4226	struct grubConfig * config;	struct grubConfig * config;
4227	struct singleEntry * template = NULL;	struct singleEntry * template = NULL;
4228	int copyDefault = 0, makeDefault = 0;	int copyDefault = 0, makeDefault = 0;
4229	int displayDefault = 0;	int displayDefault = 0;
4230		int displayDefaultIndex = 0;
4231		int displayDefaultTitle = 0;
4232		int defaultIndex = -1;
4233	struct poptOption options[] = {	struct poptOption options[] = {
4234	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4235	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3142  int main(int argc, const char ** argv) {	Line 4247  int main(int argc, const char ** argv) {
4247	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4248	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4249	_("bootfs") },	_("bootfs") },
4250	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4251	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4252	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4253	#endif	#endif
4254	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4255	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3155  int main(int argc, const char ** argv) {	Line 4260  int main(int argc, const char ** argv) {
4260	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4261	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4262	"template"), NULL },	"template"), NULL },
4263		{ "debug", 0, 0, &debug, 0,
4264		_("print debugging information for failures") },
4265	{ "default-kernel", 0, 0, &displayDefault, 0,	{ "default-kernel", 0, 0, &displayDefault, 0,
4266	_("display the path of the default kernel") },	_("display the path of the default kernel") },
4267		{ "default-index", 0, 0, &displayDefaultIndex, 0,
4268		_("display the index of the default kernel") },
4269		{ "default-title", 0, 0, &displayDefaultTitle, 0,
4270		_("display the title of the default kernel") },
4271		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4272		_("device tree file for new stanza"), _("dtb-path") },
4273		{ "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4274		_("device tree directory for new stanza"), _("dtb-path") },
4275	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4276	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4277		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4278		_("force grub2 stanzas to use efi") },
4279		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4280		_("path for environment data"),
4281		_("path") },
4282	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4283	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4284	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3171  int main(int argc, const char ** argv) {	Line 4291  int main(int argc, const char ** argv) {
4291	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4292	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4293	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4294	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4295	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4296	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4297	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3191  int main(int argc, const char ** argv) {	Line 4311  int main(int argc, const char ** argv) {
4311	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4312	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4313	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4314		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4315		_("make the given entry index the default entry"),
4316		_("entry-index") },
4317	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4318	_("configure silo bootloader") },	_("configure silo bootloader") },
4319	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3212  int main(int argc, const char ** argv) {	Line 4335  int main(int argc, const char ** argv) {
4335
4336	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4337
4338		int i = 0;
4339		for (int j = 1; j < argc; j++)
4340		i += strlen(argv[j]) + 1;
4341		saved_command_line = malloc(i);
4342		if (!saved_command_line) {
4343		fprintf(stderr, "grubby: %m\n");
4344		exit(1);
4345		}
4346		saved_command_line[0] = '\0';
4347		for (int j = 1; j < argc; j++) {
4348		strcat(saved_command_line, argv[j]);
4349		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4350		}
4351
4352	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4353	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4354
#	Line 3255  int main(int argc, const char ** argv) {	Line 4392  int main(int argc, const char ** argv) {
4392	return 1;	return 1;
4393	} else if (configureGrub2) {	} else if (configureGrub2) {
4394	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4395		if (envPath)
4396		cfi->envFile = envPath;
4397	} else if (configureLilo) {	} else if (configureLilo) {
4398	cfi = &liloConfigType;	cfi = &liloConfigType;
4399	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3273  int main(int argc, const char ** argv) {	Line 4412  int main(int argc, const char ** argv) {
4412	}	}
4413
4414	if (!cfi) {	if (!cfi) {
4415		if (grub2FindConfig(&grub2ConfigType))
4416		cfi = &grub2ConfigType;
4417		else
4418	#ifdef __ia64__	#ifdef __ia64__
4419	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4420	#elif __powerpc__	#elif __powerpc__
4421	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4422	#elif __sparc__	#elif __sparc__
4423	cfi = &siloConfigType;	cfi = &siloConfigType;
4424	#elif __s390__	#elif __s390__
4425	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4426	#elif __s390x__	#elif __s390x__
4427	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4428	#else	#else
	if (grub2FindConfig(&grub2ConfigType))
	cfi = &grub2ConfigType;
	else
4429	cfi = &grubConfigType;	cfi = &grubConfigType;
4430	#endif	#endif
4431	}	}
#	Line 3298  int main(int argc, const char ** argv) {	Line 4437  int main(int argc, const char ** argv) {
4437	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4438	}	}
4439
4440	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4441	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4442	defaultKernel)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4443		(defaultIndex >= 0))) {
4444	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4445	"specified option"));	"specified option"));
4446	return 1;	return 1;
4447	}	}
4448
4449	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4450	removeKernelPath)) {	removeKernelPath)) {
4451	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4452	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3316  int main(int argc, const char ** argv) {	Line 4456  int main(int argc, const char ** argv) {
4456	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4457	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4458	return 1;	return 1;
4459	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4460	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4461	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4462	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3342  int main(int argc, const char ** argv) {	Line 4482  int main(int argc, const char ** argv) {
4482	makeDefault = 1;	makeDefault = 1;
4483	defaultKernel = NULL;	defaultKernel = NULL;
4484	}	}
4485		else if (defaultKernel && (defaultIndex >= 0)) {
4486		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4487		"may not be used together\n"));
4488		return 1;
4489		}
4490
4491	if (!strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4492	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
4493	"is used\n"));	"is used\n"));
4494	return 1;	return 1;
4495	}	}
4496
4497	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4498	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4499	&& !removeMBKernel) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4500		&& (defaultIndex == -1)) {
4501	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4502	return 1;	return 1;
4503	}	}
#	Line 3378  int main(int argc, const char ** argv) {	Line 4524  int main(int argc, const char ** argv) {
4524	}	}
4525
4526	if (bootloaderProbe) {	if (bootloaderProbe) {
4527	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4528	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4529
4530	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4531	if (grub2config) {	if (grub2config) {
#	Line 3390  int main(int argc, const char ** argv) {	Line 4536  int main(int argc, const char ** argv) {
4536	gr2c = checkForGrub2(gconfig);	gr2c = checkForGrub2(gconfig);
4537	}	}
4538
4539	if (!access(grubConfigType.defaultConfig, F_OK)) {	const char *grubconfig = grubFindConfig(&grubConfigType);
4540	gconfig = readConfig(grubConfigType.defaultConfig, &grubConfigType);	if (!access(grubconfig, F_OK)) {
4541		gconfig = readConfig(grubconfig, &grubConfigType);
4542	if (!gconfig)	if (!gconfig)
4543	grc = 1;	grc = 1;
4544	else	else
#	Line 3406  int main(int argc, const char ** argv) {	Line 4553  int main(int argc, const char ** argv) {
4553	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4554	}	}
4555
4556		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4557		econfig = readConfig(eliloConfigType.defaultConfig,
4558		&eliloConfigType);
4559		if (!econfig)
4560		erc = 1;
4561		else
4562		erc = checkForElilo(econfig);
4563		}
4564
4565	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4566	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4567	if (!lconfig)	if (!lconfig)
4568	erc = 1;	extrc = 1;
4569	else	else
4570	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4571	}	}
4572
4573	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4574		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4575		yconfig = readConfig(yabootConfigType.defaultConfig,
4576		&yabootConfigType);
4577		if (!yconfig)
4578		yrc = 1;
4579		else
4580		yrc = checkForYaboot(yconfig);
4581		}
4582
4583		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4584		erc == 1)
4585		return 1;
4586
4587	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4588	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4589	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4590	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4591		if (yrc == 2) printf("yaboot\n");
4592		if (erc == 2) printf("elilo\n");
4593
4594	return 0;	return 0;
4595	}	}
4596
4597		if (grubConfig == NULL) {
4598		printf("Could not find bootloader configuration file.\n");
4599		exit(1);
4600		}
4601
4602	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4603	if (!config) return 1;	if (!config) return 1;
4604
#	Line 3433  int main(int argc, const char ** argv) {	Line 4608  int main(int argc, const char ** argv) {
4608	char * rootspec;	char * rootspec;
4609
4610	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4611		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4612		cfi->defaultIsSaved)
4613		config->defaultImage = 0;
4614	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4615	if (!entry) return 0;	if (!entry) return 0;
4616	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4617
4618	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4619	if (!line) return 0;	if (!line) return 0;
4620
4621	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3445  int main(int argc, const char ** argv) {	Line 4623  int main(int argc, const char ** argv) {
4623	((rootspec != NULL) ? strlen(rootspec) : 0));	((rootspec != NULL) ? strlen(rootspec) : 0));
4624
4625	return 0;	return 0;
4626
4627		} else if (displayDefaultTitle) {
4628		struct singleLine * line;
4629		struct singleEntry * entry;
4630
4631		if (config->defaultImage == -1) return 0;
4632		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4633		cfi->defaultIsSaved)
4634		config->defaultImage = 0;
4635		entry = findEntryByIndex(config, config->defaultImage);
4636		if (!entry) return 0;
4637
4638		if (!configureGrub2) {
4639		line = getLineByType(LT_TITLE, entry->lines);
4640		if (!line) return 0;
4641		printf("%s\n", line->elements[1].item);
4642
4643		} else {
4644		char * title;
4645
4646		dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4647		line = getLineByType(LT_MENUENTRY, entry->lines);
4648		if (!line) return 0;
4649		title = grub2ExtractTitle(line);
4650		if (title)
4651		printf("%s\n", title);
4652		}
4653		return 0;
4654
4655		} else if (displayDefaultIndex) {
4656		if (config->defaultImage == -1) return 0;
4657		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4658		cfi->defaultIsSaved)
4659		config->defaultImage = 0;
4660		printf("%i\n", config->defaultImage);
4661		return 0;
4662
4663	} else if (kernelInfo)	} else if (kernelInfo)
4664	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
4665
#	Line 3456  int main(int argc, const char ** argv) {	Line 4671  int main(int argc, const char ** argv) {
4671	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4672	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4673	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4674	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4675	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4676	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4677	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4678	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4679	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4680	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4681		bootPrefix, newKernelInitrd,
4682		newKernelTitle))
4683		return 1;
4684		} else {
4685		if (updateInitrd(config, updateKernelPath, bootPrefix,
4686		newKernelInitrd, newKernelTitle))
4687		return 1;
4688		}
4689	}	}
4690	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4691	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4692	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4693	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4694
4695
4696	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.1714   changed lines   Added in v.2977